8369238: Allow virtual thread preemption on some common class initialization paths

src/hotspot/share/cds/aotConstantPoolResolver.cpp

@@ -275,7 +275,7 @@ void AOTConstantPoolResolver::maybe_resolve_fmi_ref(InstanceKlass* ik, Method* m
   switch (bc) {
   case Bytecodes::_getfield:
   case Bytecodes::_putfield:
-    InterpreterRuntime::resolve_get_put(bc, raw_index, mh, cp, StaticMode::dont_initialize_klass, CHECK);
+    InterpreterRuntime::resolve_get_put(bc, raw_index, mh, cp, ClassInitMode::dont_init, CHECK);
     break;
 
   case Bytecodes::_invokevirtual:

src/hotspot/share/ci/ciField.cpp

@@ -400,7 +400,7 @@ bool ciField::will_link(ciMethod* accessing_method,
                      _name->get_symbol(), _signature->get_symbol(),
                      methodHandle(THREAD, accessing_method->get_Method()));
   fieldDescriptor result;
-  LinkResolver::resolve_field(result, link_info, bc, StaticMode::dont_initialize_klass, CHECK_AND_CLEAR_(false));
+  LinkResolver::resolve_field(result, link_info, bc, ClassInitMode::dont_init, CHECK_AND_CLEAR_(false));
 
   // update the hit-cache, unless there is a problem with memory scoping:
   if (accessing_method->holder()->is_shared() || !is_shared()) {

src/hotspot/share/classfile/javaClasses.cpp

@@ -2127,7 +2127,7 @@ int java_lang_VirtualThread::_objectWaiter_offset;
   macro(_next_offset,                      k, "next",               vthread_signature,           false); \
   macro(_onWaitingList_offset,             k, "onWaitingList",      bool_signature,              false); \
   macro(_notified_offset,                  k, "notified",           bool_signature,              false); \
-  macro(_interruptible_wait_offset,        k, "interruptableWait",  bool_signature,              false); \
+  macro(_interruptible_wait_offset,        k, "interruptibleWait",  bool_signature,              false); \
   macro(_timeout_offset,                   k, "timeout",            long_signature,              false);
 
 

src/hotspot/share/interpreter/interpreterRuntime.cpp

@@ -652,22 +652,21 @@ void InterpreterRuntime::resolve_get_put(JavaThread* current, Bytecodes::Code by
   constantPoolHandle pool(current, last_frame.method()->constants());
   methodHandle m(current, last_frame.method());
 
-  resolve_get_put(bytecode, last_frame.get_index_u2(bytecode), m, pool, StaticMode::initialize_klass_preemptable, CHECK_AND_CLEAR_PREEMPTED);
+  resolve_get_put(bytecode, last_frame.get_index_u2(bytecode), m, pool, ClassInitMode::init_preemptable, CHECK_AND_CLEAR_PREEMPTED);
 }
 
 void InterpreterRuntime::resolve_get_put(Bytecodes::Code bytecode, int field_index,
                                          methodHandle& m,
                                          constantPoolHandle& pool,
-                                         StaticMode static_mode, TRAPS) {
+                                         ClassInitMode init_mode, TRAPS) {
   fieldDescriptor info;
   bool is_put    = (bytecode == Bytecodes::_putfield  || bytecode == Bytecodes::_nofast_putfield ||
                     bytecode == Bytecodes::_putstatic);
   bool is_static = (bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic);
 
   {
     JvmtiHideSingleStepping jhss(THREAD);
-    LinkResolver::resolve_field_access(info, pool, field_index,
-                                       m, bytecode, static_mode, CHECK);
+    LinkResolver::resolve_field_access(info, pool, field_index, m, bytecode, init_mode, CHECK);
   } // end JvmtiHideSingleStepping
 
   // check if link resolution caused cpCache to be updated
@@ -826,7 +825,7 @@ void InterpreterRuntime::resolve_invoke(JavaThread* current, Bytecodes::Code byt
     JavaThread* THREAD = current; // For exception macros.
     LinkResolver::resolve_invoke(info, receiver, pool,
                                  method_index, bytecode,
-                                 StaticMode::initialize_klass_preemptable, THREAD);
+                                 ClassInitMode::init_preemptable, THREAD);
 
     if (HAS_PENDING_EXCEPTION) {
       if (ProfileTraps && PENDING_EXCEPTION->klass()->name() == vmSymbols::java_lang_NullPointerException()) {

src/hotspot/share/interpreter/interpreterRuntime.hpp

@@ -94,7 +94,7 @@ class InterpreterRuntime: AllStatic {
 
   // Used by AOTConstantPoolResolver
   static void resolve_get_put(Bytecodes::Code bytecode, int field_index,
-                              methodHandle& m, constantPoolHandle& pool, StaticMode static_mode, TRAPS);
+                              methodHandle& m, constantPoolHandle& pool, ClassInitMode init_mode, TRAPS);
   static void cds_resolve_invoke(Bytecodes::Code bytecode, int method_index,
                                  constantPoolHandle& pool, TRAPS);
   static void cds_resolve_invokehandle(int raw_index,

src/hotspot/share/interpreter/linkResolver.cpp

@@ -986,14 +986,14 @@ void LinkResolver::resolve_field_access(fieldDescriptor& fd,
                                         int index,
                                         const methodHandle& method,
                                         Bytecodes::Code byte,
-                                        StaticMode static_mode, TRAPS) {
+                                        ClassInitMode init_mode, TRAPS) {
   LinkInfo link_info(pool, index, method, byte, CHECK);
-  resolve_field(fd, link_info, byte, static_mode, CHECK);
+  resolve_field(fd, link_info, byte, init_mode, CHECK);
 }
 
 void LinkResolver::resolve_field(fieldDescriptor& fd,
                                  const LinkInfo& link_info,
-                                 Bytecodes::Code byte, StaticMode static_mode,
+                                 Bytecodes::Code byte, ClassInitMode init_mode,
                                  TRAPS) {
   assert(byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic ||
          byte == Bytecodes::_getfield  || byte == Bytecodes::_putfield  ||
@@ -1078,9 +1078,9 @@ void LinkResolver::resolve_field(fieldDescriptor& fd,
     // note 2: we don't want to force initialization if we are just checking
     //         if the field access is legal; e.g., during compilation
     if (is_static) {
-      if (static_mode == StaticMode::initialize_klass) {
+      if (init_mode == ClassInitMode::init) {
         sel_klass->initialize(CHECK);
-      } else if (static_mode == StaticMode::initialize_klass_preemptable) {
+      } else if (init_mode == ClassInitMode::init_preemptable) {
         sel_klass->initialize_preemptable(CHECK);
       }
     }
@@ -1108,17 +1108,17 @@ void LinkResolver::resolve_field(fieldDescriptor& fd,
 
 void LinkResolver::resolve_static_call(CallInfo& result,
                                        const LinkInfo& link_info,
-                                       StaticMode static_mode, TRAPS) {
+                                       ClassInitMode init_mode, TRAPS) {
   Method* resolved_method = linktime_resolve_static_method(link_info, CHECK);
 
   // The resolved class can change as a result of this resolution.
   Klass* resolved_klass = resolved_method->method_holder();
 
   // Initialize klass (this should only happen if everything is ok)
-  if (static_mode != StaticMode::dont_initialize_klass && resolved_klass->should_be_initialized()) {
-    if (static_mode == StaticMode::initialize_klass) {
+  if (init_mode != ClassInitMode::dont_init && resolved_klass->should_be_initialized()) {
+    if (init_mode == ClassInitMode::init) {
       resolved_klass->initialize(CHECK);
-    } else if (static_mode == StaticMode::initialize_klass_preemptable) {
+    } else if (init_mode == ClassInitMode::init_preemptable) {
       resolved_klass->initialize_preemptable(CHECK);
     }
     // Use updated LinkInfo to reresolve with resolved method holder
@@ -1682,7 +1682,7 @@ int LinkResolver::resolve_virtual_vtable_index(Klass* receiver_klass,
 Method* LinkResolver::resolve_static_call_or_null(const LinkInfo& link_info) {
   EXCEPTION_MARK;
   CallInfo info;
-  resolve_static_call(info, link_info, StaticMode::dont_initialize_klass, THREAD);
+  resolve_static_call(info, link_info, ClassInitMode::dont_init, THREAD);
   if (HAS_PENDING_EXCEPTION) {
     CLEAR_PENDING_EXCEPTION;
     return nullptr;
@@ -1706,15 +1706,15 @@ Method* LinkResolver::resolve_special_call_or_null(const LinkInfo& link_info) {
 //------------------------------------------------------------------------------------------------------------------------
 // ConstantPool entries
 
-void LinkResolver::resolve_invoke(CallInfo& result, Handle recv, const constantPoolHandle& pool, int index, Bytecodes::Code byte, StaticMode static_mode, TRAPS) {
+void LinkResolver::resolve_invoke(CallInfo& result, Handle recv, const constantPoolHandle& pool, int index, Bytecodes::Code byte, ClassInitMode init_mode, TRAPS) {
   switch (byte) {
-    case Bytecodes::_invokestatic   : resolve_invokestatic   (result,       pool, index, static_mode, CHECK); break;
-    case Bytecodes::_invokespecial  : resolve_invokespecial  (result, recv, pool, index,              CHECK); break;
-    case Bytecodes::_invokevirtual  : resolve_invokevirtual  (result, recv, pool, index,              CHECK); break;
-    case Bytecodes::_invokehandle   : resolve_invokehandle   (result,       pool, index,              CHECK); break;
-    case Bytecodes::_invokedynamic  : resolve_invokedynamic  (result,       pool, index,              CHECK); break;
-    case Bytecodes::_invokeinterface: resolve_invokeinterface(result, recv, pool, index,              CHECK); break;
-    default                         :                                                                         break;
+    case Bytecodes::_invokestatic   : resolve_invokestatic   (result,       pool, index, init_mode, CHECK); break;
+    case Bytecodes::_invokespecial  : resolve_invokespecial  (result, recv, pool, index,            CHECK); break;
+    case Bytecodes::_invokevirtual  : resolve_invokevirtual  (result, recv, pool, index,            CHECK); break;
+    case Bytecodes::_invokehandle   : resolve_invokehandle   (result,       pool, index,            CHECK); break;
+    case Bytecodes::_invokedynamic  : resolve_invokedynamic  (result,       pool, index,            CHECK); break;
+    case Bytecodes::_invokeinterface: resolve_invokeinterface(result, recv, pool, index,            CHECK); break;
+    default                         :                                                                       break;
   }
   return;
 }
@@ -1736,7 +1736,7 @@ void LinkResolver::resolve_invoke(CallInfo& result, Handle& recv,
                              /*check_null_and_abstract=*/true, CHECK);
       break;
     case Bytecodes::_invokestatic:
-      resolve_static_call(result, link_info, StaticMode::dont_initialize_klass, CHECK);
+      resolve_static_call(result, link_info, ClassInitMode::dont_init, CHECK);
       break;
     case Bytecodes::_invokespecial:
       resolve_special_call(result, recv, link_info, CHECK);
@@ -1747,9 +1747,9 @@ void LinkResolver::resolve_invoke(CallInfo& result, Handle& recv,
   }
 }
 
-void LinkResolver::resolve_invokestatic(CallInfo& result, const constantPoolHandle& pool, int index, StaticMode static_mode, TRAPS) {
+void LinkResolver::resolve_invokestatic(CallInfo& result, const constantPoolHandle& pool, int index, ClassInitMode init_mode, TRAPS) {
   LinkInfo link_info(pool, index, Bytecodes::_invokestatic, CHECK);
-  resolve_static_call(result, link_info, static_mode, CHECK);
+  resolve_static_call(result, link_info, init_mode, CHECK);
 }
 
 

src/hotspot/share/interpreter/linkResolver.hpp

@@ -189,10 +189,10 @@ class LinkInfo : public StackObj {
   void         print()  PRODUCT_RETURN;
 };
 
-enum class StaticMode : uint8_t {
-  dont_initialize_klass,
-  initialize_klass,
-  initialize_klass_preemptable
+enum class ClassInitMode : uint8_t {
+  dont_init,
+  init,
+  init_preemptable
 };
 
 // Link information for getfield/putfield & getstatic/putstatic bytecodes
@@ -273,7 +273,7 @@ class LinkResolver: AllStatic {
 
   // runtime resolving from constant pool
   static void resolve_invokestatic   (CallInfo& result,
-                                      const constantPoolHandle& pool, int index, StaticMode mode, TRAPS);
+                                      const constantPoolHandle& pool, int index, ClassInitMode mode, TRAPS);
   static void resolve_invokespecial  (CallInfo& result, Handle recv,
                                       const constantPoolHandle& pool, int index, TRAPS);
   static void resolve_invokevirtual  (CallInfo& result, Handle recv,
@@ -301,22 +301,21 @@ class LinkResolver: AllStatic {
                                    int index,
                                    const methodHandle& method,
                                    Bytecodes::Code byte,
-                                   StaticMode mode, TRAPS);
+                                   ClassInitMode mode, TRAPS);
   static void resolve_field_access(fieldDescriptor& result,
                                    const constantPoolHandle& pool,
                                    int index,
                                    const methodHandle& method,
                                    Bytecodes::Code byte, TRAPS) {
-    resolve_field_access(result, pool, index, method, byte,
-                         StaticMode::initialize_klass, THREAD);
+    resolve_field_access(result, pool, index, method, byte, ClassInitMode::init, THREAD);
   }
   static void resolve_field(fieldDescriptor& result, const LinkInfo& link_info,
                             Bytecodes::Code access_kind,
-                            StaticMode mode, TRAPS);
+                            ClassInitMode mode, TRAPS);
 
   static void resolve_static_call   (CallInfo& result,
                                      const LinkInfo& link_info,
-                                     StaticMode mode, TRAPS);
+                                     ClassInitMode mode, TRAPS);
   static void resolve_special_call  (CallInfo& result,
                                      Handle recv,
                                      const LinkInfo& link_info,
@@ -358,11 +357,11 @@ class LinkResolver: AllStatic {
   // runtime resolving from constant pool
   static void resolve_invoke(CallInfo& result, Handle recv,
                              const constantPoolHandle& pool, int index,
-                             Bytecodes::Code byte, StaticMode static_mode, TRAPS);
+                             Bytecodes::Code byte, ClassInitMode static_mode, TRAPS);
   static void resolve_invoke(CallInfo& result, Handle recv,
                              const constantPoolHandle& pool, int index,
                              Bytecodes::Code byte, TRAPS) {
-    resolve_invoke(result, recv, pool, index, byte, StaticMode::initialize_klass, THREAD);
+    resolve_invoke(result, recv, pool, index, byte, ClassInitMode::init, THREAD);
   }
 
   // runtime resolving from attached method

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

@@ -1008,7 +1008,7 @@ C2V_VMENTRY_NULL(jobject, resolveFieldInPool, (JNIEnv* env, jobject, ARGUMENT_PA
   }
 
   LinkInfo link_info(cp, index, mh, code, CHECK_NULL);
-  LinkResolver::resolve_field(fd, link_info, Bytecodes::java_code(code), StaticMode::dont_initialize_klass, CHECK_NULL);
+  LinkResolver::resolve_field(fd, link_info, Bytecodes::java_code(code), ClassInitMode::dont_init, CHECK_NULL);
   JVMCIPrimitiveArray info = JVMCIENV->wrap(info_handle);
   if (info.is_null() || JVMCIENV->get_length(info) != 4) {
     JVMCI_ERROR_NULL("info must not be null and have a length of 4");

src/hotspot/share/prims/methodHandles.cpp

@@ -771,7 +771,7 @@ Handle MethodHandles::resolve_MemberName(Handle mname, Klass* caller, int lookup
         assert(!HAS_PENDING_EXCEPTION, "");
         if (ref_kind == JVM_REF_invokeStatic) {
           LinkResolver::resolve_static_call(result,
-                        link_info, StaticMode::dont_initialize_klass, THREAD);
+                        link_info, ClassInitMode::dont_init, THREAD);
         } else if (ref_kind == JVM_REF_invokeInterface) {
           LinkResolver::resolve_interface_call(result, Handle(), defc,
                         link_info, false, THREAD);
@@ -833,7 +833,7 @@ Handle MethodHandles::resolve_MemberName(Handle mname, Klass* caller, int lookup
       {
         assert(!HAS_PENDING_EXCEPTION, "");
         LinkInfo link_info(defc, name, type, caller, LinkInfo::AccessCheck::skip, loader_constraint_check);
-        LinkResolver::resolve_field(result, link_info, Bytecodes::_nop, StaticMode::dont_initialize_klass, THREAD);
+        LinkResolver::resolve_field(result, link_info, Bytecodes::_nop, ClassInitMode::dont_init, THREAD);
         if (HAS_PENDING_EXCEPTION) {
           if (speculative_resolve) {
             CLEAR_PENDING_EXCEPTION;

src/hotspot/share/runtime/continuationEntry.cpp

@@ -111,11 +111,9 @@ void ContinuationEntry::describe(FrameValues& values, int frame_no) const {
 #endif
 
 #ifdef ASSERT
-bool ContinuationEntry::assert_entry_frame_laid_out(JavaThread* thread, bool preempted) {
+bool ContinuationEntry::assert_entry_frame_laid_out(JavaThread* thread) {
   assert(thread->has_last_Java_frame(), "Wrong place to use this assertion");
 
-  if (preempted) return true;
-
   ContinuationEntry* entry = thread->last_continuation();
   assert(entry != nullptr, "");
 

src/hotspot/share/runtime/continuationEntry.hpp

@@ -146,7 +146,7 @@ class ContinuationEntry {
 #endif
 
 #ifdef ASSERT
-  static bool assert_entry_frame_laid_out(JavaThread* thread, bool preempted = false);
+  static bool assert_entry_frame_laid_out(JavaThread* thread);
 #endif
 };
 

src/hotspot/share/runtime/continuationFreezeThaw.cpp

@@ -193,7 +193,7 @@ static void verify_continuation(oop continuation) { Continuation::debug_verify_c
 
 static void do_deopt_after_thaw(JavaThread* thread);
 static bool do_verify_after_thaw(JavaThread* thread, stackChunkOop chunk, outputStream* st);
-static void log_frames(JavaThread* thread, bool dolog = true);
+static void log_frames(JavaThread* thread, bool do_log = true);
 static void log_frames_after_thaw(JavaThread* thread, ContinuationWrapper& cont, intptr_t* sp);
 static void print_frame_layout(const frame& f, bool callee_complete, outputStream* st = tty);
 static void verify_frame_kind(frame& top, Continuation::preempt_kind preempt_kind, Method** m_ptr = nullptr, const char** code_name_ptr = nullptr, int* bci_ptr = nullptr, stackChunkOop chunk = nullptr);
@@ -3167,10 +3167,10 @@ static bool do_verify_after_thaw(JavaThread* thread, stackChunkOop chunk, output
   return true;
 }
 
-static void log_frames(JavaThread* thread, bool dolog) {
+static void log_frames(JavaThread* thread, bool do_log) {
   const static int show_entry_callers = 3;
   LogTarget(Trace, continuations) lt;
-  if (!lt.develop_is_enabled() || !dolog) {
+  if (!lt.develop_is_enabled() || !do_log) {
     return;
   }
   LogStream ls(lt);
@@ -3230,7 +3230,7 @@ static void log_frames_after_thaw(JavaThread* thread, ContinuationWrapper& cont,
   if (LoomVerifyAfterThaw) {
     assert(do_verify_after_thaw(thread, cont.tail(), tty), "");
   }
-  assert(ContinuationEntry::assert_entry_frame_laid_out(thread, preempted), "");
+  assert(preempted || ContinuationEntry::assert_entry_frame_laid_out(thread), "");
   clear_anchor(thread);
 
   LogTarget(Trace, continuations) lt;

src/hotspot/share/runtime/javaCalls.cpp

@@ -243,7 +243,7 @@ void JavaCalls::call_special(JavaValue* result, Handle receiver, Klass* klass, S
 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) {
   CallInfo callinfo;
   LinkInfo link_info(klass, name, signature);
-  LinkResolver::resolve_static_call(callinfo, link_info, StaticMode::initialize_klass, CHECK);
+  LinkResolver::resolve_static_call(callinfo, link_info, ClassInitMode::init, CHECK);
   methodHandle method(THREAD, callinfo.selected_method());
   assert(method.not_null(), "should have thrown exception");