Merge

Author: AlanBateman

src/hotspot/cpu/aarch64/c1_Runtime1_aarch64.cpp

@@ -160,28 +160,21 @@ int StubAssembler::call_RT(Register oop_result1, Register metadata_result, addre
 }
 
 enum return_state_t {
-  does_not_return, requires_return
+  does_not_return, requires_return, requires_pop_epilogue_return
 };
 
-
 // Implementation of StubFrame
 
 class StubFrame: public StackObj {
  private:
   StubAssembler* _sasm;
-  bool _return_state;
-  bool _use_pop_on_epilogue;
-
-  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments,
-            return_state_t return_state, bool use_pop_on_epilogue);
+  return_state_t _return_state;
 
  public:
-  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments, bool use_pop_on_epilogue);
-  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments, return_state_t return_state);
-  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments);
-  ~StubFrame();
-
+  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments, return_state_t return_state=requires_return);
   void load_argument(int offset_in_words, Register reg);
+
+  ~StubFrame();
 };;
 
 void StubAssembler::prologue(const char* name, bool must_gc_arguments) {
@@ -204,31 +197,24 @@ void StubAssembler::epilogue(bool use_pop) {
 
 #define __ _sasm->
 
-StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments,
-                     return_state_t return_state, bool use_pop_on_epilogue)
-  : _sasm(sasm), _return_state(return_state), _use_pop_on_epilogue(use_pop_on_epilogue) {
+StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments, return_state_t return_state) {
+  _sasm = sasm;
+  _return_state = return_state;
   __ prologue(name, must_gc_arguments);
 }
 
-StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments,
-                     bool use_pop_on_epilogue) :
-  StubFrame(sasm, name, must_gc_arguments, requires_return, use_pop_on_epilogue) {}
-
-StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments,
-                     return_state_t return_state) :
-  StubFrame(sasm, name, must_gc_arguments, return_state, /*use_pop_on_epilogue*/false) {}
-
-StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments) :
-  StubFrame(sasm, name, must_gc_arguments, requires_return, /*use_pop_on_epilogue*/false) {}
-
 // load parameters that were stored with LIR_Assembler::store_parameter
 // Note: offsets for store_parameter and load_argument must match
 void StubFrame::load_argument(int offset_in_words, Register reg) {
   __ load_parameter(offset_in_words, reg);
 }
 
 StubFrame::~StubFrame() {
-  __ epilogue(_use_pop_on_epilogue);
+  if (_return_state == does_not_return) {
+    __ should_not_reach_here();
+  } else {
+    __ epilogue(_return_state == requires_pop_epilogue_return);
+  }
 }
 
 #undef __
