8338383: Implement JEP 491: Synchronize Virtual Threads without Pinning

src/hotspot/cpu/aarch64/c1_Runtime1_aarch64.cpp

@@ -189,6 +189,7 @@ void StubAssembler::epilogue(bool use_pop) {
   // must restore the rfp value saved on enter though.
   if (use_pop) {
     ldp(rfp, lr, Address(post(sp, 2 * wordSize)));
+    authenticate_return_address();
   } else {
     leave();
   }

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

@@ -129,10 +129,9 @@ void FreezeBase::adjust_interpreted_frame_unextended_sp(frame& f) {
   }
 }
 
-inline void FreezeBase::prepare_freeze_interpreted_top_frame(const frame& f) {
+inline void FreezeBase::prepare_freeze_interpreted_top_frame(frame& f) {
   assert(*f.addr_at(frame::interpreter_frame_last_sp_offset) == 0, "should be null for top frame");
-  intptr_t* lspp = f.addr_at(frame::interpreter_frame_last_sp_offset);
-  *lspp = f.unextended_sp() - f.fp();
+  f.interpreter_frame_set_last_sp(f.unextended_sp());
 }
 
 inline void FreezeBase::relativize_interpreted_frame_metadata(const frame& f, const frame& hf) {

src/hotspot/cpu/arm/continuationFreezeThaw_arm.inline.hpp

@@ -48,7 +48,7 @@ void FreezeBase::adjust_interpreted_frame_unextended_sp(frame& f) {
   Unimplemented();
 }
 
-inline void FreezeBase::prepare_freeze_interpreted_top_frame(const frame& f) {
+inline void FreezeBase::prepare_freeze_interpreted_top_frame(frame& f) {
   Unimplemented();
 }
 

src/hotspot/cpu/ppc/continuationFreezeThaw_ppc.inline.hpp

@@ -71,7 +71,7 @@ void FreezeBase::adjust_interpreted_frame_unextended_sp(frame& f) {
   // nothing to do
 }
 
-inline void FreezeBase::prepare_freeze_interpreted_top_frame(const frame& f) {
+inline void FreezeBase::prepare_freeze_interpreted_top_frame(frame& f) {
   // nothing to do
   DEBUG_ONLY( intptr_t* lspp = (intptr_t*) &(f.get_ijava_state()->top_frame_sp); )
   assert(*lspp == f.unextended_sp() - f.fp(), "should be " INTPTR_FORMAT " usp:" INTPTR_FORMAT " fp:" INTPTR_FORMAT, *lspp, p2i(f.unextended_sp()), p2i(f.fp()));

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

@@ -127,10 +127,9 @@ void FreezeBase::adjust_interpreted_frame_unextended_sp(frame& f) {
   }
 }
 
-inline void FreezeBase::prepare_freeze_interpreted_top_frame(const frame& f) {
+inline void FreezeBase::prepare_freeze_interpreted_top_frame(frame& f) {
   assert(*f.addr_at(frame::interpreter_frame_last_sp_offset) == 0, "should be null for top frame");
-  intptr_t* lspp = f.addr_at(frame::interpreter_frame_last_sp_offset);
-  *lspp = f.unextended_sp() - f.fp();
+  f.interpreter_frame_set_last_sp(f.unextended_sp());
 }
 
 inline void FreezeBase::relativize_interpreted_frame_metadata(const frame& f, const frame& hf) {

src/hotspot/cpu/s390/continuationFreezeThaw_s390.inline.hpp

@@ -48,7 +48,7 @@ void FreezeBase::adjust_interpreted_frame_unextended_sp(frame& f) {
   Unimplemented();
 }
 
-inline void FreezeBase::prepare_freeze_interpreted_top_frame(const frame& f) {
+inline void FreezeBase::prepare_freeze_interpreted_top_frame(frame& f) {
   Unimplemented();
 }
 

src/hotspot/cpu/x86/continuationFreezeThaw_x86.inline.hpp

@@ -126,10 +126,9 @@ void FreezeBase::adjust_interpreted_frame_unextended_sp(frame& f) {
   }
 }
 
-inline void FreezeBase::prepare_freeze_interpreted_top_frame(const frame& f) {
+inline void FreezeBase::prepare_freeze_interpreted_top_frame(frame& f) {
   assert(*f.addr_at(frame::interpreter_frame_last_sp_offset) == 0, "should be null for top frame");
-  intptr_t* lspp = f.addr_at(frame::interpreter_frame_last_sp_offset);
-  *lspp = f.unextended_sp() - f.fp();
+  f.interpreter_frame_set_last_sp(f.unextended_sp());
 }
 
 inline void FreezeBase::relativize_interpreted_frame_metadata(const frame& f, const frame& hf) {

src/hotspot/cpu/zero/continuationFreezeThaw_zero.inline.hpp

@@ -48,7 +48,7 @@ void FreezeBase::adjust_interpreted_frame_unextended_sp(frame& f) {
   Unimplemented();
 }
 
-inline void FreezeBase::prepare_freeze_interpreted_top_frame(const frame& f) {
+inline void FreezeBase::prepare_freeze_interpreted_top_frame(frame& f) {
   Unimplemented();
 }
 

src/hotspot/share/runtime/continuationFreezeThaw.cpp

@@ -455,7 +455,7 @@ class FreezeBase : public StackObj {
   inline void set_top_frame_metadata_pd(const frame& hf);
   inline void patch_pd(frame& callee, const frame& caller);
   void adjust_interpreted_frame_unextended_sp(frame& f);
-  static inline void prepare_freeze_interpreted_top_frame(const frame& f);
+  static inline void prepare_freeze_interpreted_top_frame(frame& f);
   static inline void relativize_interpreted_frame_metadata(const frame& f, const frame& hf);
 
 protected:

src/hotspot/share/runtime/lightweightSynchronizer.cpp

@@ -804,10 +804,10 @@ ObjectMonitor* LightweightSynchronizer::inflate_locked_or_imse(oop obj, ObjectSy
   }
 }
 
-ObjectMonitor* LightweightSynchronizer::inflate_into_object_header(oop object, ObjectSynchronizer::InflateCause cause, JavaThread* inflating_thread, Thread* current) {
+ObjectMonitor* LightweightSynchronizer::inflate_into_object_header(oop object, ObjectSynchronizer::InflateCause cause, JavaThread* locking_thread, Thread* current) {
 
-  // The JavaThread* inflating_thread parameter is only used by LM_LIGHTWEIGHT and requires
-  // that the inflating_thread == Thread::current() or is suspended throughout the call by
+  // The JavaThread* locking_thread parameter is only used by LM_LIGHTWEIGHT and requires
+  // that the locking_thread == Thread::current() or is suspended throughout the call by
   // some other mechanism.
   // Even with LM_LIGHTWEIGHT the thread might be nullptr when called from a non
   // JavaThread. (As may still be the case from FastHashCode). However it is only
@@ -822,10 +822,10 @@ ObjectMonitor* LightweightSynchronizer::inflate_into_object_header(oop object, O
     // The mark can be in one of the following states:
     // *  inflated     - Just return if using stack-locking.
     //                   If using fast-locking and the ObjectMonitor owner
-    //                   is anonymous and the inflating_thread owns the
-    //                   object lock, then we make the inflating_thread
+    //                   is anonymous and the locking_thread owns the
+    //                   object lock, then we make the locking_thread
     //                   the ObjectMonitor owner and remove the lock from
-    //                   the inflating_thread's lock stack.
+    //                   the locking_thread's lock stack.
     // *  fast-locked  - Coerce it to inflated from fast-locked.
     // *  unlocked     - Aggressively inflate the object.
 
@@ -835,31 +835,31 @@ ObjectMonitor* LightweightSynchronizer::inflate_into_object_header(oop object, O
       markWord dmw = inf->header();
       assert(dmw.is_neutral(), "invariant: header=" INTPTR_FORMAT, dmw.value());
       if (inf->has_anonymous_owner() &&
-          inflating_thread != nullptr && inflating_thread->lock_stack().contains(object)) {
-        inf->set_owner_from_anonymous(inflating_thread);
-        size_t removed = inflating_thread->lock_stack().remove(object);
+          locking_thread != nullptr && locking_thread->lock_stack().contains(object)) {
+        inf->set_owner_from_anonymous(locking_thread);
+        size_t removed = locking_thread->lock_stack().remove(object);
         inf->set_recursions(removed - 1);
       }
       return inf;
     }
 
     // CASE: fast-locked
-    // Could be fast-locked either by the inflating_thread or by some other thread.
+    // Could be fast-locked either by the locking_thread or by some other thread.
     //
     // Note that we allocate the ObjectMonitor speculatively, _before_
     // attempting to set the object's mark to the new ObjectMonitor. If
-    // the inflating_thread owns the monitor, then we set the ObjectMonitor's
-    // owner to the inflating_thread. Otherwise, we set the ObjectMonitor's owner
+    // the locking_thread owns the monitor, then we set the ObjectMonitor's
+    // owner to the locking_thread. Otherwise, we set the ObjectMonitor's owner
     // to anonymous. If we lose the race to set the object's mark to the
     // new ObjectMonitor, then we just delete it and loop around again.
     //
     if (mark.is_fast_locked()) {
       ObjectMonitor* monitor = new ObjectMonitor(object);
       monitor->set_header(mark.set_unlocked());
-      bool own = inflating_thread != nullptr && inflating_thread->lock_stack().contains(object);
+      bool own = locking_thread != nullptr && locking_thread->lock_stack().contains(object);
       if (own) {
-        // Owned by inflating_thread.
-        monitor->set_owner(inflating_thread);
+        // Owned by locking_thread.
+        monitor->set_owner(locking_thread);
       } else {
         // Owned by somebody else.
         monitor->set_anonymous_owner();
@@ -869,7 +869,7 @@ ObjectMonitor* LightweightSynchronizer::inflate_into_object_header(oop object, O
       if (old_mark == mark) {
         // Success! Return inflated monitor.
         if (own) {
-          size_t removed = inflating_thread->lock_stack().remove(object);
+          size_t removed = locking_thread->lock_stack().remove(object);
           monitor->set_recursions(removed - 1);
         }
         // Once the ObjectMonitor is configured and object is associated

src/hotspot/share/runtime/lightweightSynchronizer.hpp

@@ -63,7 +63,7 @@ class LightweightSynchronizer : AllStatic {
   static void enter(Handle obj, BasicLock* lock, JavaThread* current);
   static void exit(oop object, JavaThread* current);
 
-  static ObjectMonitor* inflate_into_object_header(oop object, ObjectSynchronizer::InflateCause cause, JavaThread* inflating_thread, Thread* current);
+  static ObjectMonitor* inflate_into_object_header(oop object, ObjectSynchronizer::InflateCause cause, JavaThread* locking_thread, Thread* current);
   static ObjectMonitor* inflate_locked_or_imse(oop object, ObjectSynchronizer::InflateCause cause, TRAPS);
   static ObjectMonitor* inflate_fast_locked_object(oop object, ObjectSynchronizer::InflateCause cause, JavaThread* locking_thread, JavaThread* current);
   static ObjectMonitor* inflate_and_enter(oop object, ObjectSynchronizer::InflateCause cause, JavaThread* locking_thread, JavaThread* current);

src/hotspot/share/runtime/objectMonitor.cpp

@@ -2367,7 +2367,7 @@ ObjectWaiter::~ObjectWaiter() {
   }
 }
 
-oop ObjectWaiter::vthread() {
+oop ObjectWaiter::vthread() const {
   return _vthread.resolve();
 }
 

src/hotspot/share/runtime/objectMonitor.hpp

@@ -61,15 +61,15 @@ class ObjectWaiter : public CHeapObj<mtThread> {
   ObjectWaiter(JavaThread* current);
   ObjectWaiter(oop vthread, ObjectMonitor* mon);
   ~ObjectWaiter();
-  JavaThread* thread() { return _thread; }
-  bool is_vthread()    { return _thread == nullptr; }
-  uint8_t state()      { return TState; }
-  ObjectMonitor* monitor() { return _monitor; }
-  bool is_monitorenter()   { return !_is_wait; }
-  bool is_wait()           { return _is_wait; }
-  bool notified()          { return _notified; }
-  bool at_reenter()        { return _at_reenter; }
-  oop vthread();
+  JavaThread* thread()      const { return _thread; }
+  bool is_vthread()         const { return _thread == nullptr; }
+  uint8_t state()           const { return TState; }
+  ObjectMonitor* monitor()  const { return _monitor; }
+  bool is_monitorenter()    const { return !_is_wait; }
+  bool is_wait()            const { return _is_wait; }
+  bool notified()           const { return _notified; }
+  bool at_reenter()         const { return _at_reenter; }
+  oop vthread() const;
   void wait_reenter_begin(ObjectMonitor *mon);
   void wait_reenter_end(ObjectMonitor *mon);
 };

src/hotspot/share/runtime/synchronizer.cpp

@@ -1437,8 +1437,8 @@ ObjectMonitor* ObjectSynchronizer::inflate_for(JavaThread* thread, oop obj, cons
   return inflate_impl(thread, obj, cause);
 }
 
-ObjectMonitor* ObjectSynchronizer::inflate_impl(JavaThread* inflating_thread, oop object, const InflateCause cause) {
-  // The JavaThread* inflating_thread requires that the inflating_thread == Thread::current() or
+ObjectMonitor* ObjectSynchronizer::inflate_impl(JavaThread* locking_thread, oop object, const InflateCause cause) {
+  // The JavaThread* locking_thread requires that the locking_thread == Thread::current() or
   // is suspended throughout the call by some other mechanism.
   // The thread might be nullptr when called from a non JavaThread. (As may still be
   // the case from FastHashCode). However it is only important for correctness that the
@@ -1452,8 +1452,8 @@ ObjectMonitor* ObjectSynchronizer::inflate_impl(JavaThread* inflating_thread, oo
 
     // The mark can be in one of the following states:
     // *  inflated     - If the ObjectMonitor owner is anonymous and the
-    //                   inflating_thread owns the object lock, then we
-    //                   make the inflating_thread the ObjectMonitor owner.
+    //                   locking_thread owns the object lock, then we
+    //                   make the locking_thread the ObjectMonitor owner.
     // *  stack-locked - Coerce it to inflated from stack-locked.
     // *  INFLATING    - Busy wait for conversion from stack-locked to
     //                   inflated.
@@ -1464,11 +1464,11 @@ ObjectMonitor* ObjectSynchronizer::inflate_impl(JavaThread* inflating_thread, oo
       ObjectMonitor* inf = mark.monitor();
       markWord dmw = inf->header();
       assert(dmw.is_neutral(), "invariant: header=" INTPTR_FORMAT, dmw.value());
-      if (inf->has_anonymous_owner() && inflating_thread != nullptr) {
+      if (inf->has_anonymous_owner() && locking_thread != nullptr) {
         assert(LockingMode == LM_LEGACY, "invariant");
-        if (inflating_thread->is_lock_owned((address)inf->stack_locker())) {
+        if (locking_thread->is_lock_owned((address)inf->stack_locker())) {
           inf->set_stack_locker(nullptr);
-          inf->set_owner_from_anonymous(inflating_thread);
+          inf->set_owner_from_anonymous(locking_thread);
         }
       }
       return inf;
@@ -1550,8 +1550,8 @@ ObjectMonitor* ObjectSynchronizer::inflate_impl(JavaThread* inflating_thread, oo
       // Note that a thread can inflate an object
       // that it has stack-locked -- as might happen in wait() -- directly
       // with CAS.  That is, we can avoid the xchg-nullptr .... ST idiom.
-      if (inflating_thread != nullptr && inflating_thread->is_lock_owned((address)mark.locker())) {
-        m->set_owner(inflating_thread);
+      if (locking_thread != nullptr && locking_thread->is_lock_owned((address)mark.locker())) {
+        m->set_owner(locking_thread);
       } else {
         // Use ANONYMOUS_OWNER to indicate that the owner is the BasicLock on the stack,
         // and set the stack locker field in the monitor.

src/hotspot/share/runtime/synchronizer.hpp

@@ -137,7 +137,7 @@ class ObjectSynchronizer : AllStatic {
 
 private:
   // Shared implementation between the different LockingMode.
-  static ObjectMonitor* inflate_impl(JavaThread* inflating_thread, oop obj, const InflateCause cause);
+  static ObjectMonitor* inflate_impl(JavaThread* locking_thread, oop obj, const InflateCause cause);
 
 public:
   // This version is only for internal use