Remove ObjectMonitor::set_owner_from_BasicLock()

Author: pchilano

src/hotspot/share/runtime/objectMonitor.cpp

@@ -1536,23 +1536,12 @@ void ObjectMonitor::ExitEpilog(JavaThread* current, ObjectWaiter* Wakee) {
   OM_PERFDATA_OP(Parks, inc());
 }
 
-// complete_exit exits a lock returning recursion count
-// complete_exit requires an inflated monitor
-// The _owner field is not always the Thread addr even with an
-// inflated monitor, e.g. the monitor can be inflated by a non-owning
-// thread due to contention.
+// Exits the monitor returning recursion count. _owner should
+// be set to current's tid, i.e. no ANONYMOUS_OWNER allowed.
 intx ObjectMonitor::complete_exit(JavaThread* current) {
   assert(InitDone, "Unexpectedly not initialized");
-
-  if (!has_owner(current)) {
-    if (LockingMode == LM_LEGACY && has_stack_locker(current)) {
-      assert(_recursions == 0, "internal state error");
-      set_owner_from_BasicLock(current);  // Convert from BasicLock* to Thread*.
-      _recursions = 0;
-    }
-  }
-
   guarantee(has_owner(current), "complete_exit not owner");
+
   intx save = _recursions; // record the old recursion count
   _recursions = 0;         // set the recursion level to be 0
   exit(current);           // exit the monitor

src/hotspot/share/runtime/objectMonitor.hpp

@@ -298,8 +298,6 @@ class ObjectMonitor : public CHeapObj<mtObjectMonitor> {
   void      set_owner_from_raw(int64_t old_value, int64_t new_value);
   // Same as above but uses tid of current as new value.
   void      set_owner_from(int64_t old_value, JavaThread* current);
-  // Set _owner field to tid of current thread; current value must be ANONYMOUS_OWNER.
-  void      set_owner_from_BasicLock(JavaThread* current);
   // Try to set _owner field to new_value if the current value matches
   // old_value, using Atomic::cmpxchg(). Otherwise, does not change the
   // _owner field. Returns the prior value of the _owner field.
@@ -330,9 +328,6 @@ class ObjectMonitor : public CHeapObj<mtObjectMonitor> {
     set_owner_from(ANONYMOUS_OWNER, owner);
   }
 
-  // Returns true if BasicLock* stored in _stack_locker
-  // points to current's stack, false otherwise.
-  bool has_stack_locker(JavaThread* current);
   // Get and set _stack_locker.
   BasicLock* stack_locker() const;
   void set_stack_locker(BasicLock* locker);

src/hotspot/share/runtime/objectMonitor.inline.hpp

@@ -125,10 +125,6 @@ inline void ObjectMonitor::set_stack_locker(BasicLock* locker) {
   Atomic::store(&_stack_locker, locker);
 }
 
-inline bool ObjectMonitor::has_stack_locker(JavaThread* current) {
-  return has_owner_anonymous() && current->is_lock_owned((address)stack_locker());
-}
-
 // Returns true if owner field == DEFLATER_MARKER and false otherwise.
 // This accessor is called when we really need to know if the owner
 // field == DEFLATER_MARKER and any non-null value won't do the trick.
@@ -191,22 +187,6 @@ inline void ObjectMonitor::set_owner_from(int64_t old_value, JavaThread* current
   set_owner_from_raw(old_value, owner_from(current));
 }
 
-// Simply set _owner to the tid of current. Current owner must be anonymous.
-inline void ObjectMonitor::set_owner_from_BasicLock(JavaThread* current) {
-  BasicLock* basic_lock_p = stack_locker();
-
-  set_stack_locker(nullptr); // first
-  assert(has_owner_anonymous(), "");
-
-  // Non-null owner field to non-null owner field is safe without
-  // cmpxchg() as long as all readers can tolerate either flavor.
-  Atomic::store(&_owner, owner_from(current));
-  log_trace(monitorinflation, owner)("set_owner_from_BasicLock(): mid="
-                                     INTPTR_FORMAT ", basic_lock_p="
-                                     INTPTR_FORMAT ", new_value=" INT64_FORMAT,
-                                     p2i(this), p2i(basic_lock_p), owner_from(current));
-}
-
 // Try to set _owner field to new_value if the current value matches
 // old_value. Otherwise, does not change the _owner field. Returns
 // the prior value of the _owner field.

src/hotspot/share/runtime/synchronizer.cpp

@@ -1467,7 +1467,8 @@ ObjectMonitor* ObjectSynchronizer::inflate_impl(JavaThread* inflating_thread, oo
       if (inf->has_owner_anonymous() && inflating_thread != nullptr) {
         assert(LockingMode == LM_LEGACY, "invariant");
         if (inflating_thread->is_lock_owned((address)inf->stack_locker())) {
-          inf->set_owner_from_BasicLock(inflating_thread);
+          inf->set_stack_locker(nullptr);
+          inf->set_owner_from_anonymous(inflating_thread);
         }
       }
       return inf;