< prev index next >

src/hotspot/share/oops/method.hpp

Print this page
*** 58,14 ***
--- 58,16 ---
  class CheckedExceptionElement;
  class LocalVariableTableElement;
  class AdapterHandlerEntry;
  class MethodData;
  class MethodCounters;
+ class MethodTrainingData;
  class ConstMethod;
  class InlineTableSizes;
  class CompiledMethod;
  class InterpreterOopMap;
+ class SCCEntry;
  
  class Method : public Metadata {
   friend class VMStructs;
   friend class JVMCIVMStructs;
   friend class MethodTest;

*** 100,10 ***
--- 102,13 ---
    // time (whenever a compile completes).  It can transition from not-null to
    // null only at safepoints (because of a de-opt).
    CompiledMethod* volatile _code;                       // Points to the corresponding piece of native code
    volatile address           _from_interpreted_entry; // Cache of _code ? _adapter->i2c_entry() : _i2i_entry
  
+   CompiledMethod* _preload_code;  // preloaded SCCache code
+   SCCEntry* _scc_entry;           // SCCache entry for pre-loading code
+ 
    // Constructor
    Method(ConstMethod* xconst, AccessFlags access_flags, Symbol* name);
   public:
  
    static Method* allocate(ClassLoaderData* loader_data,

*** 120,10 ***
--- 125,11 ---
    virtual bool is_method() const { return true; }
  
  #if INCLUDE_CDS
    void remove_unshareable_info();
    void restore_unshareable_info(TRAPS);
+   static void restore_archived_method_handle_intrinsic(methodHandle m, TRAPS);
  #endif
  
    // accessors for instance variables
  
    ConstMethod* constMethod() const             { return _constMethod; }

*** 312,10 ***
--- 318,15 ---
    // method data access
    MethodData* method_data() const              {
      return _method_data;
    }
  
+   void set_method_data(MethodData* data);
+ 
+   MethodTrainingData* training_data_or_null() const;
+   bool init_training_data(MethodTrainingData* tdata);
+ 
    // mark an exception handler as entered (used to prune dead catch blocks in C2)
    void set_exception_handler_entered(int handler_bci);
  
    MethodCounters* method_counters() const {
      return _method_counters;

*** 339,11 ***
  
    bool was_executed_more_than(int n);
    bool was_never_executed()                     { return !was_executed_more_than(0);  }
  
    static void build_profiling_method_data(const methodHandle& method, TRAPS);
! 
    static MethodCounters* build_method_counters(Thread* current, Method* m);
  
    int interpreter_invocation_count()            { return invocation_count();          }
  
  #ifndef PRODUCT
--- 350,11 ---
  
    bool was_executed_more_than(int n);
    bool was_never_executed()                     { return !was_executed_more_than(0);  }
  
    static void build_profiling_method_data(const methodHandle& method, TRAPS);
!   static bool install_training_method_data(const methodHandle& method);
    static MethodCounters* build_method_counters(Thread* current, Method* m);
  
    int interpreter_invocation_count()            { return invocation_count();          }
  
  #ifndef PRODUCT

*** 379,10 ***
--- 390,20 ---
    }
    void set_from_compiled_entry(address entry) {
      _from_compiled_entry =  entry;
    }
  
+   void set_preload_code(CompiledMethod* code) {
+     _preload_code = code;
+   }
+   void set_scc_entry(SCCEntry* entry) {
+     _scc_entry = entry;
+   }
+   SCCEntry* scc_entry() const {
+     return _scc_entry;
+   }
+ 
    address get_i2c_entry();
    address get_c2i_entry();
    address get_c2i_unverified_entry();
    address get_c2i_no_clinit_check_entry();
    AdapterHandlerEntry* adapter() const {

*** 595,10 ***
--- 616,11 ---
    // NOTE: code() is inherently racy as deopt can be clearing code
    // simultaneously. Use with caution.
    bool has_compiled_code() const;
  
    bool needs_clinit_barrier() const;
+   bool code_has_clinit_barriers() const;
  
    // sizing
    static int header_size()                       {
      return align_up((int)sizeof(Method), wordSize) / wordSize;
    }
< prev index next >