Merge

Author: AlanBateman

make/data/hotspot-symbols/symbols-unix

@@ -193,8 +193,8 @@ JVM_RegisterSignal
 JVM_ReleaseUTF
 JVM_ReportFinalizationComplete
 JVM_ResumeThread
-JVM_ScopeLocalCache
-JVM_SetScopeLocalCache
+JVM_ExtentLocalCache
+JVM_SetExtentLocalCache
 JVM_SetArrayElement
 JVM_SetClassSigners
 JVM_SetNativeThreadName

src/hotspot/share/c1/c1_Compiler.cpp

@@ -154,7 +154,7 @@ bool Compiler::is_intrinsic_supported(const methodHandle& method) {
   case vmIntrinsics::_getModifiers:
   case vmIntrinsics::_currentCarrierThread:
   case vmIntrinsics::_currentThread:
-  case vmIntrinsics::_scopeLocalCache:
+  case vmIntrinsics::_extentLocalCache:
   case vmIntrinsics::_dabs:
   case vmIntrinsics::_dsqrt:
   case vmIntrinsics::_dsqrt_strict:

src/hotspot/share/c1/c1_LIRGenerator.cpp

@@ -1417,8 +1417,8 @@ void LIRGenerator::do_getObjectSize(Intrinsic* x) {
   __ branch_destination(L_done->label());
 }
 
-void LIRGenerator::do_scopeLocalCache(Intrinsic* x) {
-  do_JavaThreadField(x, JavaThread::scopeLocalCache_offset());
+void LIRGenerator::do_extentLocalCache(Intrinsic* x) {
+  do_JavaThreadField(x, JavaThread::extentLocalCache_offset());
 }
 
 // Example: Thread.currentCarrierThread()
@@ -2960,7 +2960,7 @@ void LIRGenerator::do_Intrinsic(Intrinsic* x) {
   case vmIntrinsics::_getObjectSize:  do_getObjectSize(x); break;
   case vmIntrinsics::_currentCarrierThread: do_currentCarrierThread(x); break;
   case vmIntrinsics::_currentThread:  do_vthread(x);       break;
-  case vmIntrinsics::_scopeLocalCache: do_scopeLocalCache(x); break;
+  case vmIntrinsics::_extentLocalCache: do_extentLocalCache(x); break;
 
   case vmIntrinsics::_dlog:           // fall through
   case vmIntrinsics::_dlog10:         // fall through

src/hotspot/share/c1/c1_LIRGenerator.hpp

@@ -257,7 +257,7 @@ class LIRGenerator: public InstructionVisitor, public BlockClosure {
   void do_getClass(Intrinsic* x);
   void do_getObjectSize(Intrinsic* x);
   void do_currentCarrierThread(Intrinsic* x);
-  void do_scopeLocalCache(Intrinsic* x);
+  void do_extentLocalCache(Intrinsic* x);
   void do_vthread(Intrinsic* x);
   void do_JavaThreadField(Intrinsic* x, ByteSize offset);
   void do_FmaIntrinsic(Intrinsic* x);

src/hotspot/share/classfile/javaClasses.cpp

@@ -1789,7 +1789,7 @@ int java_lang_Thread::_interrupted_offset;
 int java_lang_Thread::_tid_offset;
 int java_lang_Thread::_continuation_offset;
 int java_lang_Thread::_park_blocker_offset;
-int java_lang_Thread::_scopeLocalBindings_offset;
+int java_lang_Thread::_extentLocalBindings_offset;
 JFR_ONLY(int java_lang_Thread::_jfr_epoch_offset;)
 
 #define THREAD_FIELDS_DO(macro) \
@@ -1802,7 +1802,7 @@ JFR_ONLY(int java_lang_Thread::_jfr_epoch_offset;)
   macro(_tid_offset,           k, "tid", long_signature, false); \
   macro(_park_blocker_offset,  k, "parkBlocker", object_signature, false); \
   macro(_continuation_offset,  k, "cont", continuation_signature, false); \
-  macro(_scopeLocalBindings_offset, k, "scopeLocalBindings", object_signature, false);
+  macro(_extentLocalBindings_offset, k, "extentLocalBindings", object_signature, false);
 
 void java_lang_Thread::compute_offsets() {
   assert(_holder_offset == 0, "offsets should be initialized only once");
@@ -1835,8 +1835,8 @@ void java_lang_Thread::set_jvmti_thread_state(oop java_thread, JvmtiThreadState*
   java_thread->address_field_put(_jvmti_thread_state_offset, (address)state);
 }
 
-void java_lang_Thread::clear_scopeLocalBindings(oop java_thread) {
-  java_thread->obj_field_put(_scopeLocalBindings_offset, NULL);
+void java_lang_Thread::clear_extentLocalBindings(oop java_thread) {
+  java_thread->obj_field_put(_extentLocalBindings_offset, NULL);
 }
 
 oop java_lang_Thread::holder(oop java_thread) {
@@ -4879,7 +4879,7 @@ class UnsafeConstantsFixup : public FieldClosure {
     } else if (fd->name() == vmSymbols::data_cache_line_flush_size_name()) {
       mirror->int_field_put(fd->offset(), _data_cache_line_flush_size);
     } else if (fd->name() == vmSymbols::scoped_cache_shift_name()) {
-      mirror->int_field_put(fd->offset(), ScopeLocalCacheSize ? exact_log2(ScopeLocalCacheSize) : -1);
+      mirror->int_field_put(fd->offset(), ExtentLocalCacheSize ? exact_log2(ExtentLocalCacheSize) : -1);
     } else {
       assert(false, "unexpected UnsafeConstants field");
     }

src/hotspot/share/classfile/javaClasses.hpp

@@ -418,7 +418,7 @@ class java_lang_Thread : AllStatic {
   static int _tid_offset;
   static int _continuation_offset;
   static int _park_blocker_offset;
-  static int _scopeLocalBindings_offset;
+  static int _extentLocalBindings_offset;
   JFR_ONLY(static int _jfr_epoch_offset;)
 
   static void compute_offsets();
@@ -467,8 +467,8 @@ class java_lang_Thread : AllStatic {
   static JvmtiThreadState* jvmti_thread_state(oop java_thread);
   static void set_jvmti_thread_state(oop java_thread, JvmtiThreadState* state);
 
-  // Clear all scope local bindings on error
-  static void clear_scopeLocalBindings(oop java_thread);
+  // Clear all extent local bindings on error
+  static void clear_extentLocalBindings(oop java_thread);
 
   // Blocker object responsible for thread parking
   static oop park_blocker(oop java_thread);

src/hotspot/share/classfile/vmIntrinsics.cpp

@@ -77,7 +77,7 @@ bool vmIntrinsics::preserves_state(vmIntrinsics::ID id) {
   case vmIntrinsics::_isInstance:
   case vmIntrinsics::_currentCarrierThread:
   case vmIntrinsics::_currentThread:
-  case vmIntrinsics::_scopeLocalCache:
+  case vmIntrinsics::_extentLocalCache:
   case vmIntrinsics::_dabs:
   case vmIntrinsics::_fabs:
   case vmIntrinsics::_iabs:
@@ -127,8 +127,8 @@ bool vmIntrinsics::can_trap(vmIntrinsics::ID id) {
   case vmIntrinsics::_currentCarrierThread:
   case vmIntrinsics::_currentThread:
   case vmIntrinsics::_setCurrentThread:
-  case vmIntrinsics::_scopeLocalCache:
-  case vmIntrinsics::_setScopeLocalCache:
+  case vmIntrinsics::_extentLocalCache:
+  case vmIntrinsics::_setExtentLocalCache:
   case vmIntrinsics::_dabs:
   case vmIntrinsics::_fabs:
   case vmIntrinsics::_iabs:
@@ -264,8 +264,8 @@ bool vmIntrinsics::disabled_by_jvm_flags(vmIntrinsics::ID id) {
     if (!InlineThreadNatives) return true;
     break;
   case vmIntrinsics::_setCurrentThread:
-  case vmIntrinsics::_scopeLocalCache:
-  case vmIntrinsics::_setScopeLocalCache:
+  case vmIntrinsics::_extentLocalCache:
+  case vmIntrinsics::_setExtentLocalCache:
   case vmIntrinsics::_floatToRawIntBits:
   case vmIntrinsics::_intBitsToFloat:
   case vmIntrinsics::_doubleToRawLongBits:

src/hotspot/share/classfile/vmIntrinsics.hpp

@@ -259,12 +259,12 @@ class methodHandle;
   do_intrinsic(_currentThread,            java_lang_Thread,       currentThread_name, currentThread_signature,   F_SN)  \
    do_name(     currentThread_name,                              "currentThread")                                       \
    do_signature(currentThread_signature,                         "()Ljava/lang/Thread;")                                \
-  do_intrinsic(_scopeLocalCache,          java_lang_Thread,       scopeLocalCache_name, scopeLocalCache_signature, F_SN) \
-   do_name(     scopeLocalCache_name,                            "scopeLocalCache")                                     \
-   do_signature(scopeLocalCache_signature,                       "()[Ljava/lang/Object;")                               \
-  do_intrinsic(_setScopeLocalCache,       java_lang_Thread,       setScopeLocalCache_name, setScopeLocalCache_signature, F_SN) \
-   do_name(     setScopeLocalCache_name,                         "setScopeLocalCache")                                  \
-   do_signature(setScopeLocalCache_signature,                    "([Ljava/lang/Object;)V")                              \
+  do_intrinsic(_extentLocalCache,          java_lang_Thread,       extentLocalCache_name, extentLocalCache_signature, F_SN) \
+   do_name(     extentLocalCache_name,                            "extentLocalCache")                                     \
+   do_signature(extentLocalCache_signature,                       "()[Ljava/lang/Object;")                               \
+  do_intrinsic(_setExtentLocalCache,       java_lang_Thread,       setExtentLocalCache_name, setExtentLocalCache_signature, F_SN) \
+   do_name(     setExtentLocalCache_name,                         "setExtentLocalCache")                                  \
+   do_signature(setExtentLocalCache_signature,                    "([Ljava/lang/Object;)V")                              \
   do_intrinsic(_setCurrentThread,         java_lang_Thread,       setCurrentThread_name, thread_void_signature,   F_RN) \
    do_name(     setCurrentThread_name,                           "setCurrentThread")                                    \
                                                                                                                         \

src/hotspot/share/include/jvm.h

@@ -316,10 +316,10 @@ JNIEXPORT jobjectArray JNICALL
 JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads);
 
 JNIEXPORT jobject JNICALL
-JVM_ScopeLocalCache(JNIEnv *env, jclass threadClass);
+JVM_ExtentLocalCache(JNIEnv *env, jclass threadClass);
 
 JNIEXPORT void JNICALL
-JVM_SetScopeLocalCache(JNIEnv *env, jclass threadClass, jobject theCache);
+JVM_SetExtentLocalCache(JNIEnv *env, jclass threadClass, jobject theCache);
 
 JNIEXPORT jlong JNICALL
 JVM_GetNextThreadIdOffset(JNIEnv *env, jclass threadClass);

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

@@ -1514,12 +1514,12 @@ C2V_VMENTRY(void, materializeVirtualObjects, (JNIEnv* env, jobject, jobject _hs_
   for (int frame_index = 0; frame_index < virtualFrames->length(); frame_index++) {
     compiledVFrame* cvf = virtualFrames->at(frame_index);
 
-    GrowableArray<ScopeValue*>* scopeLocals = cvf->scope()->locals();
+    GrowableArray<ScopeValue*>* extentLocals = cvf->scope()->locals();
     StackValueCollection* locals = cvf->locals();
     if (locals != NULL) {
       for (int i2 = 0; i2 < locals->size(); i2++) {
         StackValue* var = locals->at(i2);
-        if (var->type() == T_OBJECT && scopeLocals->at(i2)->is_object()) {
+        if (var->type() == T_OBJECT && extentLocals->at(i2)->is_object()) {
           jvalue val;
           val.l = cast_from_oop<jobject>(locals->at(i2)->get_obj()());
           cvf->update_local(T_OBJECT, i2, val);

src/hotspot/share/opto/c2compiler.cpp

@@ -641,8 +641,8 @@ bool C2Compiler::is_intrinsic_supported(const methodHandle& method, bool is_virt
   case vmIntrinsics::_currentCarrierThread:
   case vmIntrinsics::_currentThread:
   case vmIntrinsics::_setCurrentThread:
-  case vmIntrinsics::_scopeLocalCache:
-  case vmIntrinsics::_setScopeLocalCache:
+  case vmIntrinsics::_extentLocalCache:
+  case vmIntrinsics::_setExtentLocalCache:
 #ifdef JFR_HAVE_INTRINSICS
   case vmIntrinsics::_counterTime:
   case vmIntrinsics::_getEventWriter:

src/hotspot/share/opto/library_call.cpp

@@ -472,8 +472,8 @@ bool LibraryCallKit::try_to_inline(int predicate) {
   case vmIntrinsics::_currentThread:            return inline_native_currentThread();
   case vmIntrinsics::_setCurrentThread:         return inline_native_setCurrentThread();
 
-  case vmIntrinsics::_scopeLocalCache:          return inline_native_scopeLocalCache();
-  case vmIntrinsics::_setScopeLocalCache:       return inline_native_setScopeLocalCache();
+  case vmIntrinsics::_extentLocalCache:          return inline_native_extentLocalCache();
+  case vmIntrinsics::_setExtentLocalCache:       return inline_native_setExtentLocalCache();
 
 #ifdef JFR_HAVE_INTRINSICS
   case vmIntrinsics::_counterTime:              return inline_native_time_funcs(CAST_FROM_FN_PTR(address, JfrTime::time_function()), "counterTime");
@@ -3461,38 +3461,38 @@ bool LibraryCallKit::inline_native_setCurrentThread() {
   return true;
 }
 
-Node* LibraryCallKit::scopeLocalCache_helper() {
+Node* LibraryCallKit::extentLocalCache_helper() {
   ciKlass *objects_klass = ciObjArrayKlass::make(env()->Object_klass());
   const TypeOopPtr *etype = TypeOopPtr::make_from_klass(env()->Object_klass());
 
   bool xk = etype->klass_is_exact();
 
   Node* thread = _gvn.transform(new ThreadLocalNode());
-  Node* p = basic_plus_adr(top()/*!oop*/, thread, in_bytes(JavaThread::scopeLocalCache_offset()));
+  Node* p = basic_plus_adr(top()/*!oop*/, thread, in_bytes(JavaThread::extentLocalCache_offset()));
   return _gvn.transform(LoadNode::make(_gvn, NULL, immutable_memory(), p, p->bottom_type()->is_ptr(),
         TypeRawPtr::NOTNULL, T_ADDRESS, MemNode::unordered));
 }
 
-//------------------------inline_native_scopeLocalCache------------------
-bool LibraryCallKit::inline_native_scopeLocalCache() {
+//------------------------inline_native_extentLocalCache------------------
+bool LibraryCallKit::inline_native_extentLocalCache() {
   ciKlass *objects_klass = ciObjArrayKlass::make(env()->Object_klass());
   const TypeOopPtr *etype = TypeOopPtr::make_from_klass(env()->Object_klass());
   const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS);
 
-  // Because we create the scopeLocal cache lazily we have to make the
+  // Because we create the extentLocal cache lazily we have to make the
   // type of the result BotPTR.
   bool xk = etype->klass_is_exact();
   const Type* objects_type = TypeAryPtr::make(TypePtr::BotPTR, arr0, objects_klass, xk, 0);
-  Node* cache_obj_handle = scopeLocalCache_helper();
+  Node* cache_obj_handle = extentLocalCache_helper();
   set_result(access_load(cache_obj_handle, objects_type, T_OBJECT, IN_NATIVE));
 
   return true;
 }
 
-//------------------------inline_native_setScopeLocalCache------------------
-bool LibraryCallKit::inline_native_setScopeLocalCache() {
+//------------------------inline_native_setExtentLocalCache------------------
+bool LibraryCallKit::inline_native_setExtentLocalCache() {
   Node* arr = argument(0);
-  Node* cache_obj_handle = scopeLocalCache_helper();
+  Node* cache_obj_handle = extentLocalCache_helper();
 
   const TypePtr *adr_type = _gvn.type(cache_obj_handle)->isa_ptr();
   store_to_memory(control(), cache_obj_handle, arr, T_OBJECT, adr_type,

src/hotspot/share/opto/library_call.hpp

@@ -239,9 +239,9 @@ class LibraryCallKit : public GraphKit {
   bool inline_native_currentThread();
   bool inline_native_setCurrentThread();
 
-  bool inline_native_scopeLocalCache();
-  Node* scopeLocalCache_helper();
-  bool inline_native_setScopeLocalCache();
+  bool inline_native_extentLocalCache();
+  Node* extentLocalCache_helper();
+  bool inline_native_setExtentLocalCache();
 
   bool inline_native_time_funcs(address method, const char* funcName);
 #ifdef JFR_HAVE_INTRINSICS

src/hotspot/share/opto/memnode.cpp

@@ -858,7 +858,7 @@ bool LoadNode::is_immutable_value(Node* adr) {
       in_bytes(JavaThread::osthread_offset()),
       in_bytes(JavaThread::threadObj_offset()),
       in_bytes(JavaThread::vthread_offset()),
-      in_bytes(JavaThread::scopeLocalCache_offset()),
+      in_bytes(JavaThread::extentLocalCache_offset()),
     };
 
     for (size_t i = 0; i < sizeof offsets / sizeof offsets[0]; i++) {

src/hotspot/share/prims/jvm.cpp

@@ -3179,22 +3179,22 @@ JVM_ENTRY(void, JVM_SetNativeThreadName(JNIEnv* env, jobject jthread, jstring na
   }
 JVM_END
 
-JVM_ENTRY(jobject, JVM_ScopeLocalCache(JNIEnv* env, jclass threadClass))
-  oop theCache = thread->scopeLocalCache();
+JVM_ENTRY(jobject, JVM_ExtentLocalCache(JNIEnv* env, jclass threadClass))
+  oop theCache = thread->extentLocalCache();
   if (theCache) {
     arrayOop objs = arrayOop(theCache);
-    assert(objs->length() == ScopeLocalCacheSize * 2, "wrong length");
+    assert(objs->length() == ExtentLocalCacheSize * 2, "wrong length");
   }
   return JNIHandles::make_local(THREAD, theCache);
 JVM_END
 
-JVM_ENTRY(void, JVM_SetScopeLocalCache(JNIEnv* env, jclass threadClass,
+JVM_ENTRY(void, JVM_SetExtentLocalCache(JNIEnv* env, jclass threadClass,
                                        jobject theCache))
   arrayOop objs = arrayOop(JNIHandles::resolve(theCache));
   if (objs != NULL) {
-    assert(objs->length() == ScopeLocalCacheSize * 2, "wrong length");
+    assert(objs->length() == ExtentLocalCacheSize * 2, "wrong length");
   }
-  thread->set_scopeLocalCache(objs);
+  thread->set_extentLocalCache(objs);
 JVM_END
 
 // java.lang.SecurityManager ///////////////////////////////////////////////////////////////////////

src/hotspot/share/runtime/deoptimization.cpp

@@ -443,11 +443,11 @@ Deoptimization::UnrollBlock* Deoptimization::fetch_unroll_info_helper(JavaThread
   vframeArray* array = create_vframeArray(current, deoptee, &map, chunk, realloc_failures);
 #if COMPILER2_OR_JVMCI
   if (realloc_failures) {
-    // FIXME: This very crudely destroys all ScopeLocal bindings. This
+    // FIXME: This very crudely destroys all ExtentLocal bindings. This
     // is better than a bound value escaping, but far from ideal.
     oop java_thread = current->threadObj();
-    current->set_scopeLocalCache(NULL);
-    java_lang_Thread::clear_scopeLocalBindings(java_thread);
+    current->set_extentLocalCache(NULL);
+    java_lang_Thread::clear_extentLocalBindings(java_thread);
     pop_frames_failed_reallocs(current, array);
   }
 #endif

src/hotspot/share/runtime/flags/jvmFlagConstraintsRuntime.cpp

@@ -92,10 +92,10 @@ JVMFlag::Error VMPageSizeConstraintFunc(uintx value, bool verbose) {
   return JVMFlag::SUCCESS;
 }
 
-JVMFlag::Error ScopeLocalCacheSizeConstraintFunc(intx value, bool verbose) {
+JVMFlag::Error ExtentLocalCacheSizeConstraintFunc(intx value, bool verbose) {
   if (!is_power_of_2(value)) {
     JVMFlag::printError(verbose,
-                        "ScopeLocalCacheSize (" INTX_FORMAT ") must be "
+                        "ExtentLocalCacheSize (" INTX_FORMAT ") must be "
                         "power of 2\n",
                         value);
     return JVMFlag::VIOLATES_CONSTRAINT;

src/hotspot/share/runtime/flags/jvmFlagConstraintsRuntime.hpp

@@ -37,7 +37,7 @@
   f(intx,   ObjectAlignmentInBytesConstraintFunc)     \
   f(intx,   ContendedPaddingWidthConstraintFunc)      \
   f(intx,   PerfDataSamplingIntervalFunc)             \
-  f(intx,   ScopeLocalCacheSizeConstraintFunc)        \
+  f(intx,   ExtentLocalCacheSizeConstraintFunc)        \
   f(uintx,  VMPageSizeConstraintFunc)                 \
   f(size_t, NUMAInterleaveGranularityConstraintFunc)
 

src/hotspot/share/runtime/globals.hpp

@@ -2013,10 +2013,10 @@ const intx ObjectAlignmentInBytes = 8;
   develop(bool, UseContinuationFastPath, true,                              \
           "Use fast-path frame walking in continuations")                   \
                                                                             \
-  product(intx, ScopeLocalCacheSize, 16,                                    \
+  product(intx, ExtentLocalCacheSize, 16,                                    \
           "Size of the cache for scoped values")                            \
            range(0, max_intx)                                               \
-           constraint(ScopeLocalCacheSizeConstraintFunc, AtParse)           \
+           constraint(ExtentLocalCacheSizeConstraintFunc, AtParse)           \
                                                                             \
   develop(int, VerifyMetaspaceInterval, DEBUG_ONLY(500) NOT_DEBUG(0),       \
                "Run periodic metaspace verifications (0 - none, "           \

src/hotspot/share/runtime/sharedRuntime.cpp

@@ -805,9 +805,9 @@ void SharedRuntime::throw_StackOverflowError_common(JavaThread* current, bool de
   if (StackTraceInThrowable) {
     java_lang_Throwable::fill_in_stack_trace(exception);
   }
-  // Remove the ScopeLocal cache in case we got a StackOverflowError
-  // while we were trying to remove ScopeLocal bindings.
-  current->set_scopeLocalCache(NULL);
+  // Remove the ExtentLocal cache in case we got a StackOverflowError
+  // while we were trying to remove ExtentLocal bindings.
+  current->set_extentLocalCache(NULL);
   // Increment counter for hs_err file reporting
   Atomic::inc(&Exceptions::_stack_overflow_errors);
   throw_and_post_jvmti_exception(current, exception);

src/hotspot/share/runtime/thread.cpp

@@ -789,7 +789,7 @@ void JavaThread::set_threadOopHandles(oop p) {
   _threadObj   = OopHandle(_thread_oop_storage, p);
   _vthread     = OopHandle(_thread_oop_storage, p);
   _jvmti_vthread = OopHandle(_thread_oop_storage, NULL);
-  _scopeLocalCache = OopHandle(_thread_oop_storage, NULL);
+  _extentLocalCache = OopHandle(_thread_oop_storage, NULL);
 }
 
 oop JavaThread::threadObj() const {
@@ -814,13 +814,13 @@ void JavaThread::set_jvmti_vthread(oop p) {
   _jvmti_vthread.replace(p);
 }
 
-oop JavaThread::scopeLocalCache() const {
-  return _scopeLocalCache.resolve();
+oop JavaThread::extentLocalCache() const {
+  return _extentLocalCache.resolve();
 }
 
-void JavaThread::set_scopeLocalCache(oop p) {
+void JavaThread::set_extentLocalCache(oop p) {
   assert(_thread_oop_storage != NULL, "not yet initialized");
-  _scopeLocalCache.replace(p);
+  _extentLocalCache.replace(p);
 }
 
 void JavaThread::allocate_threadObj(Handle thread_group, const char* thread_name,
@@ -1676,11 +1676,11 @@ void JavaThread::handle_async_exception(oop java_throwable) {
     // We cannot call Exceptions::_throw(...) here because we cannot block
     set_pending_exception(java_throwable, __FILE__, __LINE__);
 
-    // Clear any scope-local bindings on ThreadDeath
-    set_scopeLocalCache(NULL);
+    // Clear any extent-local bindings on ThreadDeath
+    set_extentLocalCache(NULL);
     oop threadOop = threadObj();
     assert(threadOop != NULL, "must be");
-    java_lang_Thread::clear_scopeLocalBindings(threadOop);
+    java_lang_Thread::clear_extentLocalBindings(threadOop);
 
     LogTarget(Info, exceptions) lt;
     if (lt.is_enabled()) {

src/hotspot/share/runtime/thread.hpp

@@ -705,7 +705,7 @@ class JavaThread: public Thread {
   OopHandle      _threadObj;                     // The Java level thread object
   OopHandle      _vthread; // the value returned by Thread.currentThread(): the virtual thread, if mounted, otherwise _threadObj
   OopHandle      _jvmti_vthread;
-  OopHandle      _scopeLocalCache;
+  OopHandle      _extentLocalCache;
 
 #ifdef ASSERT
  private:
@@ -1063,9 +1063,9 @@ class JavaThread: public Thread {
   inline StackWatermarks* stack_watermarks() { return &_stack_watermarks; }
 
  public:
-  jlong _scopeLocal_hash_table_shift;
+  jlong _extentLocal_hash_table_shift;
 
-  void allocate_scopeLocal_hash_table(int count);
+  void allocate_extentLocal_hash_table(int count);
 
  public:
   // Constructor
@@ -1119,8 +1119,8 @@ class JavaThread: public Thread {
   void set_threadOopHandles(oop p);
   oop vthread() const;
   void set_vthread(oop p);
-  oop scopeLocalCache() const;
-  void set_scopeLocalCache(oop p);
+  oop extentLocalCache() const;
+  void set_extentLocalCache(oop p);
   oop jvmti_vthread() const;
   void set_jvmti_vthread(oop p);
 
@@ -1339,7 +1339,7 @@ class JavaThread: public Thread {
   void clr_do_not_unlock(void)                   { _do_not_unlock_if_synchronized = false; }
   bool do_not_unlock(void)                       { return _do_not_unlock_if_synchronized; }
 
-  static ByteSize scopeLocalCache_offset()       { return byte_offset_of(JavaThread, _scopeLocalCache); }
+  static ByteSize extentLocalCache_offset()       { return byte_offset_of(JavaThread, _extentLocalCache); }
 
   // For assembly stub generation
   static ByteSize threadObj_offset()             { return byte_offset_of(JavaThread, _threadObj); }

src/hotspot/share/runtime/vframe_hp.cpp

@@ -145,12 +145,12 @@ void compiledVFrame::update_deferred_value(BasicType type, int index, jvalue val
 // original update is kept.
 void compiledVFrame::create_deferred_updates_after_object_deoptimization() {
   // locals
-  GrowableArray<ScopeValue*>* scopeLocals = scope()->locals();
+  GrowableArray<ScopeValue*>* extentLocals = scope()->locals();
   StackValueCollection* lcls = locals();
   if (lcls != NULL) {
     for (int i2 = 0; i2 < lcls->size(); i2++) {
       StackValue* var = lcls->at(i2);
-      if (var->type() == T_OBJECT && scopeLocals->at(i2)->is_object()) {
+      if (var->type() == T_OBJECT && extentLocals->at(i2)->is_object()) {
         jvalue val;
         val.l = cast_from_oop<jobject>(lcls->at(i2)->get_obj()());
         update_local(T_OBJECT, i2, val);

src/hotspot/share/runtime/vmStructs.cpp

@@ -714,7 +714,7 @@
   nonstatic_field(JavaThread,                  _threadObj,                                    OopHandle)                             \
   nonstatic_field(JavaThread,                  _vthread,                                      OopHandle)                             \
   nonstatic_field(JavaThread,                  _jvmti_vthread,                                OopHandle)                             \
-  nonstatic_field(JavaThread,                  _scopeLocalCache,                              OopHandle)                             \
+  nonstatic_field(JavaThread,                  _extentLocalCache,                              OopHandle)                             \
   nonstatic_field(JavaThread,                  _anchor,                                       JavaFrameAnchor)                       \
   nonstatic_field(JavaThread,                  _vm_result,                                    oop)                                   \
   nonstatic_field(JavaThread,                  _vm_result_2,                                  Metadata*)                             \

src/java.base/share/classes/java/lang/System.java

@@ -2541,20 +2541,20 @@ public <T> void setCarrierThreadLocal(ThreadLocal<T> local, T value) {
                 local.setCarrierThreadLocal(value);
             }
 
-            public Object[] scopeLocalCache() {
-                return Thread.scopeLocalCache();
+            public Object[] extentLocalCache() {
+                return Thread.extentLocalCache();
             }
 
-            public void setScopeLocalCache(Object[] cache) {
-                Thread.setScopeLocalCache(cache);
+            public void setExtentLocalCache(Object[] cache) {
+                Thread.setExtentLocalCache(cache);
             }
 
-            public Object scopeLocalBindings() {
-                return Thread.scopeLocalBindings();
+            public Object extentLocalBindings() {
+                return Thread.extentLocalBindings();
             }
 
-            public void setScopeLocalBindings(Object bindings) {
-                Thread.setScopeLocalBindings(bindings);
+            public void setExtentLocalBindings(Object bindings) {
+                Thread.setExtentLocalBindings(bindings);
             }
 
             public Continuation getContinuation(Thread thread) {

src/java.base/share/classes/java/lang/Thread.java

@@ -45,7 +45,7 @@
 import jdk.internal.reflect.CallerSensitive;
 import jdk.internal.reflect.Reflection;
 import jdk.internal.vm.Continuation;
-import jdk.internal.vm.ScopeLocalContainer;
+import jdk.internal.vm.ExtentLocalContainer;
 import jdk.internal.vm.StackableScope;
 import jdk.internal.vm.ThreadContainer;
 import jdk.internal.vm.annotation.IntrinsicCandidate;
@@ -244,34 +244,34 @@ private static class FieldHolder {
     ThreadLocal.ThreadLocalMap inheritableThreadLocals;
 
     /*
-     * Scope locals binding are maintained by the ScopeLocal class.
+     * Scope locals binding are maintained by the ExtentLocal class.
      */
-    private Object scopeLocalBindings;
+    private Object extentLocalBindings;
 
-    static Object scopeLocalBindings() {
-        return currentThread().scopeLocalBindings;
+    static Object extentLocalBindings() {
+        return currentThread().extentLocalBindings;
     }
 
-    static void setScopeLocalBindings(Object bindings) {
-        currentThread().scopeLocalBindings = bindings;
+    static void setExtentLocalBindings(Object bindings) {
+        currentThread().extentLocalBindings = bindings;
     }
 
     /**
-     * Inherit the scope-local bindings from the given container.
+     * Inherit the extent-local bindings from the given container.
      * Invoked when starting a thread.
      */
-    void inheritScopeLocalBindings(ThreadContainer container) {
-        ScopeLocalContainer.BindingsSnapshot snapshot;
+    void inheritExtentLocalBindings(ThreadContainer container) {
+        ExtentLocalContainer.BindingsSnapshot snapshot;
         if (container.owner() != null
-                && (snapshot = container.scopeLocalBindings()) != null) {
+                && (snapshot = container.extentLocalBindings()) != null) {
 
             // bindings established for running/calling an operation
-            Object bindings = snapshot.scopeLocalBindings();
-            if (currentThread().scopeLocalBindings != bindings) {
+            Object bindings = snapshot.extentLocalBindings();
+            if (currentThread().extentLocalBindings != bindings) {
                 StructureViolationExceptions.throwException("Scope local bindings have changed");
             }
 
-            this.scopeLocalBindings = bindings;
+            this.extentLocalBindings = bindings;
         }
     }
 
@@ -358,13 +358,13 @@ void setContinuation(Continuation cont) {
     @IntrinsicCandidate
     native void setCurrentThread(Thread thread);
 
-    // ScopeLocal support:
+    // ExtentLocal support:
 
     @IntrinsicCandidate
-    static native Object[] scopeLocalCache();
+    static native Object[] extentLocalCache();
 
     @IntrinsicCandidate
-    static native void setScopeLocalCache(Object[] cache);
+    static native void setExtentLocalCache(Object[] cache);
 
     /**
      * A hint to the scheduler that the current thread is willing to yield
@@ -1517,8 +1517,8 @@ void start(ThreadContainer container) {
             boolean started = false;
             container.onStart(this);  // may throw
             try {
-                // scope locals may be inherited
-                inheritScopeLocalBindings(container);
+                // extent locals may be inherited
+                inheritExtentLocalBindings(container);
 
                 // bind thread to container
                 setThreadContainer(container);

src/java.base/share/classes/java/lang/VirtualThread.java

@@ -451,8 +451,8 @@ void start(ThreadContainer container) {
         boolean started = false;
         container.onStart(this); // may throw
         try {
-            // scope locals may be inherited
-            inheritScopeLocalBindings(container);
+            // extent locals may be inherited
+            inheritExtentLocalBindings(container);
 
             // bind thread to container
             setThreadContainer(container);

src/java.base/share/classes/java/util/concurrent/ThreadLocalRandom.java

@@ -305,7 +305,7 @@ static final void eraseThreadLocals(Thread thread) {
         // Ideally we should also clear the Thread's ScopedCache, but it is
         // in the VM-internal JavaThread structure. This method is called so
         // early in the lifetime of a ForkJoinPool thread that we don't expect
-        // any ScopeLocals to have yet been bound by this thread, so the
+        // any ExtentLocals to have yet been bound by this thread, so the
         // ScopedCache should be empty at this point.
         // U.putReference(thread, INHERITABLESCOPELOCALBINDINGS, null);
     }
@@ -407,7 +407,7 @@ private Object readResolve() {
         = new AtomicLong(RandomSupport.mixMurmur64(System.currentTimeMillis()) ^
                          RandomSupport.mixMurmur64(System.nanoTime()));
 
-    // used by ScopeLocal
+    // used by ExtentLocal
     private static class Access {
         static {
             SharedSecrets.setJavaUtilConcurrentTLRAccess(

src/java.base/share/classes/jdk/internal/access/JavaLangAccess.java

@@ -464,24 +464,24 @@ public interface JavaLangAccess {
     <T> void setCarrierThreadLocal(ThreadLocal<T> local, T value);
 
     /**
-     * Returns the current thread's scope locals cache
+     * Returns the current thread's extent locals cache
      */
-    Object[] scopeLocalCache();
+    Object[] extentLocalCache();
 
     /**
-     * Sets the current thread's scope locals cache
+     * Sets the current thread's extent locals cache
      */
-    void setScopeLocalCache(Object[] cache);
+    void setExtentLocalCache(Object[] cache);
 
     /**
-     * Return the current thread's scope local bindings.
+     * Return the current thread's extent local bindings.
      */
-    Object scopeLocalBindings();
+    Object extentLocalBindings();
 
     /**
-     * Set the current thread's scope local bindings.
+     * Set the current thread's extent local bindings.
      */
-    void setScopeLocalBindings(Object bindings);
+    void setExtentLocalBindings(Object bindings);
 
     /**
      * Returns the innermost mounted continuation

src/java.base/share/classes/jdk/internal/misc/ThreadFlock.java

@@ -35,7 +35,7 @@
 import java.util.stream.Stream;
 import jdk.internal.access.JavaLangAccess;
 import jdk.internal.access.SharedSecrets;
-import jdk.internal.vm.ScopeLocalContainer;
+import jdk.internal.vm.ExtentLocalContainer;
 import jdk.internal.vm.ThreadContainer;
 import jdk.internal.vm.ThreadContainers;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
@@ -99,7 +99,7 @@ public class ThreadFlock implements AutoCloseable {
     private volatile int threadCount;
 
     private final String name;
-    private final ScopeLocalContainer.BindingsSnapshot scopeLocalBindings;
+    private final ExtentLocalContainer.BindingsSnapshot extentLocalBindings;
     private final ThreadContainerImpl container; // encapsulate for now
 
     // state
@@ -111,16 +111,16 @@ public class ThreadFlock implements AutoCloseable {
 
     ThreadFlock(String name) {
         this.name = name;
-        this.scopeLocalBindings = ScopeLocalContainer.captureBindings();
+        this.extentLocalBindings = ExtentLocalContainer.captureBindings();
         this.container = new ThreadContainerImpl(this);
     }
 
     private long threadCount() {
         return threadCount;
     }
 
-    private ScopeLocalContainer.BindingsSnapshot scopeLocalBindings() {
-        return scopeLocalBindings;
+    private ExtentLocalContainer.BindingsSnapshot extentLocalBindings() {
+        return extentLocalBindings;
     }
 
     private void incrementThreadCount() {
@@ -210,7 +210,7 @@ private void ensureOwnerOrContainsThread() {
      * Opens a new thread flock. The flock is owned by the current thread. It can be
      * named to aid debugging.
      *
-     * <p> This method captures the current thread's {@linkplain ScopeLocal scope-local}
+     * <p> This method captures the current thread's {@linkplain ExtentLocal extent-local}
      * bindings for inheritance by threads created in the flock.
      *
      * <p> For the purposes of containment, monitoring, and debugging, the parent
@@ -250,7 +250,7 @@ public Thread owner() {
     /**
      * Starts the given unstarted thread in this flock.
      *
-     * <p> The thread is started with the scope-local bindings that were captured
+     * <p> The thread is started with the extent-local bindings that were captured
      * when opening the flock. The bindings must match the current thread's bindings.
      *
      * <p> This method may only be invoked by the flock owner or threads {@linkplain
@@ -263,7 +263,7 @@ public Thread owner() {
      * @throws WrongThreadException if the current thread is not the owner or a thread
      * contained in the flock
      * @throws jdk.incubator.concurrent.StructureViolationException if the current
-     * scope-local bindings are not the same as when the flock was created
+     * extent-local bindings are not the same as when the flock was created
      */
     public Thread start(Thread thread) {
         ensureOwnerOrContainsThread();
@@ -401,8 +401,8 @@ public void wakeup() {
      * closes this flock, and then throws {@link
      * jdk.incubator.concurrent.StructureViolationException}.
      * Similarly, if called to close a flock that <em>encloses</em> {@linkplain
-     * jdk.incubator.concurrent.ScopeLocal.Carrier#run(Runnable) operations} with
-     * scope-local bindings then it also throws {@code StructureViolationException}
+     * jdk.incubator.concurrent.ExtentLocal.Carrier#run(Runnable) operations} with
+     * extent-local bindings then it also throws {@code StructureViolationException}
      * after closing the flock.
      *
      * @throws WrongThreadException if invoked by a thread that is not the owner
@@ -588,8 +588,8 @@ public String toString() {
             return flock.toString();
         }
         @Override
-        public ScopeLocalContainer.BindingsSnapshot scopeLocalBindings() {
-            return flock.scopeLocalBindings();
+        public ExtentLocalContainer.BindingsSnapshot extentLocalBindings() {
+            return flock.extentLocalBindings();
         }
     }
 }

src/java.base/share/classes/jdk/internal/vm/Continuation.java

@@ -53,7 +53,7 @@ public class Continuation {
 
         StackChunk.init(); // ensure StackChunk class is initialized
 
-        String value = GetPropertyAction.privilegedGetProperty("jdk.preserveScopeLocalCache");
+        String value = GetPropertyAction.privilegedGetProperty("jdk.preserveExtentLocalCache");
         PRESERVE_SCOPE_LOCAL_CACHE = (value == null) || Boolean.parseBoolean(value);
     }
 
@@ -128,7 +128,7 @@ private static Thread currentCarrierThread() {
     private Object yieldInfo;
     private boolean preempted;
 
-    private Object[] scopeLocalCache;
+    private Object[] extentLocalCache;
 
     /**
      * Constructs a continuation
@@ -237,7 +237,7 @@ private void unmount() {
     public final void run() {
         while (true) {
             mount();
-            JLA.setScopeLocalCache(scopeLocalCache);
+            JLA.setExtentLocalCache(extentLocalCache);
 
             if (done)
                 throw new IllegalStateException("Continuation terminated");
@@ -270,11 +270,11 @@ public final void run() {
 
                     unmount();
                     if (PRESERVE_SCOPE_LOCAL_CACHE) {
-                        scopeLocalCache = JLA.scopeLocalCache();
+                        extentLocalCache = JLA.extentLocalCache();
                     } else {
-                        scopeLocalCache = null;
+                        extentLocalCache = null;
                     }
-                    JLA.setScopeLocalCache(null);
+                    JLA.setExtentLocalCache(null);
                 } catch (Throwable e) { e.printStackTrace(); System.exit(1); }
             }
             // we're now in the parent continuation

src/java.base/share/classes/jdk/internal/vm/ScopeLocalContainer.java src/java.base/share/classes/jdk/internal/vm/ExtentLocalContainer.java

@@ -33,26 +33,26 @@
 import jdk.internal.vm.annotation.ReservedStackAccess;
 
 /**
- * A StackableScope to represent scope-local bindings.
+ * A StackableScope to represent extent-local bindings.
  *
- * This class defines static methods to run an operation with a ScopeLocalContainer
- * on the scope stack. It also defines a method to get the latest ScopeLocalContainer
- * and a method to return a snapshot of the scope local bindings.
+ * This class defines static methods to run an operation with a ExtentLocalContainer
+ * on the scope stack. It also defines a method to get the latest ExtentLocalContainer
+ * and a method to return a snapshot of the extent local bindings.
  */
-public class ScopeLocalContainer extends StackableScope {
+public class ExtentLocalContainer extends StackableScope {
     private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
     static {
         Unsafe.getUnsafe().ensureClassInitialized(StructureViolationExceptions.class);
     }
 
-    private ScopeLocalContainer() {
+    private ExtentLocalContainer() {
     }
 
     /**
-     * Returns the "latest" ScopeLocalContainer for the current Thread. This may be on
+     * Returns the "latest" ExtentLocalContainer for the current Thread. This may be on
      * the current thread's scope task or ma require walking up the tree to find it.
      */
-    public static <T extends ScopeLocalContainer> T latest(Class<T> containerClass) {
+    public static <T extends ExtentLocalContainer> T latest(Class<T> containerClass) {
         StackableScope scope = head();
         if (scope == null) {
             scope = JLA.threadContainer(Thread.currentThread());
@@ -69,37 +69,37 @@ public static <T extends ScopeLocalContainer> T latest(Class<T> containerClass)
     }
 
     /**
-     * Returns the "latest" ScopeLocalContainer for the current Thread. This
+     * Returns the "latest" ExtentLocalContainer for the current Thread. This
      * may be on the current thread's scope task or may require walking up the
      * tree to find it.
      */
-    public static ScopeLocalContainer latest() {
-        return latest(ScopeLocalContainer.class);
+    public static ExtentLocalContainer latest() {
+        return latest(ExtentLocalContainer.class);
     }
 
     /**
-     * A snapshot of the scope local bindings. The snapshot includes the bindings
-     * established for the current thread and scope local container.
+     * A snapshot of the extent local bindings. The snapshot includes the bindings
+     * established for the current thread and extent local container.
      */
-    public record BindingsSnapshot(Object scopeLocalBindings,
-                                   ScopeLocalContainer container) { }
+    public record BindingsSnapshot(Object extentLocalBindings,
+                                   ExtentLocalContainer container) { }
 
     /**
-     * Returns a scope local bindings for the current thread.
+     * Returns a extent local bindings for the current thread.
      */
     public static BindingsSnapshot captureBindings() {
-        return new BindingsSnapshot(JLA.scopeLocalBindings(), latest());
+        return new BindingsSnapshot(JLA.extentLocalBindings(), latest());
     }
 
     /**
-     * For use by ScopeLocal to run an operation in a structured context.
+     * For use by ExtentLocal to run an operation in a structured context.
      */
     public static void run(Runnable op) {
         if (head() == null) {
             // no need to push scope when stack is empty
             runWithoutScope(op);
         } else {
-            new ScopeLocalContainer().doRun(op);
+            new ExtentLocalContainer().doRun(op);
         }
     }
 
@@ -141,14 +141,14 @@ private void doRun(Runnable op) {
     }
 
     /**
-     * For use by ScopeLocal to call a value returning operation in a structured context.
+     * For use by ExtentLocal to call a value returning operation in a structured context.
      */
     public static <V> V call(Callable<V> op) throws Exception {
         if (head() == null) {
             // no need to push scope when stack is empty
             return callWithoutScope(op);
         } else {
-            return new ScopeLocalContainer().doCall(op);
+            return new ExtentLocalContainer().doCall(op);
         }
     }
 

src/java.base/share/classes/jdk/internal/vm/ThreadContainer.java

@@ -90,9 +90,9 @@ public long threadCount() {
     public abstract void onExit(Thread thread);
 
     /**
-     * The scope locals captured when the thread container was created.
+     * The extent locals captured when the thread container was created.
      */
-    public ScopeLocalContainer.BindingsSnapshot scopeLocalBindings() {
+    public ExtentLocalContainer.BindingsSnapshot extentLocalBindings() {
         return null;
     }
 }

src/java.base/share/native/libjava/Thread.c

@@ -53,8 +53,8 @@ static JNINativeMethod methods[] = {
     {"dumpThreads",      "([" THD ")[[" STE, (void *)&JVM_DumpThreads},
     {"getStackTrace0",   "()" OBJ,     (void *)&JVM_GetStackTrace},
     {"setNativeName",    "(" STR ")V", (void *)&JVM_SetNativeThreadName},
-    {"scopeLocalCache",  "()[" OBJ,    (void *)&JVM_ScopeLocalCache},
-    {"setScopeLocalCache", "([" OBJ ")V",(void *)&JVM_SetScopeLocalCache},
+    {"extentLocalCache",  "()[" OBJ,    (void *)&JVM_ExtentLocalCache},
+    {"setExtentLocalCache", "([" OBJ ")V",(void *)&JVM_SetExtentLocalCache},
     {"getNextThreadIdOffset", "()J",     (void *)&JVM_GetNextThreadIdOffset}
 };
 

test/hotspot/jtreg/ProblemList-svc-vthread.txt

@@ -109,37 +109,37 @@ vmTestbase/nsk/jdi/ExceptionEvent/catchLocation/location002/TestDescription.java
 ## to support vthreads and expect the OPAQUE_FRAME error. The others were
 ## not because they don't add any additional value.
 
-vmTestbase/nsk/jdi/Scenarios/invokeMethod/popframes001/TestDescription.java
-vmTestbase/nsk/jdi/BScenarios/hotswap/tc01x002/TestDescription.java
-vmTestbase/nsk/jdi/BScenarios/hotswap/tc02x001/TestDescription.java
-vmTestbase/nsk/jdi/BScenarios/hotswap/tc02x002/TestDescription.java
-vmTestbase/nsk/jdi/BScenarios/hotswap/tc04x001/TestDescription.java
-vmTestbase/nsk/jdi/BScenarios/hotswap/tc04x002/TestDescription.java
-vmTestbase/nsk/jdi/BScenarios/hotswap/tc06x001/TestDescription.java
-vmTestbase/nsk/jdi/BScenarios/hotswap/tc08x001/TestDescription.java
-vmTestbase/nsk/jdi/BScenarios/hotswap/tc10x002/TestDescription.java
+vmTestbase/nsk/jdi/Scenarios/invokeMethod/popframes001/TestDescription.java 8285414 generic-all
+vmTestbase/nsk/jdi/BScenarios/hotswap/tc01x002/TestDescription.java 8285414 generic-all
+vmTestbase/nsk/jdi/BScenarios/hotswap/tc02x001/TestDescription.java 8285414 generic-all
+vmTestbase/nsk/jdi/BScenarios/hotswap/tc02x002/TestDescription.java 8285414 generic-all
+vmTestbase/nsk/jdi/BScenarios/hotswap/tc04x001/TestDescription.java 8285414 generic-all
+vmTestbase/nsk/jdi/BScenarios/hotswap/tc04x002/TestDescription.java 8285414 generic-all
+vmTestbase/nsk/jdi/BScenarios/hotswap/tc06x001/TestDescription.java 8285414 generic-all
+vmTestbase/nsk/jdi/BScenarios/hotswap/tc08x001/TestDescription.java 8285414 generic-all
+vmTestbase/nsk/jdi/BScenarios/hotswap/tc10x002/TestDescription.java 8285414 generic-all
 
-vmTestbase/nsk/jdi/ThreadReference/popFrames/popframes002/TestDescription.java
-vmTestbase/nsk/jdi/ThreadReference/popFrames/popframes003/TestDescription.java
-vmTestbase/nsk/jdi/ThreadReference/popFrames/popframes004/TestDescription.java
+vmTestbase/nsk/jdi/ThreadReference/popFrames/popframes002/TestDescription.java 8285414 generic-all
+vmTestbase/nsk/jdi/ThreadReference/popFrames/popframes003/TestDescription.java 8285414 generic-all
+vmTestbase/nsk/jdi/ThreadReference/popFrames/popframes004/TestDescription.java 8285414 generic-all
 
 ####
 ## JVMTI ForceEarlyReturn not supported for vthreads (JVMTI_ERROR_OPAQUE_FRAME)
 ## Note forceEarlyReturn002 was converted to support vthreads. The rest were not
 ## since there is no added value (JVMTI_ERROR_OPAQUE_FRAME is expected).
 
-vmTestbase/nsk/jdi/ThreadReference/forceEarlyReturn/forceEarlyReturn014/forceEarlyReturn014.java
-vmTestbase/nsk/jdi/stress/serial/forceEarlyReturn001/TestDescription.java
-vmTestbase/nsk/jdi/stress/serial/forceEarlyReturn002/TestDescription.java
+vmTestbase/nsk/jdi/ThreadReference/forceEarlyReturn/forceEarlyReturn014/forceEarlyReturn014.java 8285415 generic-all
+vmTestbase/nsk/jdi/stress/serial/forceEarlyReturn001/TestDescription.java 8285415 generic-all
+vmTestbase/nsk/jdi/stress/serial/forceEarlyReturn002/TestDescription.java 8285415 generic-all
 
 ###
-# These 2 tests try to create 10 vthreads and have them all block on a synchornized
+# These 2 tests try to create 10 vthreads and have them all block on a synchronized
 # method call, but on some hosts there are not enough carrier threads to support pinning
 # all 10 vthreads, so the test deadlocks. -Djdk.defaultScheduler.parallelism=<n>
 # could be used with the debuggee to ensure there are enough carrier threads.
 
-vmTestbase/nsk/jdi/EventRequestManager/stepRequests/stepreq002/TestDescription.java
-vmTestbase/nsk/jdi/EventRequestManager/deleteEventRequests/delevtreqs002/TestDescription.java
+vmTestbase/nsk/jdi/EventRequestManager/stepRequests/stepreq002/TestDescription.java 8285416 generic-all
+vmTestbase/nsk/jdi/EventRequestManager/deleteEventRequests/delevtreqs002/TestDescription.java 8285416 generic-all
 
 ###
 # These tests all create 5 virtual threads that block on a synchronized block, which causes
@@ -160,26 +160,26 @@ vmTestbase/nsk/jdi/ObjectReference/waitingThreads/waitingthreads002/TestDescript
 # debuggee, which has the side affect of making the Read-Poller thread exit. Because
 # of this no vthreads can complete their reads, and the test times out as a result.
 
-vmTestbase/nsk/jdi/VMOutOfMemoryException/VMOutOfMemoryException001/VMOutOfMemoryException001.java windows-all
+vmTestbase/nsk/jdi/VMOutOfMemoryException/VMOutOfMemoryException001/VMOutOfMemoryException001.java 8285417 windows-all
 
 ####
 ## NSK JMX Tests
 
 ####
 ## Unsupported functionality
 
-vmTestbase/nsk/monitoring/ThreadMXBean/GetThreadAllocatedBytes/baseBehaviorTest_server_default/TestDescription.java
-vmTestbase/nsk/monitoring/ThreadMXBean/GetThreadAllocatedBytes/baseBehaviorTest_server_custom/TestDescription.java
-vmTestbase/nsk/monitoring/ThreadMXBean/GetThreadAllocatedBytes/baseBehaviorTest_directly/TestDescription.java
-vmTestbase/nsk/monitoring/ThreadMXBean/GetThreadAllocatedBytes/baseBehaviorTest_proxy_custom/TestDescription.java
-vmTestbase/nsk/monitoring/ThreadMXBean/GetThreadAllocatedBytes/baseBehaviorTest_proxy_default/TestDescription.java
+vmTestbase/nsk/monitoring/ThreadMXBean/GetThreadAllocatedBytes/baseBehaviorTest_server_default/TestDescription.java 8285419 generic-all
+vmTestbase/nsk/monitoring/ThreadMXBean/GetThreadAllocatedBytes/baseBehaviorTest_server_custom/TestDescription.java 8285419 generic-all
+vmTestbase/nsk/monitoring/ThreadMXBean/GetThreadAllocatedBytes/baseBehaviorTest_directly/TestDescription.java 8285419 generic-all
+vmTestbase/nsk/monitoring/ThreadMXBean/GetThreadAllocatedBytes/baseBehaviorTest_proxy_custom/TestDescription.java 8285419 generic-all
+vmTestbase/nsk/monitoring/ThreadMXBean/GetThreadAllocatedBytes/baseBehaviorTest_proxy_default/TestDescription.java 8285419 generic-all
 
 
 ####
 ## No ThreadInfo for vthreads
 
-vmTestbase/nsk/monitoring/ThreadInfo/isInNative/isinnative001/TestDescription.java
-vmTestbase/nsk/monitoring/ThreadInfo/getLockOwnerName/getlockownername001/TestDescription.java
-vmTestbase/nsk/monitoring/ThreadInfo/getLockName/getlockname001/TestDescription.java
-vmTestbase/nsk/monitoring/ThreadInfo/from_c/from_c001/TestDescription.java
-vmTestbase/nsk/monitoring/MemoryUsage/from/from001/TestDescription.java
+vmTestbase/nsk/monitoring/ThreadInfo/isInNative/isinnative001/TestDescription.java 8285420 generic-all
+vmTestbase/nsk/monitoring/ThreadInfo/getLockOwnerName/getlockownername001/TestDescription.java 8285420 generic-all
+vmTestbase/nsk/monitoring/ThreadInfo/getLockName/getlockname001/TestDescription.java 8285420 generic-all
+vmTestbase/nsk/monitoring/ThreadInfo/from_c/from_c001/TestDescription.java 8285420 generic-all
+vmTestbase/nsk/monitoring/MemoryUsage/from/from001/TestDescription.java 8285420 generic-all

test/jdk/ProblemList-svc-vthread.txt

@@ -5,42 +5,42 @@ com/sun/jdi/EATests.java#id0                                    8264699 generic-
 ## Tests failing when main() is executed in additional vthread or in vthread instead of thread
 #
 
-com/sun/jdi/DeferredStepTest.java
-com/sun/jdi/EarlyReturnTest.java
-com/sun/jdi/ExceptionEvents.java
-com/sun/jdi/FetchLocals.java
-com/sun/jdi/Frames2Test.java
-com/sun/jdi/GetSetLocalTest.java
-com/sun/jdi/JdbMethodExitTest.java
-com/sun/jdi/JdbStepTest.java
-com/sun/jdi/JdbStopThreadTest.java
-com/sun/jdi/JdbStopThreadidTest.java
-com/sun/jdi/LaunchCommandLine.java
-com/sun/jdi/MethodEntryExitEvents.java
-com/sun/jdi/MultiBreakpointsTest.java
-com/sun/jdi/NativeInstanceFilter.java
-com/sun/jdi/PopAndStepTest.java
-com/sun/jdi/PopAsynchronousTest.java
-com/sun/jdi/PopSynchronousTest.java
-com/sun/jdi/RedefineCrossStart.java
-com/sun/jdi/RedefineG.java
-com/sun/jdi/RedefineNestmateAttr/TestNestmateAttr.java
-com/sun/jdi/RedefineTTYLineNumber.java
-com/sun/jdi/ReferrersTest.java
-com/sun/jdi/ResumeAfterThreadResumeCallTest.java
-com/sun/jdi/SetLocalWhileThreadInNative.java
-com/sun/jdi/StepTest.java
-com/sun/jdi/redefine/RedefineTest.java
-com/sun/jdi/redefineMethod/RedefineTest.java
+com/sun/jdi/DeferredStepTest.java 8285422 generic-all
+com/sun/jdi/EarlyReturnTest.java 8285422 generic-all
+com/sun/jdi/ExceptionEvents.java 8285422 generic-all
+com/sun/jdi/FetchLocals.java 8285422 generic-all
+com/sun/jdi/Frames2Test.java 8285422 generic-all
+com/sun/jdi/GetSetLocalTest.java 8285422 generic-all
+com/sun/jdi/JdbMethodExitTest.java 8285422 generic-all
+com/sun/jdi/JdbStepTest.java 8285422 generic-all
+com/sun/jdi/JdbStopThreadTest.java 8285422 generic-all
+com/sun/jdi/JdbStopThreadidTest.java 8285422 generic-all
+com/sun/jdi/LaunchCommandLine.java 8285422 generic-all
+com/sun/jdi/MethodEntryExitEvents.java 8285422 generic-all
+com/sun/jdi/MultiBreakpointsTest.java 8285422 generic-all
+com/sun/jdi/NativeInstanceFilter.java 8285422 generic-all
+com/sun/jdi/PopAndStepTest.java 8285422 generic-all
+com/sun/jdi/PopAsynchronousTest.java 8285422 generic-all
+com/sun/jdi/PopSynchronousTest.java 8285422 generic-all
+com/sun/jdi/RedefineCrossStart.java 8285422 generic-all
+com/sun/jdi/RedefineG.java 8285422 generic-all
+com/sun/jdi/RedefineNestmateAttr/TestNestmateAttr.java 8285422 generic-all
+com/sun/jdi/RedefineTTYLineNumber.java 8285422 generic-all
+com/sun/jdi/ReferrersTest.java 8285422 generic-all
+com/sun/jdi/ResumeAfterThreadResumeCallTest.java 8285422 generic-all
+com/sun/jdi/SetLocalWhileThreadInNative.java 8285422 generic-all
+com/sun/jdi/StepTest.java 8285422 generic-all
+com/sun/jdi/redefine/RedefineTest.java 8285422 generic-all
+com/sun/jdi/redefineMethod/RedefineTest.java 8285422 generic-all
 
 ####
 # JDI SDE Tests
 # Use custom classpath
 
-com/sun/jdi/sde/FilterMangleTest.java
-com/sun/jdi/sde/MangleTest.java
-com/sun/jdi/sde/MangleStepTest.java
-com/sun/jdi/sde/TemperatureTableTest.java
-com/sun/jdi/sde/SourceDebugExtensionTest.java
+com/sun/jdi/sde/FilterMangleTest.java 8285423 generic-all
+com/sun/jdi/sde/MangleTest.java 8285423 generic-all
+com/sun/jdi/sde/MangleStepTest.java 8285423 generic-all
+com/sun/jdi/sde/TemperatureTableTest.java 8285423 generic-all
+com/sun/jdi/sde/SourceDebugExtensionTest.java 8285423 generic-all
 
-com/sun/jdi/EATests.java#id0                                    8264699 generic-all
+com/sun/jdi/EATests.java#id0 8264699 generic-all