src/share/vm/interpreter/abstractInterpreter.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File 8074457 Sdiff src/share/vm/interpreter

src/share/vm/interpreter/abstractInterpreter.hpp

Print this page




  45 //
  46 // templateInterpreter*          cppInterpreter*        generation of assembly code that creates
  47 //                                                      and manages interpreter runtime frames.
  48 //                                                      Also code for populating interpreter
  49 //                                                      frames created during deoptimization.
  50 //
  51 // For both template and c++ interpreter. There are common files for aspects of the interpreter
  52 // that are generic to both interpreters. This is the layout:
  53 //
  54 // abstractInterpreter.hpp: generic description of the interpreter.
  55 // interpreter*:            generic frame creation and handling.
  56 //
  57 
  58 //------------------------------------------------------------------------------------------------------------------------
  59 // The C++ interface to the bytecode interpreter(s).
  60 
  61 class InterpreterMacroAssembler;
  62 
  63 class AbstractInterpreter: AllStatic {
  64   friend class VMStructs;
  65   friend class Interpreter;
  66   friend class CppInterpreterGenerator;

  67  public:
  68   enum MethodKind {
  69     zerolocals,                                                 // method needs locals initialization
  70     zerolocals_synchronized,                                    // method needs locals initialization & is synchronized
  71     native,                                                     // native method
  72     native_synchronized,                                        // native method & is synchronized
  73     empty,                                                      // empty method (code: _return)
  74     accessor,                                                   // accessor method (code: _aload_0, _getfield, _(a|i)return)
  75     abstract,                                                   // abstract method (throws an AbstractMethodException)
  76     method_handle_invoke_FIRST,                                 // java.lang.invoke.MethodHandles::invokeExact, etc.
  77     method_handle_invoke_LAST                                   = (method_handle_invoke_FIRST
  78                                                                    + (vmIntrinsics::LAST_MH_SIG_POLY
  79                                                                       - vmIntrinsics::FIRST_MH_SIG_POLY)),
  80     java_lang_math_sin,                                         // implementation of java.lang.Math.sin   (x)
  81     java_lang_math_cos,                                         // implementation of java.lang.Math.cos   (x)
  82     java_lang_math_tan,                                         // implementation of java.lang.Math.tan   (x)
  83     java_lang_math_abs,                                         // implementation of java.lang.Math.abs   (x)
  84     java_lang_math_sqrt,                                        // implementation of java.lang.Math.sqrt  (x)
  85     java_lang_math_log,                                         // implementation of java.lang.Math.log   (x)
  86     java_lang_math_log10,                                       // implementation of java.lang.Math.log10 (x)


 111   enum SomeConstants {
 112     number_of_result_handlers = 10                              // number of result handlers for native calls
 113   };
 114 
 115  protected:
 116   static StubQueue* _code;                                      // the interpreter code (codelets)
 117 
 118   static bool       _notice_safepoints;                         // true if safepoints are activated
 119 
 120   static address    _native_entry_begin;                        // Region for native entry code
 121   static address    _native_entry_end;
 122 
 123   // method entry points
 124   static address    _entry_table[number_of_method_entries];     // entry points for a given method
 125   static address    _native_abi_to_tosca[number_of_result_handlers];  // for native method result handlers
 126   static address    _slow_signature_handler;                              // the native method generic (slow) signature handler
 127 
 128   static address    _rethrow_exception_entry;                   // rethrows an activation in previous frame
 129 
 130   friend class      AbstractInterpreterGenerator;
 131   friend class              InterpreterGenerator;
 132   friend class      InterpreterMacroAssembler;
 133 
 134  public:
 135   // Initialization/debugging
 136   static void       initialize();
 137   static StubQueue* code()                                      { return _code; }
 138 
 139 
 140   // Method activation
 141   static MethodKind method_kind(methodHandle m);
 142   static address    entry_for_kind(MethodKind k)                { assert(0 <= k && k < number_of_method_entries, "illegal kind"); return _entry_table[k]; }
 143   static address    entry_for_method(methodHandle m)            { return entry_for_kind(method_kind(m)); }
 144 
 145   // used for bootstrapping method handles:
 146   static void       set_entry_for_kind(MethodKind k, address e);
 147 
 148   static void       print_method_kind(MethodKind kind)          PRODUCT_RETURN;
 149 
 150   static bool       can_be_compiled(methodHandle m);
 151 


 195 
 196   // Runtime support
 197   static bool       is_not_reached(const methodHandle& method, int bci);
 198   // Safepoint support
 199   static void       notice_safepoints()                         { ShouldNotReachHere(); } // stops the thread when reaching a safepoint
 200   static void       ignore_safepoints()                         { ShouldNotReachHere(); } // ignores safepoints
 201 
 202   // Support for native calls
 203   static address    slow_signature_handler()                    { return _slow_signature_handler; }
 204   static address    result_handler(BasicType type)              { return _native_abi_to_tosca[BasicType_as_index(type)]; }
 205   static int        BasicType_as_index(BasicType type);         // computes index into result_handler_by_index table
 206   static bool       in_native_entry(address pc)                 { return _native_entry_begin <= pc && pc < _native_entry_end; }
 207   // Debugging/printing
 208   static void       print();                                    // prints the interpreter code
 209 
 210  public:
 211   // Interpreter helpers
 212   const static int stackElementWords   = 1;
 213   const static int stackElementSize    = stackElementWords * wordSize;
 214   const static int logStackElementSize = LogBytesPerWord;























 215 
 216   // Local values relative to locals[n]
 217   static int  local_offset_in_bytes(int n) {
 218     return ((frame::interpreter_frame_expression_stack_direction() * n) * stackElementSize);
 219   }
 220 
 221   // access to stacked values according to type:
 222   static oop* oop_addr_in_slot(intptr_t* slot_addr) {
 223     return (oop*) slot_addr;
 224   }
 225   static jint* int_addr_in_slot(intptr_t* slot_addr) {
 226     if ((int) sizeof(jint) < wordSize && !Bytes::is_Java_byte_ordering_different())
 227       // big-endian LP64
 228       return (jint*)(slot_addr + 1) - 1;
 229     else
 230       return (jint*) slot_addr;
 231   }
 232   static jlong long_in_slot(intptr_t* slot_addr) {
 233     if (sizeof(intptr_t) >= sizeof(jlong)) {
 234       return *(jlong*) slot_addr;




  45 //
  46 // templateInterpreter*          cppInterpreter*        generation of assembly code that creates
  47 //                                                      and manages interpreter runtime frames.
  48 //                                                      Also code for populating interpreter
  49 //                                                      frames created during deoptimization.
  50 //
  51 // For both template and c++ interpreter. There are common files for aspects of the interpreter
  52 // that are generic to both interpreters. This is the layout:
  53 //
  54 // abstractInterpreter.hpp: generic description of the interpreter.
  55 // interpreter*:            generic frame creation and handling.
  56 //
  57 
  58 //------------------------------------------------------------------------------------------------------------------------
  59 // The C++ interface to the bytecode interpreter(s).
  60 
  61 class InterpreterMacroAssembler;
  62 
  63 class AbstractInterpreter: AllStatic {
  64   friend class VMStructs;

  65   friend class CppInterpreterGenerator;
  66   friend class TemplateInterpreterGenerator;
  67  public:
  68   enum MethodKind {
  69     zerolocals,                                                 // method needs locals initialization
  70     zerolocals_synchronized,                                    // method needs locals initialization & is synchronized
  71     native,                                                     // native method
  72     native_synchronized,                                        // native method & is synchronized
  73     empty,                                                      // empty method (code: _return)
  74     accessor,                                                   // accessor method (code: _aload_0, _getfield, _(a|i)return)
  75     abstract,                                                   // abstract method (throws an AbstractMethodException)
  76     method_handle_invoke_FIRST,                                 // java.lang.invoke.MethodHandles::invokeExact, etc.
  77     method_handle_invoke_LAST                                   = (method_handle_invoke_FIRST
  78                                                                    + (vmIntrinsics::LAST_MH_SIG_POLY
  79                                                                       - vmIntrinsics::FIRST_MH_SIG_POLY)),
  80     java_lang_math_sin,                                         // implementation of java.lang.Math.sin   (x)
  81     java_lang_math_cos,                                         // implementation of java.lang.Math.cos   (x)
  82     java_lang_math_tan,                                         // implementation of java.lang.Math.tan   (x)
  83     java_lang_math_abs,                                         // implementation of java.lang.Math.abs   (x)
  84     java_lang_math_sqrt,                                        // implementation of java.lang.Math.sqrt  (x)
  85     java_lang_math_log,                                         // implementation of java.lang.Math.log   (x)
  86     java_lang_math_log10,                                       // implementation of java.lang.Math.log10 (x)


 111   enum SomeConstants {
 112     number_of_result_handlers = 10                              // number of result handlers for native calls
 113   };
 114 
 115  protected:
 116   static StubQueue* _code;                                      // the interpreter code (codelets)
 117 
 118   static bool       _notice_safepoints;                         // true if safepoints are activated
 119 
 120   static address    _native_entry_begin;                        // Region for native entry code
 121   static address    _native_entry_end;
 122 
 123   // method entry points
 124   static address    _entry_table[number_of_method_entries];     // entry points for a given method
 125   static address    _native_abi_to_tosca[number_of_result_handlers];  // for native method result handlers
 126   static address    _slow_signature_handler;                              // the native method generic (slow) signature handler
 127 
 128   static address    _rethrow_exception_entry;                   // rethrows an activation in previous frame
 129 
 130   friend class      AbstractInterpreterGenerator;

 131   friend class      InterpreterMacroAssembler;
 132 
 133  public:
 134   // Initialization/debugging
 135   static void       initialize();
 136   static StubQueue* code()                                      { return _code; }
 137 
 138 
 139   // Method activation
 140   static MethodKind method_kind(methodHandle m);
 141   static address    entry_for_kind(MethodKind k)                { assert(0 <= k && k < number_of_method_entries, "illegal kind"); return _entry_table[k]; }
 142   static address    entry_for_method(methodHandle m)            { return entry_for_kind(method_kind(m)); }
 143 
 144   // used for bootstrapping method handles:
 145   static void       set_entry_for_kind(MethodKind k, address e);
 146 
 147   static void       print_method_kind(MethodKind kind)          PRODUCT_RETURN;
 148 
 149   static bool       can_be_compiled(methodHandle m);
 150 


 194 
 195   // Runtime support
 196   static bool       is_not_reached(const methodHandle& method, int bci);
 197   // Safepoint support
 198   static void       notice_safepoints()                         { ShouldNotReachHere(); } // stops the thread when reaching a safepoint
 199   static void       ignore_safepoints()                         { ShouldNotReachHere(); } // ignores safepoints
 200 
 201   // Support for native calls
 202   static address    slow_signature_handler()                    { return _slow_signature_handler; }
 203   static address    result_handler(BasicType type)              { return _native_abi_to_tosca[BasicType_as_index(type)]; }
 204   static int        BasicType_as_index(BasicType type);         // computes index into result_handler_by_index table
 205   static bool       in_native_entry(address pc)                 { return _native_entry_begin <= pc && pc < _native_entry_end; }
 206   // Debugging/printing
 207   static void       print();                                    // prints the interpreter code
 208 
 209  public:
 210   // Interpreter helpers
 211   const static int stackElementWords   = 1;
 212   const static int stackElementSize    = stackElementWords * wordSize;
 213   const static int logStackElementSize = LogBytesPerWord;
 214 
 215   static int expr_index_at(int i) {
 216     return stackElementWords * i;
 217   }
 218 
 219   static int expr_offset_in_bytes(int i) {
 220 #if defined(TARGET_ARCH_ppc) || defined(TARGET_ARCH_sparc)
 221     return stackElementSize * i + wordSize;  // both point to one word past TOS
 222 #else
 223     return stackElementSize * i;
 224 #endif
 225   }
 226 
 227   static int local_index_at(int i) {
 228     assert(i <= 0, "local direction already negated");
 229     return stackElementWords * i;
 230   }
 231 
 232 #ifdef TARGET_ARCH_x86
 233   static Address::ScaleFactor stackElementScale() {
 234     return NOT_LP64(Address::times_4) LP64_ONLY(Address::times_8);
 235   }
 236 #endif
 237 
 238   // Local values relative to locals[n]
 239   static int  local_offset_in_bytes(int n) {
 240     return ((frame::interpreter_frame_expression_stack_direction() * n) * stackElementSize);
 241   }
 242 
 243   // access to stacked values according to type:
 244   static oop* oop_addr_in_slot(intptr_t* slot_addr) {
 245     return (oop*) slot_addr;
 246   }
 247   static jint* int_addr_in_slot(intptr_t* slot_addr) {
 248     if ((int) sizeof(jint) < wordSize && !Bytes::is_Java_byte_ordering_different())
 249       // big-endian LP64
 250       return (jint*)(slot_addr + 1) - 1;
 251     else
 252       return (jint*) slot_addr;
 253   }
 254   static jlong long_in_slot(intptr_t* slot_addr) {
 255     if (sizeof(intptr_t) >= sizeof(jlong)) {
 256       return *(jlong*) slot_addr;


src/share/vm/interpreter/abstractInterpreter.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File