< prev index next >

src/hotspot/share/interpreter/templateInterpreter.hpp

Print this page




 100   };
 101 
 102  protected:
 103 
 104   static address    _throw_ArrayIndexOutOfBoundsException_entry;
 105   static address    _throw_ArrayStoreException_entry;
 106   static address    _throw_ArithmeticException_entry;
 107   static address    _throw_ClassCastException_entry;
 108   static address    _throw_NullPointerException_entry;
 109   static address    _throw_exception_entry;
 110 
 111   static address    _throw_StackOverflowError_entry;
 112 
 113   static address    _remove_activation_entry;                   // continuation address if an exception is not handled by current frame
 114   static address    _remove_activation_preserving_args_entry;   // continuation address when current frame is being popped
 115 
 116 #ifndef PRODUCT
 117   static EntryPoint _trace_code;
 118 #endif // !PRODUCT
 119   static EntryPoint _return_entry[number_of_return_entries];    // entry points to return to from a call

 120   static EntryPoint _earlyret_entry;                            // entry point to return early from a call
 121   static EntryPoint _deopt_entry[number_of_deopt_entries];      // entry points to return to from a deoptimization
 122   static address    _deopt_reexecute_return_entry;
 123   static EntryPoint _safept_entry;
 124 
 125   static address _invoke_return_entry[number_of_return_addrs];           // for invokestatic, invokespecial, invokevirtual return entries

 126   static address _invokeinterface_return_entry[number_of_return_addrs];  // for invokeinterface return entries
 127   static address _invokedynamic_return_entry[number_of_return_addrs];    // for invokedynamic return entries
 128 
 129   static DispatchTable _active_table;                           // the active    dispatch table (used by the interpreter for dispatch)
 130   static DispatchTable _normal_table;                           // the normal    dispatch table (used to set the active table in normal mode)
 131   static DispatchTable _safept_table;                           // the safepoint dispatch table (used to set the active table for safepoints)
 132   static address       _wentry_point[DispatchTable::length];    // wide instructions only (vtos tosca always)
 133 
 134 
 135  public:
 136   // Initialization/debugging
 137   static void       initialize();
 138   // this only returns whether a pc is within generated code for the interpreter.
 139   static bool       contains(address pc)                        { return _code != NULL && _code->contains(pc); }
 140   // Debugging/printing
 141   static InterpreterCodelet* codelet_containing(address pc);
 142 
 143 
 144  public:
 145 


 157   static address    trace_code    (TosState state)              { return _trace_code.entry(state); }
 158 #endif // !PRODUCT
 159   static address*   dispatch_table(TosState state)              { return _active_table.table_for(state); }
 160   static address*   dispatch_table()                            { return _active_table.table_for(); }
 161   static int        distance_from_dispatch_table(TosState state){ return _active_table.distance_from(state); }
 162   static address*   normal_table(TosState state)                { return _normal_table.table_for(state); }
 163   static address*   normal_table()                              { return _normal_table.table_for(); }
 164   static address*   safept_table(TosState state)                { return _safept_table.table_for(state); }
 165 
 166   // Support for invokes
 167   static address*   invoke_return_entry_table()                 { return _invoke_return_entry; }
 168   static address*   invokeinterface_return_entry_table()        { return _invokeinterface_return_entry; }
 169   static address*   invokedynamic_return_entry_table()          { return _invokedynamic_return_entry; }
 170   static int        TosState_as_index(TosState state);
 171 
 172   static address* invoke_return_entry_table_for(Bytecodes::Code code);
 173 
 174   static address deopt_entry(TosState state, int length);
 175   static address deopt_reexecute_return_entry()                 { return _deopt_reexecute_return_entry; }
 176   static address return_entry(TosState state, int length, Bytecodes::Code code);

 177 
 178   // Safepoint support
 179   static void       notice_safepoints();                        // stops the thread when reaching a safepoint
 180   static void       ignore_safepoints();                        // ignores safepoints
 181 
 182   // Deoptimization support
 183   // Compute the entry address for continuation after
 184   static address deopt_continue_after_entry(Method* method,
 185                                             address bcp,
 186                                             int callee_parameters,
 187                                             bool is_top_frame);
 188   // Deoptimization should reexecute this bytecode
 189   static bool    bytecode_should_reexecute(Bytecodes::Code code);
 190   // Compute the address for reexecution
 191   static address deopt_reexecute_entry(Method* method, address bcp);
 192 
 193   // Size of interpreter code.  Max size with JVMTI
 194   static int InterpreterCodeSize;
 195 };
 196 


 100   };
 101 
 102  protected:
 103 
 104   static address    _throw_ArrayIndexOutOfBoundsException_entry;
 105   static address    _throw_ArrayStoreException_entry;
 106   static address    _throw_ArithmeticException_entry;
 107   static address    _throw_ClassCastException_entry;
 108   static address    _throw_NullPointerException_entry;
 109   static address    _throw_exception_entry;
 110 
 111   static address    _throw_StackOverflowError_entry;
 112 
 113   static address    _remove_activation_entry;                   // continuation address if an exception is not handled by current frame
 114   static address    _remove_activation_preserving_args_entry;   // continuation address when current frame is being popped
 115 
 116 #ifndef PRODUCT
 117   static EntryPoint _trace_code;
 118 #endif // !PRODUCT
 119   static EntryPoint _return_entry[number_of_return_entries];    // entry points to return to from a call
 120   static EntryPoint _return_entryX[number_of_return_entries];    // entry points to return to from a call
 121   static EntryPoint _earlyret_entry;                            // entry point to return early from a call
 122   static EntryPoint _deopt_entry[number_of_deopt_entries];      // entry points to return to from a deoptimization
 123   static address    _deopt_reexecute_return_entry;
 124   static EntryPoint _safept_entry;
 125 
 126   static address _invoke_return_entry[number_of_return_addrs];           // for invokestatic, invokespecial, invokevirtual return entries
 127   static address _invoke_return_entryX[number_of_return_addrs];           // for invokestatic, invokespecial, invokevirtual return entries
 128   static address _invokeinterface_return_entry[number_of_return_addrs];  // for invokeinterface return entries
 129   static address _invokedynamic_return_entry[number_of_return_addrs];    // for invokedynamic return entries
 130 
 131   static DispatchTable _active_table;                           // the active    dispatch table (used by the interpreter for dispatch)
 132   static DispatchTable _normal_table;                           // the normal    dispatch table (used to set the active table in normal mode)
 133   static DispatchTable _safept_table;                           // the safepoint dispatch table (used to set the active table for safepoints)
 134   static address       _wentry_point[DispatchTable::length];    // wide instructions only (vtos tosca always)
 135 
 136 
 137  public:
 138   // Initialization/debugging
 139   static void       initialize();
 140   // this only returns whether a pc is within generated code for the interpreter.
 141   static bool       contains(address pc)                        { return _code != NULL && _code->contains(pc); }
 142   // Debugging/printing
 143   static InterpreterCodelet* codelet_containing(address pc);
 144 
 145 
 146  public:
 147 


 159   static address    trace_code    (TosState state)              { return _trace_code.entry(state); }
 160 #endif // !PRODUCT
 161   static address*   dispatch_table(TosState state)              { return _active_table.table_for(state); }
 162   static address*   dispatch_table()                            { return _active_table.table_for(); }
 163   static int        distance_from_dispatch_table(TosState state){ return _active_table.distance_from(state); }
 164   static address*   normal_table(TosState state)                { return _normal_table.table_for(state); }
 165   static address*   normal_table()                              { return _normal_table.table_for(); }
 166   static address*   safept_table(TosState state)                { return _safept_table.table_for(state); }
 167 
 168   // Support for invokes
 169   static address*   invoke_return_entry_table()                 { return _invoke_return_entry; }
 170   static address*   invokeinterface_return_entry_table()        { return _invokeinterface_return_entry; }
 171   static address*   invokedynamic_return_entry_table()          { return _invokedynamic_return_entry; }
 172   static int        TosState_as_index(TosState state);
 173 
 174   static address* invoke_return_entry_table_for(Bytecodes::Code code);
 175 
 176   static address deopt_entry(TosState state, int length);
 177   static address deopt_reexecute_return_entry()                 { return _deopt_reexecute_return_entry; }
 178   static address return_entry(TosState state, int length, Bytecodes::Code code);
 179   static address return_entry(TosState state, int length, Bytecodes::Code code, bool X);
 180 
 181   // Safepoint support
 182   static void       notice_safepoints();                        // stops the thread when reaching a safepoint
 183   static void       ignore_safepoints();                        // ignores safepoints
 184 
 185   // Deoptimization support
 186   // Compute the entry address for continuation after
 187   static address deopt_continue_after_entry(Method* method,
 188                                             address bcp,
 189                                             int callee_parameters,
 190                                             bool is_top_frame);
 191   // Deoptimization should reexecute this bytecode
 192   static bool    bytecode_should_reexecute(Bytecodes::Code code);
 193   // Compute the address for reexecution
 194   static address deopt_reexecute_entry(Method* method, address bcp);
 195 
 196   // Size of interpreter code.  Max size with JVMTI
 197   static int InterpreterCodeSize;
 198 };
 199 
< prev index next >