src/hotspot/share/code/nmethod.hpp

@@ -25,10 +25,11 @@
  #ifndef SHARE_CODE_NMETHOD_HPP
  #define SHARE_CODE_NMETHOD_HPP
  
  #include "code/codeBlob.hpp"
  #include "code/pcDesc.hpp"
+ #include "compiler/compilerDefinitions.hpp"
  #include "oops/metadata.hpp"
  #include "oops/method.hpp"
  
  class AbstractCompiler;
  class CompiledDirectCall;

@@ -211,10 +212,14 @@
  
    // offsets for entry points
    address  _osr_entry_point;       // entry point for on stack replacement
    uint16_t _entry_offset;          // entry point with class check
    uint16_t _verified_entry_offset; // entry point without class check
+   // TODO: can these be uint16_t, seem rely on -1 CodeOffset, can change later...
+   address _inline_entry_point;              // inline type entry point (unpack all inline type args) with class check
+   address _verified_inline_entry_point;     // inline type entry point (unpack all inline type args) without class check
+   address _verified_inline_ro_entry_point;  // inline type entry point (unpack receiver only) without class check
    int      _entry_bci;             // != InvocationEntryBci if this nmethod is an on-stack replacement method
    int      _immutable_data_size;
  
    // _consts_offset == _content_offset because SECT_CONSTS is first in code buffer
  

@@ -603,10 +608,13 @@
    bool nul_chk_table_contains  (address addr) const { return nul_chk_table_begin() <= addr && addr < nul_chk_table_end(); }
  
    // entry points
    address entry_point() const          { return code_begin() + _entry_offset;          } // normal entry point
    address verified_entry_point() const { return code_begin() + _verified_entry_offset; } // if klass is correct
+   address inline_entry_point() const              { return _inline_entry_point; }             // inline type entry point (unpack all inline type args)
+   address verified_inline_entry_point() const     { return _verified_inline_entry_point; }    // inline type entry point (unpack all inline type args) without class check
+   address verified_inline_ro_entry_point() const  { return _verified_inline_ro_entry_point; } // inline type entry point (only unpack receiver) without class check
  
    enum : signed char { not_installed = -1, // in construction, only the owner doing the construction is
                                             // allowed to advance state
                         in_use        = 0,  // executable nmethod
                         not_entrant   = 1   // marked for deoptimization but activations may still exist

@@ -672,10 +680,20 @@
    void  set_has_method_handle_invokes(bool z)     { _has_method_handle_invokes = z; }
  
    bool  has_wide_vectors() const                  { return _has_wide_vectors; }
    void  set_has_wide_vectors(bool z)              { _has_wide_vectors = z; }
  
+   bool  needs_stack_repair() const {
+     if (is_compiled_by_c1()) {
+       return method()->c1_needs_stack_repair();
+     } else if (is_compiled_by_c2()) {
+       return method()->c2_needs_stack_repair();
+     } else {
+       return false;
+     }
+   }
+ 
    bool  has_flushed_dependencies() const          { return _has_flushed_dependencies; }
    void  set_has_flushed_dependencies(bool z)      {
      assert(!has_flushed_dependencies(), "should only happen once");
      _has_flushed_dependencies = z;
    }