@@ -892,7 +878,7 @@ OopMapSet* Runtime1::generate_code_for(C1StubId id, StubAssembler* sasm) {
       // fall through
     case C1StubId::monitorenter_id:
       {
-        StubFrame f(sasm, "monitorenter", dont_gc_arguments, /*use_pop_on_epilogue*/true);
+        StubFrame f(sasm, "monitorenter", dont_gc_arguments, requires_pop_epilogue_return);
         OopMap* map = save_live_registers(sasm, save_fpu_registers);
 
         // Called with store_parameter and not C abi

src/hotspot/cpu/aarch64/c2_MacroAssembler_aarch64.cpp

@@ -110,11 +110,7 @@ void C2_MacroAssembler::fast_lock(Register objectReg, Register boxReg, Register
   // Handle existing monitor.
   bind(object_has_monitor);
 
-  // The object's monitor m is unlocked iff m->owner == nullptr,
-  // otherwise m->owner may contain a thread id, a stack address for LM_LEGACY,
-  // or the ANONYMOUS_OWNER constant for LM_LIGHTWEIGHT.
-  //
-  // Try to CAS m->owner from null to current thread.
+  // Try to CAS owner (no owner => current thread's _lock_id).
   ldr(rscratch2, Address(rthread, JavaThread::lock_id_offset()));
   add(tmp, disp_hdr, (in_bytes(ObjectMonitor::owner_offset())-markWord::monitor_value));
   cmpxchg(tmp, zr, rscratch2, Assembler::xword, /*acquire*/ true,
@@ -377,7 +373,7 @@ void C2_MacroAssembler::fast_lock_lightweight(Register obj, Register box, Regist
     // Compute owner address.
     lea(t2_owner_addr, owner_address);
 
-    // CAS owner (null => current thread id).
+    // Try to CAS owner (no owner => current thread's _lock_id).
     ldr(rscratch2, Address(rthread, JavaThread::lock_id_offset()));
     cmpxchg(t2_owner_addr, zr, rscratch2, Assembler::xword, /*acquire*/ true,
             /*release*/ false, /*weak*/ false, t3_owner);

src/hotspot/cpu/aarch64/continuationFreezeThaw_aarch64.inline.hpp

@@ -310,7 +310,7 @@ inline intptr_t* ThawBase::possibly_adjust_frame(frame& top) {
     sp[-1] = sp[1];
 
     log_develop_trace(continuations, preempt)("adjusted sp for c2 runtime stub, initial sp: " INTPTR_FORMAT " final sp: " INTPTR_FORMAT
-                                              " fp: " INTPTR_FORMAT, p2i(sp + frame::metadata_words), p2i(sp), sp[-2]);
+                                              " fp: " INTPTR_FORMAT, p2i(sp + 2), p2i(sp), sp[-2]);
   }
   return sp;
 }

src/hotspot/cpu/aarch64/frame_aarch64.cpp

@@ -420,6 +420,36 @@ frame frame::sender_for_upcall_stub_frame(RegisterMap* map) const {
   return fr;
 }
 
+#if defined(ASSERT)
+static address get_register_address_in_stub(const frame& stub_fr, VMReg reg) {
+  RegisterMap map(nullptr,
+                  RegisterMap::UpdateMap::include,
+                  RegisterMap::ProcessFrames::skip,
+                  RegisterMap::WalkContinuation::skip);
+  stub_fr.oop_map()->update_register_map(&stub_fr, &map);
+  return map.location(reg, stub_fr.sp());
+}
+#endif
+
+JavaThread** frame::saved_thread_address(const frame& f) {
+  CodeBlob* cb = f.cb();
+  assert(cb != nullptr && cb->is_runtime_stub(), "invalid frame");
+
+  JavaThread** thread_addr;
+#ifdef COMPILER1
+  if (cb == Runtime1::blob_for(C1StubId::monitorenter_id) ||
+      cb == Runtime1::blob_for(C1StubId::monitorenter_nofpu_id)) {
+    thread_addr = (JavaThread**)(f.sp() + Runtime1::runtime_blob_current_thread_offset(f));
+  } else
+#endif
+  {
+    // c2 only saves rbp in the stub frame so nothing to do.
+    thread_addr = nullptr;
+  }
+  assert(get_register_address_in_stub(f, SharedRuntime::thread_register()) == (address)thread_addr, "wrong thread address");
+  return thread_addr;
+}
+
 //------------------------------------------------------------------------------
 // frame::verify_deopt_original_pc
 //

src/hotspot/cpu/arm/frame_arm.cpp

@@ -325,6 +325,11 @@ bool frame::upcall_stub_frame_is_first() const {
   return false;
 }
 
+JavaThread** frame::saved_thread_address(const frame& f) {
+  Unimplemented();
+  return nullptr;
+}
+
 //------------------------------------------------------------------------------
 // frame::verify_deopt_original_pc
 //

src/hotspot/cpu/ppc/frame_ppc.cpp

@@ -243,6 +243,11 @@ frame frame::sender_for_upcall_stub_frame(RegisterMap* map) const {
   return fr;
 }
 
+JavaThread** frame::saved_thread_address(const frame& f) {
+  // The current thread (JavaThread*) is never stored on the stack
+  return nullptr;
+}
+
 frame frame::sender_for_interpreter_frame(RegisterMap *map) const {
   // This is the sp before any possible extension (adapter/locals).
   intptr_t* unextended_sp = interpreter_frame_sender_sp();

src/hotspot/cpu/ppc/macroAssembler_ppc.cpp

@@ -2658,10 +2658,8 @@ void MacroAssembler::compiler_fast_lock_object(ConditionRegister flag, Register
 
   // Handle existing monitor.
   bind(object_has_monitor);
-  // The object's monitor m is unlocked iff m->owner is null,
-  // otherwise m->owner may contain a thread or a stack address.
 
-  // Try to CAS m->owner from null to current thread.
+  // Try to CAS owner (no owner => current thread's _lock_id).
   addi(temp, displaced_header, in_bytes(ObjectMonitor::owner_offset()) - markWord::monitor_value);
   Register thread_id = displaced_header;
   ld(thread_id, in_bytes(JavaThread::lock_id_offset()), R16_thread);
@@ -2941,7 +2939,7 @@ void MacroAssembler::compiler_fast_lock_lightweight_object(ConditionRegister fla
       addi(owner_addr, monitor, in_bytes(ObjectMonitor::owner_offset()));
     }
 
-    // CAS owner (null => current thread id).
+    // Try to CAS owner (no owner => current thread's _lock_id).
     assert_different_registers(thread_id, monitor, owner_addr, box, R0);
     ld(thread_id, in_bytes(JavaThread::lock_id_offset()), R16_thread);
     cmpxchgd(/*flag=*/CCR0,

src/hotspot/cpu/riscv/c1_Runtime1_riscv.cpp

@@ -165,29 +165,21 @@ int StubAssembler::call_RT(Register oop_result, Register metadata_result, addres
 }
 
 enum return_state_t {
-  does_not_return, requires_return
+  does_not_return, requires_return, requires_pop_epilogue_return
 };
 
 // Implementation of StubFrame
 
 class StubFrame: public StackObj {
  private:
   StubAssembler* _sasm;
-  bool _return_state;
-  bool _use_pop_on_epilogue;
+  return_state_t _return_state;
 
  public:
-  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments,
-            return_state_t return_state, bool use_pop_on_epilogue);
-
- public:
-  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments, bool use_pop_on_epilogue);
-  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments, return_state_t return_state);
-  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments);
+  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments, return_state_t return_state=requires_return);
+  void load_argument(int offset_in_words, Register reg);
 
   ~StubFrame();
-
-  void load_argument(int offset_in_words, Register reg);
 };;
 
 void StubAssembler::prologue(const char* name, bool must_gc_arguments) {
@@ -212,31 +204,26 @@ void StubAssembler::epilogue(bool use_pop) {
 
 #define __ _sasm->
 
-StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments,
-                     return_state_t return_state, bool use_pop_on_epilogue)
-  : _sasm(sasm), _return_state(return_state), _use_pop_on_epilogue(use_pop_on_epilogue) {
+StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments, return_state_t return_state) {
+  _sasm = sasm;
+  _return_state = return_state;
   __ prologue(name, must_gc_arguments);
 }
 
-StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments,
-                     bool use_pop_on_epilogue) :
-  StubFrame(sasm, name, must_gc_arguments, requires_return, use_pop_on_epilogue) {}
-
-StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments,
-                     return_state_t return_state) :
-  StubFrame(sasm, name, must_gc_arguments, return_state, /*use_pop_on_epilogue*/false) {}
-
-StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments) :
-  StubFrame(sasm, name, must_gc_arguments, requires_return, /*use_pop_on_epilogue*/false) {}
-
 // load parameters that were stored with LIR_Assembler::store_parameter
 // Note: offsets for store_parameter and load_argument must match
 void StubFrame::load_argument(int offset_in_words, Register reg) {
   __ load_parameter(offset_in_words, reg);
 }
 
