< prev index next >

src/hotspot/cpu/sparc/macroAssembler_sparc.hpp


557  public:                                                                                                                             
558   MacroAssembler(CodeBuffer* code) : Assembler(code) {}                                                                              
559 
560   // This routine should emit JVMTI PopFrame and ForceEarlyReturn handling code.                                                     
561   // The implementation is only non-empty for the InterpreterMacroAssembler,                                                         
562   // as only the interpreter handles and ForceEarlyReturn PopFrame requests.                                                         
563   virtual void check_and_handle_popframe(Register scratch_reg);                                                                      
564   virtual void check_and_handle_earlyret(Register scratch_reg);                                                                      
565 
566   // Support for NULL-checks                                                                                                         
567   //                                                                                                                                 
568   // Generates code that causes a NULL OS exception if the content of reg is NULL.                                                   
569   // If the accessed location is M[reg + offset] and the offset is known, provide the                                                
570   // offset.  No explicit code generation is needed if the offset is within a certain                                                
571   // range (0 <= offset <= page_size).                                                                                               
572   //                                                                                                                                 
573   // FIXME: Currently not done for SPARC                                                                                             
574 
575   void null_check(Register reg, int offset = -1);                                                                                    
576   static bool needs_explicit_null_check(intptr_t offset);                                                                            
                                                                                                                                     
577 
578   // support for delayed instructions                                                                                                
579   MacroAssembler* delayed() { Assembler::delayed();  return this; }                                                                  
580 
581   // branches that use right instruction for v8 vs. v9                                                                               
582   inline void br( Condition c, bool a, Predict p, address d, relocInfo::relocType rt = relocInfo::none );                            
583   inline void br( Condition c, bool a, Predict p, Label& L );                                                                        
584 
585   inline void fb( Condition c, bool a, Predict p, address d, relocInfo::relocType rt = relocInfo::none );                            
586   inline void fb( Condition c, bool a, Predict p, Label& L );                                                                        
587 
588   // compares register with zero (32 bit) and branches (V9 and V8 instructions)                                                      
589   void cmp_zero_and_br( Condition c, Register s1, Label& L, bool a = false, Predict p = pn );                                        
590   // Compares a pointer register with zero and branches on (not)null.                                                                
591   // Does a test & branch on 32-bit systems and a register-branch on 64-bit.                                                         
592   void br_null   ( Register s1, bool a, Predict p, Label& L );                                                                       
593   void br_notnull( Register s1, bool a, Predict p, Label& L );                                                                       
594 
595   //                                                                                                                                 

557  public:
558   MacroAssembler(CodeBuffer* code) : Assembler(code) {}
559 
560   // This routine should emit JVMTI PopFrame and ForceEarlyReturn handling code.
561   // The implementation is only non-empty for the InterpreterMacroAssembler,
562   // as only the interpreter handles and ForceEarlyReturn PopFrame requests.
563   virtual void check_and_handle_popframe(Register scratch_reg);
564   virtual void check_and_handle_earlyret(Register scratch_reg);
565 
566   // Support for NULL-checks
567   //
568   // Generates code that causes a NULL OS exception if the content of reg is NULL.
569   // If the accessed location is M[reg + offset] and the offset is known, provide the
570   // offset.  No explicit code generation is needed if the offset is within a certain
571   // range (0 <= offset <= page_size).
572   //
573   // FIXME: Currently not done for SPARC
574 
575   void null_check(Register reg, int offset = -1);
576   static bool needs_explicit_null_check(intptr_t offset);
577   static bool uses_implicit_null_check(void* address);
578 
579   // support for delayed instructions
580   MacroAssembler* delayed() { Assembler::delayed();  return this; }
581 
582   // branches that use right instruction for v8 vs. v9
583   inline void br( Condition c, bool a, Predict p, address d, relocInfo::relocType rt = relocInfo::none );
584   inline void br( Condition c, bool a, Predict p, Label& L );
585 
586   inline void fb( Condition c, bool a, Predict p, address d, relocInfo::relocType rt = relocInfo::none );
587   inline void fb( Condition c, bool a, Predict p, Label& L );
588 
589   // compares register with zero (32 bit) and branches (V9 and V8 instructions)
590   void cmp_zero_and_br( Condition c, Register s1, Label& L, bool a = false, Predict p = pn );
591   // Compares a pointer register with zero and branches on (not)null.
592   // Does a test & branch on 32-bit systems and a register-branch on 64-bit.
593   void br_null   ( Register s1, bool a, Predict p, Label& L );
594   void br_notnull( Register s1, bool a, Predict p, Label& L );
595 
596   //
< prev index next >