hotspot/src/share/vm/interpreter/interpreterRuntime.hpp
changeset 46424 2dfc07162b35
parent 40010 e32d5e545789
child 46430 45fd2f759802
equal deleted inserted replaced
46423:62fac1c2c841 46424:2dfc07162b35
    40 class InterpreterRuntime: AllStatic {
    40 class InterpreterRuntime: AllStatic {
    41   friend class BytecodeClosure; // for method and bcp
    41   friend class BytecodeClosure; // for method and bcp
    42   friend class PrintingClosure; // for method and bcp
    42   friend class PrintingClosure; // for method and bcp
    43 
    43 
    44  private:
    44  private:
    45   // Helper functions to access current interpreter state
    45   // Helper class to access current interpreter state
    46   static frame     last_frame(JavaThread *thread)    { return thread->last_frame(); }
    46   class LastFrameAccessor : public StackObj {
    47   static Method*   method(JavaThread *thread)        { return last_frame(thread).interpreter_frame_method(); }
    47     frame _last_frame;
    48   static address   bcp(JavaThread *thread)           { return last_frame(thread).interpreter_frame_bcp(); }
    48   public:
    49   static int       bci(JavaThread *thread)           { return last_frame(thread).interpreter_frame_bci(); }
    49     LastFrameAccessor(JavaThread* thread) {
       
    50       assert(thread == Thread::current(), "sanity");
       
    51       _last_frame = thread->last_frame();
       
    52     }
       
    53     bool is_interpreted_frame() const              { return _last_frame.is_interpreted_frame(); }
       
    54     Method*   method() const                       { return _last_frame.interpreter_frame_method(); }
       
    55     address   bcp() const                          { return _last_frame.interpreter_frame_bcp(); }
       
    56     int       bci() const                          { return _last_frame.interpreter_frame_bci(); }
       
    57     address   mdp() const                          { return _last_frame.interpreter_frame_mdp(); }
       
    58 
       
    59     void      set_bcp(address bcp)                 { _last_frame.interpreter_frame_set_bcp(bcp); }
       
    60     void      set_mdp(address dp)                  { _last_frame.interpreter_frame_set_mdp(dp); }
       
    61 
       
    62     // pass method to avoid calling unsafe bcp_to_method (partial fix 4926272)
       
    63     Bytecodes::Code code() const                   { return Bytecodes::code_at(method(), bcp()); }
       
    64 
       
    65     Bytecode  bytecode() const                     { return Bytecode(method(), bcp()); }
       
    66     int get_index_u1(Bytecodes::Code bc) const     { return bytecode().get_index_u1(bc); }
       
    67     int get_index_u2(Bytecodes::Code bc) const     { return bytecode().get_index_u2(bc); }
       
    68     int get_index_u2_cpcache(Bytecodes::Code bc) const
       
    69                                                    { return bytecode().get_index_u2_cpcache(bc); }
       
    70     int get_index_u4(Bytecodes::Code bc) const     { return bytecode().get_index_u4(bc); }
       
    71     int number_of_dimensions() const               { return bcp()[3]; }
       
    72     ConstantPoolCacheEntry* cache_entry_at(int i) const
       
    73                                                    { return method()->constants()->cache()->entry_at(i); }
       
    74     ConstantPoolCacheEntry* cache_entry() const    { return cache_entry_at(Bytes::get_native_u2(bcp() + 1)); }
       
    75 
       
    76     oop callee_receiver(Symbol* signature) {
       
    77       return _last_frame.interpreter_callee_receiver(signature);
       
    78     }
       
    79     BasicObjectLock* monitor_begin() const {
       
    80       return _last_frame.interpreter_frame_monitor_end();
       
    81     }
       
    82     BasicObjectLock* monitor_end() const {
       
    83       return _last_frame.interpreter_frame_monitor_begin();
       
    84     }
       
    85     BasicObjectLock* next_monitor(BasicObjectLock* current) const {
       
    86       return _last_frame.next_monitor_in_interpreter_frame(current);
       
    87     }
       
    88 
       
    89     frame& get_frame()                             { return _last_frame; }
       
    90   };
       
    91 
    50   static void      set_bcp_and_mdp(address bcp, JavaThread*thread);
    92   static void      set_bcp_and_mdp(address bcp, JavaThread*thread);
    51   static Bytecodes::Code code(JavaThread *thread)    {
       
    52     // pass method to avoid calling unsafe bcp_to_method (partial fix 4926272)
       
    53     return Bytecodes::code_at(method(thread), bcp(thread));
       
    54   }
       
    55   static Bytecode  bytecode(JavaThread *thread)      { return Bytecode(method(thread), bcp(thread)); }
       
    56   static int       get_index_u1(JavaThread *thread, Bytecodes::Code bc)
       
    57                                                         { return bytecode(thread).get_index_u1(bc); }
       
    58   static int       get_index_u2(JavaThread *thread, Bytecodes::Code bc)
       
    59                                                         { return bytecode(thread).get_index_u2(bc); }
       
    60   static int       get_index_u2_cpcache(JavaThread *thread, Bytecodes::Code bc)
       
    61                                                         { return bytecode(thread).get_index_u2_cpcache(bc); }
       
    62   static int       get_index_u4(JavaThread *thread, Bytecodes::Code bc)
       
    63                                                         { return bytecode(thread).get_index_u4(bc); }
       
    64   static int       number_of_dimensions(JavaThread *thread)  { return bcp(thread)[3]; }
       
    65 
       
    66   static ConstantPoolCacheEntry* cache_entry_at(JavaThread *thread, int i)  { return method(thread)->constants()->cache()->entry_at(i); }
       
    67   static ConstantPoolCacheEntry* cache_entry(JavaThread *thread)            { return cache_entry_at(thread, Bytes::get_native_u2(bcp(thread) + 1)); }
       
    68   static void      note_trap_inner(JavaThread* thread, int reason,
    93   static void      note_trap_inner(JavaThread* thread, int reason,
    69                                    methodHandle trap_method, int trap_bci, TRAPS);
    94                                    methodHandle trap_method, int trap_bci, TRAPS);
    70   static void      note_trap(JavaThread *thread, int reason, TRAPS);
    95   static void      note_trap(JavaThread *thread, int reason, TRAPS);
    71 #ifdef CC_INTERP
    96 #ifdef CC_INTERP
    72   // Profile traps in C++ interpreter.
    97   // Profile traps in C++ interpreter.
   137 
   162 
   138   // Breakpoints
   163   // Breakpoints
   139   static void _breakpoint(JavaThread* thread, Method* method, address bcp);
   164   static void _breakpoint(JavaThread* thread, Method* method, address bcp);
   140   static Bytecodes::Code get_original_bytecode_at(JavaThread* thread, Method* method, address bcp);
   165   static Bytecodes::Code get_original_bytecode_at(JavaThread* thread, Method* method, address bcp);
   141   static void            set_original_bytecode_at(JavaThread* thread, Method* method, address bcp, Bytecodes::Code new_code);
   166   static void            set_original_bytecode_at(JavaThread* thread, Method* method, address bcp, Bytecodes::Code new_code);
   142   static bool is_breakpoint(JavaThread *thread) { return Bytecodes::code_or_bp_at(bcp(thread)) == Bytecodes::_breakpoint; }
   167   static bool is_breakpoint(JavaThread *thread) { return Bytecodes::code_or_bp_at(LastFrameAccessor(thread).bcp()) == Bytecodes::_breakpoint; }
   143 
   168 
   144   // Safepoints
   169   // Safepoints
   145   static void    at_safepoint(JavaThread* thread);
   170   static void    at_safepoint(JavaThread* thread);
   146 
   171 
   147   // Debugger support
   172   // Debugger support