+
 StubFrame::~StubFrame() {
-  __ epilogue(_use_pop_on_epilogue);
+  if (_return_state == does_not_return) {
+    __ should_not_reach_here();
+  } else {
+    __ epilogue(_return_state == requires_pop_epilogue_return);
+  }
+  _sasm = nullptr;
 }
 
 #undef __
@@ -916,7 +903,7 @@ OopMapSet* Runtime1::generate_code_for(C1StubId id, StubAssembler* sasm) {
       // fall through
     case C1StubId::monitorenter_id:
       {
-        StubFrame f(sasm, "monitorenter", dont_gc_arguments, /*use_pop_on_epilogue*/true);
+        StubFrame f(sasm, "monitorenter", dont_gc_arguments, requires_pop_epilogue_return);
         OopMap* map = save_live_registers(sasm, save_fpu_registers);
         assert_cond(map != nullptr);
 

src/hotspot/cpu/riscv/c2_MacroAssembler_riscv.cpp

@@ -116,11 +116,7 @@ void C2_MacroAssembler::fast_lock(Register objectReg, Register boxReg,
   // Handle existing monitor.
   bind(object_has_monitor);
 
-  // The object's monitor m is unlocked iff m->owner == nullptr,
-  // otherwise m->owner may contain a thread id, a stack address for LM_LEGACY,
-  // the ANONYMOUS_OWNER constant for LM_LIGHTWEIGHT.
-  //
-  // Try to CAS m->owner from null to current thread id.
+  // Try to CAS owner (no owner => current thread's _lock_id).
   add(tmp, disp_hdr, (in_bytes(ObjectMonitor::owner_offset()) - markWord::monitor_value));
   Register tid = tmp4Reg;
   ld(tid, Address(xthread, JavaThread::lock_id_offset()));
@@ -404,7 +400,7 @@ void C2_MacroAssembler::fast_lock_lightweight(Register obj, Register box,
     // Compute owner address.
     la(tmp2_owner_addr, owner_address);
 
-    // CAS owner (null => current thread id).
+    // Try to CAS owner (no owner => current thread's _lock_id).
     Register tid = tmp4;
     ld(tid, Address(xthread, JavaThread::lock_id_offset()));
     cmpxchg(/*addr*/ tmp2_owner_addr, /*expected*/ zr, /*new*/ tid, Assembler::int64,

src/hotspot/cpu/riscv/continuationFreezeThaw_riscv.inline.hpp

@@ -316,7 +316,7 @@ inline intptr_t* ThawBase::possibly_adjust_frame(frame& top) {
     sp[-1] = sp[1];
 
     log_develop_trace(continuations, preempt)("adjusted sp for c2 runtime stub, initial sp: " INTPTR_FORMAT " final sp: " INTPTR_FORMAT
-                                              " fp: " INTPTR_FORMAT, p2i(sp + frame::metadata_words), p2i(sp), sp[-2]);
+                                              " fp: " INTPTR_FORMAT, p2i(sp + 2), p2i(sp), sp[-2]);
   }
   return sp;
 }

src/hotspot/cpu/riscv/frame_riscv.cpp

@@ -393,6 +393,36 @@ frame frame::sender_for_upcall_stub_frame(RegisterMap* map) const {
   return fr;
 }
 
+#if defined(ASSERT)
+static address get_register_address_in_stub(const frame& stub_fr, VMReg reg) {
+  RegisterMap map(nullptr,
+                  RegisterMap::UpdateMap::include,
+                  RegisterMap::ProcessFrames::skip,
+                  RegisterMap::WalkContinuation::skip);
+  stub_fr.oop_map()->update_register_map(&stub_fr, &map);
+  return map.location(reg, stub_fr.sp());
+}
+#endif
+
+JavaThread** frame::saved_thread_address(const frame& f) {
+  CodeBlob* cb = f.cb();
+  assert(cb != nullptr && cb->is_runtime_stub(), "invalid frame");
+
+  JavaThread** thread_addr;
+#ifdef COMPILER1
+  if (cb == Runtime1::blob_for(C1StubId::monitorenter_id) ||
+      cb == Runtime1::blob_for(C1StubId::monitorenter_nofpu_id)) {
+    thread_addr = (JavaThread**)(f.sp() + Runtime1::runtime_blob_current_thread_offset(f));
+  } else
+#endif
+  {
+    // c2 only saves rbp in the stub frame so nothing to do.
+    thread_addr = nullptr;
+  }
+  assert(get_register_address_in_stub(f, SharedRuntime::thread_register()) == (address)thread_addr, "wrong thread address");
+  return thread_addr;
+}
+
 //------------------------------------------------------------------------------
 // frame::verify_deopt_original_pc
 //

src/hotspot/cpu/s390/frame_s390.cpp

@@ -246,6 +246,11 @@ frame frame::sender_for_upcall_stub_frame(RegisterMap* map) const {
   return fr;
 }
 
+JavaThread** frame::saved_thread_address(const frame& f) {
+  Unimplemented();
+  return nullptr;
+}
+
 frame frame::sender_for_interpreter_frame(RegisterMap *map) const {
   // Pass callers sender_sp as unextended_sp.
   return frame(sender_sp(), sender_pc(), (intptr_t*)(ijava_state()->sender_sp));

src/hotspot/cpu/s390/macroAssembler_s390.cpp

@@ -3561,12 +3561,10 @@ void MacroAssembler::compiler_fast_lock_object(Register oop, Register box, Regis
 
   Register zero = temp;
   Register monitor_tagged = displacedHeader; // Tagged with markWord::monitor_value.
-  // The object's monitor m is unlocked iff m->owner is null,
-  // otherwise m->owner may contain a thread or a stack address.
 
-  // Try to CAS m->owner from null to current thread's id.
-  // If m->owner is null, then csg succeeds and sets m->owner=THREAD_ID and CR=EQ.
-  // Otherwise, register zero is filled with the current owner.
+  // Try to CAS owner (no owner => current thread's _lock_id).
+  // If csg succeeds then CR=EQ, otherwise, register zero is filled
+  // with the current owner.
   z_lghi(zero, 0);
   z_l(Z_R1_scratch, Address(Z_thread, JavaThread::lock_id_offset()));
   z_csg(zero, Z_R1_scratch, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner), monitor_tagged);
@@ -6309,9 +6307,9 @@ void MacroAssembler::compiler_fast_lock_lightweight_object(Register obj, Registe
     const Address recursions_address(tmp1_monitor, ObjectMonitor::recursions_offset() - monitor_tag);
 
 
-    // Try to CAS m->owner from null to current thread's id.
-    // If m->owner is null, then csg succeeds and sets m->owner=THREAD_ID and CR=EQ.
-    // Otherwise, register zero is filled with the current owner.
+    // Try to CAS owner (no owner => current thread's _lock_id).
+    // If csg succeeds then CR=EQ, otherwise, register zero is filled
+    // with the current owner.
     z_lghi(zero, 0);
     z_l(Z_R1_scratch, Address(Z_thread, JavaThread::lock_id_offset()));
     z_csg(zero, Z_R1_scratch, owner_address);

src/hotspot/cpu/x86/c2_MacroAssembler_x86.cpp

@@ -625,7 +625,7 @@ void C2_MacroAssembler::fast_lock_lightweight(Register obj, Register box, Regist
       movptr(Address(box, BasicLock::object_monitor_cache_offset_in_bytes()), monitor);
     }
 
-    // CAS owner (null => current thread).
+    // Try to CAS owner (no owner => current thread's _lock_id).
     xorptr(rax_reg, rax_reg);
     movptr(box, Address(thread, JavaThread::lock_id_offset()));
     lock(); cmpxchgptr(box, owner_address);

src/hotspot/cpu/x86/frame_x86.cpp

@@ -409,6 +409,36 @@ frame frame::sender_for_upcall_stub_frame(RegisterMap* map) const {
   return fr;
 }
 
+#if defined(ASSERT)
+static address get_register_address_in_stub(const frame& stub_fr, VMReg reg) {
+  RegisterMap map(nullptr,
+                  RegisterMap::UpdateMap::include,
+                  RegisterMap::ProcessFrames::skip,
+                  RegisterMap::WalkContinuation::skip);
+  stub_fr.oop_map()->update_register_map(&stub_fr, &map);
+  return map.location(reg, stub_fr.sp());
+}
+#endif
+
+JavaThread** frame::saved_thread_address(const frame& f) {
+  CodeBlob* cb = f.cb();
+  assert(cb != nullptr && cb->is_runtime_stub(), "invalid frame");
+
+  JavaThread** thread_addr;
+#ifdef COMPILER1
+  if (cb == Runtime1::blob_for(C1StubId::monitorenter_id) ||
+      cb == Runtime1::blob_for(C1StubId::monitorenter_nofpu_id)) {
+    thread_addr = (JavaThread**)(f.sp() + Runtime1::runtime_blob_current_thread_offset(f));
+  } else
+#endif
+  {
+    // c2 only saves rbp in the stub frame so nothing to do.
+    thread_addr = nullptr;
+  }
+  assert(get_register_address_in_stub(f, SharedRuntime::thread_register()) == (address)thread_addr, "wrong thread address");
+  return thread_addr;
+}
+
 //------------------------------------------------------------------------------
 // frame::verify_deopt_original_pc
 //

src/hotspot/cpu/zero/frame_zero.cpp

@@ -72,6 +72,11 @@ bool frame::upcall_stub_frame_is_first() const {
   return false;
 }
 
+JavaThread** frame::saved_thread_address(const frame& f) {
+  Unimplemented();
+  return nullptr;
+}
+
 frame frame::sender_for_nonentry_frame(RegisterMap *map) const {
   assert(zeroframe()->is_interpreter_frame() ||
          zeroframe()->is_fake_stub_frame(), "wrong type of frame");

src/hotspot/share/prims/jvmtiExport.cpp

@@ -1678,7 +1678,7 @@ void JvmtiExport::post_vthread_unmount(jobject vthread) {
   HandleMark hm(thread);
   EVT_TRIG_TRACE(EXT_EVENT_VIRTUAL_THREAD_UNMOUNT, ("[%p] Trg Virtual Thread Unmount event triggered", vthread));
 
-  // On preemption JVMTI state rebinding has already happened so get it always direclty from the oop.
+  // On preemption JVMTI state rebinding has already happened so get it always directly from the oop.
   JvmtiThreadState *state = java_lang_Thread::jvmti_thread_state(JNIHandles::resolve(vthread));
   if (state == NULL) {
     return;

src/hotspot/share/runtime/frame.cpp

@@ -60,9 +60,6 @@
 #include "utilities/debug.hpp"
 #include "utilities/decoder.hpp"
 #include "utilities/formatBuffer.hpp"
-#ifdef COMPILER1
-#include "c1/c1_Runtime1.hpp"
-#endif
 
 RegisterMap::RegisterMap(JavaThread *thread, UpdateMap update_map, ProcessFrames process_frames, WalkContinuation walk_cont) {
   _thread         = thread;
@@ -500,41 +497,6 @@ jint frame::interpreter_frame_expression_stack_size() const {
   return (jint)stack_size;
 }
 
-#if defined(ASSERT) && !defined(PPC64)
-static address get_register_address_in_stub(const frame& stub_fr, VMReg reg) {
-  RegisterMap map(nullptr,
-                  RegisterMap::UpdateMap::include,
-                  RegisterMap::ProcessFrames::skip,
-                  RegisterMap::WalkContinuation::skip);
-  stub_fr.oop_map()->update_register_map(&stub_fr, &map);
-  return map.location(reg, stub_fr.sp());
-}
-#endif
-
-JavaThread** frame::saved_thread_address(const frame& f) {
-#if defined(PPC64)
-  // The current thread (JavaThread*) is never stored on the stack
-  return nullptr;
-#else
-  CodeBlob* cb = f.cb();
-  assert(cb != nullptr && cb->is_runtime_stub(), "invalid frame");
-
-  JavaThread** thread_addr;
-#ifdef COMPILER1
-  if (cb == Runtime1::blob_for(C1StubId::monitorenter_id) ||
-      cb == Runtime1::blob_for(C1StubId::monitorenter_nofpu_id)) {
-    thread_addr = (JavaThread**)(f.sp() + Runtime1::runtime_blob_current_thread_offset(f));
-  } else
-#endif
-  {
-    // c2 only saves rbp in the stub frame so nothing to do.
-    thread_addr = nullptr;
-  }
-  assert(get_register_address_in_stub(f, SharedRuntime::thread_register()) == (address)thread_addr, "wrong thread address");
-  return thread_addr;
-#endif
-}
-
 // (frame::interpreter_frame_sender_sp accessor is in frame_<arch>.cpp)
 
 const char* frame::print_name() const {

src/hotspot/share/runtime/objectMonitor.hpp

@@ -173,17 +173,9 @@ class ObjectMonitor : public CHeapObj<mtObjectMonitor> {
 
   static const int64_t NO_OWNER = 0;
   static const int64_t ANONYMOUS_OWNER = 1;
-  // Used by async deflation as a marker in the _owner field.
-  // Note that the choice of the two markers is peculiar:
-  // - They need to represent values that cannot be pointers. In particular,
-  //   we achieve this by using the lowest two bits.
-  // - ANONYMOUS_OWNER should be a small value, it is used in generated code
-  //   and small values encode much better.
-  // - We test for anonymous owner by testing for the lowest bit, therefore
-  //   DEFLATER_MARKER must *not* have that bit set.
   static const int64_t DEFLATER_MARKER = 2;
 
-  int64_t volatile _owner;  // Either tid of owner, ANONYMOUS_OWNER_MARKER or DEFLATER_MARKER.
+  int64_t volatile _owner;  // Either tid of owner, NO_OWNER, ANONYMOUS_OWNER or DEFLATER_MARKER.
   volatile uint64_t _previous_owner_tid;  // thread id of the previous owner of the monitor
   // Separate _owner and _next_om on different cache lines since
   // both can have busy multi-threaded access. _previous_owner_tid is only