< prev index next >

src/hotspot/cpu/aarch64/interp_masm_aarch64.hpp

Print this page

 28 
 29 #include "asm/macroAssembler.hpp"
 30 #include "interpreter/invocationCounter.hpp"
 31 #include "runtime/frame.hpp"
 32 
 33 // This file specializes the assembler with interpreter-specific macros
 34 
 35 typedef ByteSize (*OffsetFunction)(uint);
 36 
 37 class InterpreterMacroAssembler: public MacroAssembler {
 38  protected:
 39   // Interpreter specific version of call_VM_base
 40   using MacroAssembler::call_VM_leaf_base;
 41 
 42   virtual void call_VM_leaf_base(address entry_point,
 43                                  int number_of_arguments);
 44 
 45   virtual void call_VM_base(Register oop_result,
 46                             Register java_thread,
 47                             Register last_java_sp,

 48                             address  entry_point,
 49                             int number_of_arguments,
 50                             bool check_exceptions);
 51 
 52   // base routine for all dispatches
 53   void dispatch_base(TosState state, address* table,
 54                      bool verifyoop = true, bool generate_poll = false);
 55 
 56  public:
 57   InterpreterMacroAssembler(CodeBuffer* code) : MacroAssembler(code) {}
 58 
 59   void load_earlyret_value(TosState state);
 60 

 61   void call_VM_preemptable(Register oop_result,
 62                            address entry_point,
 63                            Register arg_1);






 64   void restore_after_resume(bool is_native);





 65 

 66   void jump_to_entry(address entry);
 67 
 68   virtual void check_and_handle_popframe(Register java_thread);
 69   virtual void check_and_handle_earlyret(Register java_thread);
 70 
 71   // Interpreter-specific registers
 72   void save_bcp() {
 73     str(rbcp, Address(rfp, frame::interpreter_frame_bcp_offset * wordSize));
 74   }
 75 
 76   void restore_bcp() {
 77     ldr(rbcp, Address(rfp, frame::interpreter_frame_bcp_offset * wordSize));
 78   }
 79 
 80   void restore_locals() {
 81     ldr(rlocals, Address(rfp, frame::interpreter_frame_locals_offset * wordSize));
 82     lea(rlocals, Address(rfp, rlocals, Address::lsl(3)));
 83   }
 84 
 85   void restore_constant_pool_cache() {

 28 
 29 #include "asm/macroAssembler.hpp"
 30 #include "interpreter/invocationCounter.hpp"
 31 #include "runtime/frame.hpp"
 32 
 33 // This file specializes the assembler with interpreter-specific macros
 34 
 35 typedef ByteSize (*OffsetFunction)(uint);
 36 
 37 class InterpreterMacroAssembler: public MacroAssembler {
 38  protected:
 39   // Interpreter specific version of call_VM_base
 40   using MacroAssembler::call_VM_leaf_base;
 41 
 42   virtual void call_VM_leaf_base(address entry_point,
 43                                  int number_of_arguments);
 44 
 45   virtual void call_VM_base(Register oop_result,
 46                             Register java_thread,
 47                             Register last_java_sp,
 48                             Label*   return_pc,
 49                             address  entry_point,
 50                             int number_of_arguments,
 51                             bool check_exceptions);
 52 
 53   // base routine for all dispatches
 54   void dispatch_base(TosState state, address* table,
 55                      bool verifyoop = true, bool generate_poll = false);
 56 
 57  public:
 58   InterpreterMacroAssembler(CodeBuffer* code) : MacroAssembler(code) {}
 59 
 60   void load_earlyret_value(TosState state);
 61 
 62   // Use for vthread preemption
 63   void call_VM_preemptable(Register oop_result,
 64                            address entry_point,
 65                            Register arg_1,
 66                            bool check_exceptions = true);
 67   void call_VM_preemptable(Register oop_result,
 68                            address entry_point,
 69                            Register arg_1,
 70                            Register arg_2,
 71                            bool check_exceptions = true);
 72   void restore_after_resume(bool is_native);
 73  private:
 74   void call_VM_preemptable_helper(Register oop_result,
 75                                   address entry_point,
 76                                   int number_of_arguments,
 77                                   bool check_exceptions);
 78 
 79  public:
 80   void jump_to_entry(address entry);
 81 
 82   virtual void check_and_handle_popframe(Register java_thread);
 83   virtual void check_and_handle_earlyret(Register java_thread);
 84 
 85   // Interpreter-specific registers
 86   void save_bcp() {
 87     str(rbcp, Address(rfp, frame::interpreter_frame_bcp_offset * wordSize));
 88   }
 89 
 90   void restore_bcp() {
 91     ldr(rbcp, Address(rfp, frame::interpreter_frame_bcp_offset * wordSize));
 92   }
 93 
 94   void restore_locals() {
 95     ldr(rlocals, Address(rfp, frame::interpreter_frame_locals_offset * wordSize));
 96     lea(rlocals, Address(rfp, rlocals, Address::lsl(3)));
 97   }
 98 
 99   void restore_constant_pool_cache() {
< prev index next >