Initial non-working deferred locals refactor

src/hotspot/cpu/aarch64/frame_aarch64.cpp

@@ -464,7 +464,7 @@ void frame::verify_deopt_original_pc(nmethod* nm, intptr_t* unextended_sp) {
   // method anyway.
   fr._unextended_sp = unextended_sp;
 
-  address original_pc = nm->get_original_pc(&fr);
+  address original_pc = fr.get_original_pc(nm);
   assert(nm->insts_contains_inclusive(original_pc),
          "original PC must be in the main code section of the compiled method (or must be immediately following it)");
 }

src/hotspot/os/posix/signals_posix.cpp

@@ -622,7 +622,7 @@ int JVM_HANDLE_XXX_SIGNAL(int sig, siginfo_t* info,
         assert(deopt != nullptr, "");
 
         frame fr = os::fetch_frame_from_context(uc);
-        nm->set_original_pc(&fr, pc);
+        fr.set_original_pc(nm, pc);
 
         os::Posix::ucontext_set_pc(uc, deopt);
         signal_was_handled = true;

src/hotspot/share/code/nmethod.cpp

@@ -857,6 +857,43 @@ void nmethod::cleanup_inline_caches_whitebox() {
   cleanup_inline_caches_impl(false /* unloading_occurred */, true /* clean_all */);
 }
 
+GrowableArrayCHeap<jvmtiDeferredLocalVariableSet*, mtCompiler>* nmethod::get_deferred_updates(const frame* fr) {
+  if (!fr->is_deoptimized_frame()) {
+    guarantee(fr->is_compiled_frame(), "must at least be compiled");
+    return nullptr;
+  }
+
+  address ptr = *orig_pc_addr(fr);
+  if (ptr != nullptr) {
+    if (CodeCache::contains(ptr)) {
+      return nullptr;
+    }
+    DeferredUpdates* updates = (DeferredUpdates*) ptr;
+    return updates->deferred_locals;
+  }
+  return nullptr;
+}
+
+void nmethod::set_deferred_updates(const frame* fr, GrowableArrayCHeap<jvmtiDeferredLocalVariableSet*, mtCompiler>* value) {
+  guarantee(fr->is_deoptimized_frame(), "must be deoptimized frame");
+
+  address ptr = *orig_pc_addr(fr);
+  if (value != nullptr) {
+    // deferred updates can only be set after deopt
+    guarantee(CodeCache::contains(ptr), "should currently be deopt pc");
+
+    DeferredUpdates* updates = new DeferredUpdates();
+    updates->original_pc = ptr;
+    updates->deferred_locals = value;
+  } else {
+    // Release
+    guarantee(!CodeCache::contains(ptr), "should be DeferredUpdates*");
+    DeferredUpdates* updates = (DeferredUpdates*) ptr;
+    *orig_pc_addr(fr) = updates->original_pc;
+    delete updates;
+  }
+}
+
 address* nmethod::orig_pc_addr(const frame* fr) {
   return (address*) ((address)fr->unextended_sp() + orig_pc_offset());
 }

src/hotspot/share/code/nmethod.hpp

@@ -161,6 +161,12 @@ class FailedSpeculation;
 class JVMCINMethodData;
 #endif
 
+class DeferredUpdates : public CHeapObj<mtCompiler> {
+ public:
+  address original_pc;
+  GrowableArrayCHeap<jvmtiDeferredLocalVariableSet*, mtCompiler>* deferred_locals;
+};
+
 class nmethod : public CodeBlob {
   friend class VMStructs;
   friend class JVMCIVMStructs;
@@ -749,9 +755,10 @@ class nmethod : public CodeBlob {
   inline bool is_deopt_mh_entry(address pc);
   inline bool is_deopt_entry(address pc);
 
-  // Accessor/mutator for the original pc of a frame before a frame was deopted.
-  address get_original_pc(const frame* fr) { return *orig_pc_addr(fr); }
-  void    set_original_pc(const frame* fr, address pc) { *orig_pc_addr(fr) = pc; }
+  address* orig_pc_addr(const frame* fr);
+
+  GrowableArrayCHeap<jvmtiDeferredLocalVariableSet*, mtCompiler>* get_deferred_updates(const frame* fr);
+  void set_deferred_updates(const frame* fr, GrowableArrayCHeap<jvmtiDeferredLocalVariableSet*, mtCompiler>* updates);
 
   const char* state() const;
 
@@ -871,8 +878,6 @@ class nmethod : public CodeBlob {
  private:
   ScopeDesc* scope_desc_in(address begin, address end);
 
-  address* orig_pc_addr(const frame* fr);
-
   // used by jvmti to track if the load events has been reported
   bool  load_reported() const                     { return _load_reported; }
   void  set_load_reported()                       { _load_reported = true; }

src/hotspot/share/jfr/leakprofiler/checkpoint/rootResolver.cpp

@@ -263,13 +263,6 @@ bool ReferenceToThreadRootClosure::do_thread_stack_detailed(JavaThread* jt) {
     return true;
   }
 
-  GrowableArrayView<jvmtiDeferredLocalVariableSet*>* const list = JvmtiDeferredUpdates::deferred_locals(jt);
-  if (list != nullptr) {
-    for (int i = 0; i < list->length(); i++) {
-      list->at(i)->oops_do(&rcl);
-    }
-  }
-
   if (rcl.complete()) {
     return true;
   }

src/hotspot/share/prims/jvmtiDeferredUpdates.cpp

@@ -26,62 +26,3 @@
 #include "precompiled.hpp"
 #include "prims/jvmtiDeferredUpdates.hpp"
 
-void JvmtiDeferredUpdates::create_for(JavaThread* thread) {
-  assert(thread->deferred_updates() == nullptr, "already allocated");
-  thread->set_deferred_updates(new JvmtiDeferredUpdates());
-}
-
-JvmtiDeferredUpdates::~JvmtiDeferredUpdates() {
-  while (_deferred_locals_updates.length() != 0) {
-    jvmtiDeferredLocalVariableSet* dlv = _deferred_locals_updates.pop();
-    // individual jvmtiDeferredLocalVariableSet are CHeapObj's
-    delete dlv;
-  }
-}
-
-void JvmtiDeferredUpdates::inc_relock_count_after_wait(JavaThread* thread) {
-  if (thread->deferred_updates() == nullptr) {
-    create_for(thread);
-  }
-  thread->deferred_updates()->inc_relock_count_after_wait();
-}
-
-int JvmtiDeferredUpdates::get_and_reset_relock_count_after_wait(JavaThread* jt) {
-  JvmtiDeferredUpdates* updates = jt->deferred_updates();
-  int result = 0;
-  if (updates != nullptr) {
-    result = updates->get_and_reset_relock_count_after_wait();
-    if (updates->count() == 0) {
-      delete updates;
-      jt->set_deferred_updates(nullptr);
-    }
-  }
-  return result;
-}
-
-void JvmtiDeferredUpdates::delete_updates_for_frame(JavaThread* jt, intptr_t* frame_id) {
-  JvmtiDeferredUpdates* updates = jt->deferred_updates();
-  if (updates != nullptr) {
-    GrowableArray<jvmtiDeferredLocalVariableSet*>* list = updates->deferred_locals();
-    assert(list->length() > 0, "Updates holder not deleted");
-    int i = 0;
-    do {
-      // Because of inlining we could have multiple vframes for a single frame
-      // and several of the vframes could have deferred writes. Find them all.
-      jvmtiDeferredLocalVariableSet* dlv = list->at(i);
-      if (dlv->id() == frame_id) {
-        list->remove_at(i);
-        // individual jvmtiDeferredLocalVariableSet are CHeapObj's
-        delete dlv;
-      } else {
-        i++;
-      }
-    } while ( i < list->length() );
-    if (updates->count() == 0) {
-      jt->set_deferred_updates(nullptr);
-      // Free deferred updates.
-      // Note, the 'list' of local variable updates is embedded in 'updates'.
-      delete updates;
-    }
-  }
-}

src/hotspot/share/prims/jvmtiDeferredUpdates.hpp

@@ -30,133 +30,4 @@
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/growableArray.hpp"
 
-class MonitorInfo;
-template <typename T> class GrowableArray;
-
-class jvmtiDeferredLocalVariable : public CHeapObj<mtCompiler> {
-
-  private:
-
-    BasicType _type;
-    jvalue    _value;
-    int       _index;
-
-  public:
-
-    jvmtiDeferredLocalVariable(int index, BasicType type, jvalue value);
-
-    BasicType type(void)         { return _type; }
-    int index(void)              { return _index; }
-    jvalue value(void)           { return _value; }
-
-    // Only mutator is for value as only it can change
-    void set_value(jvalue value) { _value = value; }
-
-    // For gc
-    oop* oop_addr(void)          { return (oop*) &_value.l; }
-};
-
-// In order to implement set_locals for compiled vframes we must
-// store updated locals in a data structure that contains enough
-// information to recognize equality with a vframe and to store
-// any updated locals.
-
-class StackValueCollection;
-
-class jvmtiDeferredLocalVariableSet : public CHeapObj<mtCompiler> {
-  friend class compiledVFrame;
-
-private:
-
-  Method*   _method;
-  int       _bci;
-  intptr_t* _id;
-  int       _vframe_id;
-  GrowableArray<jvmtiDeferredLocalVariable*>* _locals;
-  bool      _objects_are_deoptimized;
-
-  void      update_value(StackValueCollection* locals, BasicType type, int index, jvalue value);
-
-  void      set_value_at(int idx, BasicType typ, jvalue val);
-
- public:
-  // JVM state
-  Method*   method()                  const { return _method; }
-  int       bci()                     const { return _bci; }
-  intptr_t* id()                      const { return _id; }
-  int       vframe_id()               const { return _vframe_id; }
-  bool      objects_are_deoptimized() const { return _objects_are_deoptimized; }
-
-  void      update_locals(StackValueCollection* locals);
-  void      update_stack(StackValueCollection* locals);
-  void      update_monitors(GrowableArray<MonitorInfo*>* monitors);
-  void      set_objs_are_deoptimized()      { _objects_are_deoptimized = true; }
-
-  // Does the vframe match this jvmtiDeferredLocalVariableSet
-  bool      matches(const vframe* vf);
-
-  // Does the underlying physical frame match this jvmtiDeferredLocalVariableSet
-  bool      matches(intptr_t* fr_id)        { return id() == fr_id; }
-
-  // GC
-  void      oops_do(OopClosure* f);
-
-  // constructor
-  jvmtiDeferredLocalVariableSet(Method* method, int bci, intptr_t* id, int vframe_id);
-
-  // destructor
-  ~jvmtiDeferredLocalVariableSet();
-};
-
-// Holds updates for compiled frames by JVMTI agents that cannot be performed immediately.
-
-class JvmtiDeferredUpdates : public CHeapObj<mtCompiler> {
-
-  // Relocking has to be deferred if the lock owning thread is currently waiting on the monitor.
-  int _relock_count_after_wait;
-
-  // Deferred updates of locals, expressions, and monitors
-  GrowableArray<jvmtiDeferredLocalVariableSet*> _deferred_locals_updates;
-
-  void inc_relock_count_after_wait() {
-    _relock_count_after_wait++;
-  }
-
-  int get_and_reset_relock_count_after_wait() {
-    int result = _relock_count_after_wait;
-    _relock_count_after_wait = 0;
-    return result;
-  }
-
-  GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred_locals() { return &_deferred_locals_updates; }
-
-  JvmtiDeferredUpdates() :
-    _relock_count_after_wait(0),
-    _deferred_locals_updates((AnyObj::set_allocation_type((address) &_deferred_locals_updates,
-                             AnyObj::C_HEAP), 1), mtCompiler) { }
-
-public:
-  ~JvmtiDeferredUpdates();
-
-  static void create_for(JavaThread* thread);
-
-  static GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred_locals(JavaThread* jt) {
-    return jt->deferred_updates() == nullptr ? nullptr : jt->deferred_updates()->deferred_locals();
-  }
-
-  // Relocking has to be deferred if the lock owning thread is currently waiting on the monitor.
-  static int  get_and_reset_relock_count_after_wait(JavaThread* jt);
-  static void inc_relock_count_after_wait(JavaThread* thread);
-
-  // Delete deferred updates for the compiled frame with id 'frame_id' on the
-  // given thread's stack. The thread's JvmtiDeferredUpdates instance will be
-  // deleted too if no updates remain.
-  static void delete_updates_for_frame(JavaThread* jt, intptr_t* frame_id);
-
-  // Number of deferred updates
-  int count() const {
-    return _deferred_locals_updates.length() + (_relock_count_after_wait > 0 ? 1 : 0);
-  }
-};
-
 #endif // SHARE_PRIMS_JVMTIDEFERREDUPDATES_HPP

src/hotspot/share/runtime/deoptimization.cpp

@@ -393,7 +393,7 @@ static bool rematerialize_objects(JavaThread* thread, int exec_mode, nmethod* co
 static void restore_eliminated_locks(JavaThread* thread, GrowableArray<compiledVFrame*>* chunk, bool realloc_failures,
                                      frame& deoptee, int exec_mode, bool& deoptimized_objects) {
   JavaThread* deoptee_thread = chunk->at(0)->thread();
-  assert(!EscapeBarrier::objs_are_deoptimized(deoptee_thread, deoptee.id()), "must relock just once");
+  assert(!EscapeBarrier::objs_are_deoptimized(deoptee_thread, deoptee), "must relock just once");
   assert(thread == Thread::current(), "should be");
   HandleMark hm(thread);
 #ifndef PRODUCT
@@ -542,7 +542,7 @@ Deoptimization::UnrollBlock* Deoptimization::fetch_unroll_info_helper(JavaThread
 
 #if COMPILER2_OR_JVMCI
   if ((jvmci_enabled COMPILER2_PRESENT( || ((DoEscapeAnalysis || EliminateNestedLocks) && EliminateLocks) ))
-      && !EscapeBarrier::objs_are_deoptimized(current, deoptee.id())) {
+      && !EscapeBarrier::objs_are_deoptimized(current, deoptee)) {
     bool unused = false;
     restore_eliminated_locks(current, chunk, realloc_failures, deoptee, exec_mode, unused);
   }
@@ -580,7 +580,11 @@ Deoptimization::UnrollBlock* Deoptimization::fetch_unroll_info_helper(JavaThread
   // added by jvmti then we can free up that structure as the data is now in the
   // vframeArray
 
-  JvmtiDeferredUpdates::delete_updates_for_frame(current, array->original().id());
+  GrowableArrayCHeap<jvmtiDeferredLocalVariableSet*, mtCompiler>* deferred_locals = deoptee.deferred_locals();
+  if (deferred_locals != nullptr) {
+    deoptee.set_deferred_locals(nullptr);
+    delete deferred_locals; // XXX delete individual elements too?
+  }
 
   // Compute the caller frame based on the sender sp of stub_frame and stored frame sizes info.
   CodeBlob* cb = stub_frame.cb();
@@ -1652,7 +1656,7 @@ bool Deoptimization::relock_objects(JavaThread* thread, GrowableArray<MonitorInf
                 mon_info->lock()->set_bad_metadata_deopt();
               }
 #endif
-              JvmtiDeferredUpdates::inc_relock_count_after_wait(deoptee_thread);
+              deoptee_thread->inc_relock_count_after_wait();
               continue;
             }
           }