1 /*
   2  * Copyright (c) 1997, 2026, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "cds/aotClassInitializer.hpp"
  26 #include "cds/aotMetaspace.hpp"
  27 #include "cds/cdsConfig.hpp"
  28 #include "cds/classListParser.hpp"
  29 #include "cds/classListWriter.hpp"
  30 #include "cds/dynamicArchive.hpp"
  31 #include "cds/heapShared.hpp"
  32 #include "cds/lambdaFormInvokers.hpp"
  33 #include "cds/lambdaProxyClassDictionary.hpp"
  34 #include "classfile/classFileStream.hpp"
  35 #include "classfile/classLoader.inline.hpp"
  36 #include "classfile/classLoaderData.inline.hpp"
  37 #include "classfile/classLoadInfo.hpp"
  38 #include "classfile/javaAssertions.hpp"
  39 #include "classfile/javaClasses.inline.hpp"
  40 #include "classfile/moduleEntry.hpp"
  41 #include "classfile/modules.hpp"
  42 #include "classfile/packageEntry.hpp"
  43 #include "classfile/stringTable.hpp"
  44 #include "classfile/symbolTable.hpp"
  45 #include "classfile/systemDictionary.hpp"
  46 #include "classfile/vmClasses.hpp"
  47 #include "classfile/vmSymbols.hpp"
  48 #include "gc/shared/collectedHeap.inline.hpp"
  49 #include "interpreter/bytecode.hpp"
  50 #include "interpreter/bytecodeUtils.hpp"
  51 #include "jfr/jfrEvents.hpp"
  52 #include "jvm.h"
  53 #include "logging/log.hpp"
  54 #include "memory/oopFactory.hpp"
  55 #include "memory/referenceType.hpp"
  56 #include "memory/resourceArea.hpp"
  57 #include "memory/universe.hpp"
  58 #include "oops/access.inline.hpp"
  59 #include "oops/constantPool.hpp"
  60 #include "oops/fieldStreams.inline.hpp"
  61 #include "oops/flatArrayKlass.hpp"
  62 #include "oops/inlineKlass.inline.hpp"
  63 #include "oops/instanceKlass.hpp"
  64 #include "oops/klass.inline.hpp"
  65 #include "oops/method.hpp"
  66 #include "oops/objArrayKlass.hpp"
  67 #include "oops/objArrayOop.inline.hpp"
  68 #include "oops/oop.inline.hpp"
  69 #include "oops/oopCast.inline.hpp"
  70 #include "oops/recordComponent.hpp"
  71 #include "oops/refArrayOop.inline.hpp"
  72 #include "oops/valuePayload.inline.hpp"
  73 #include "prims/foreignGlobals.hpp"
  74 #include "prims/jvm_misc.hpp"
  75 #include "prims/jvmtiExport.hpp"
  76 #include "prims/jvmtiThreadState.inline.hpp"
  77 #include "prims/stackwalk.hpp"
  78 #include "runtime/arguments.hpp"
  79 #include "runtime/atomicAccess.hpp"
  80 #include "runtime/continuation.hpp"
  81 #include "runtime/deoptimization.hpp"
  82 #include "runtime/globals_extension.hpp"
  83 #include "runtime/handles.inline.hpp"
  84 #include "runtime/handshake.hpp"
  85 #include "runtime/init.hpp"
  86 #include "runtime/interfaceSupport.inline.hpp"
  87 #include "runtime/java.hpp"
  88 #include "runtime/javaCalls.hpp"
  89 #include "runtime/javaThread.hpp"
  90 #include "runtime/jfieldIDWorkaround.hpp"
  91 #include "runtime/jniHandles.inline.hpp"
  92 #include "runtime/mountUnmountDisabler.hpp"
  93 #include "runtime/os.inline.hpp"
  94 #include "runtime/osThread.hpp"
  95 #include "runtime/perfData.hpp"
  96 #include "runtime/reflection.hpp"
  97 #include "runtime/synchronizer.hpp"
  98 #include "runtime/threadIdentifier.hpp"
  99 #include "runtime/threadSMR.hpp"
 100 #include "runtime/vframe.inline.hpp"
 101 #include "runtime/vm_version.hpp"
 102 #include "runtime/vmOperations.hpp"
 103 #include "services/attachListener.hpp"
 104 #include "services/management.hpp"
 105 #include "services/threadService.hpp"
 106 #include "utilities/checkedCast.hpp"
 107 #include "utilities/copy.hpp"
 108 #include "utilities/defaultStream.hpp"
 109 #include "utilities/dtrace.hpp"
 110 #include "utilities/events.hpp"
 111 #include "utilities/macros.hpp"
 112 #include "utilities/utf8.hpp"
 113 #include "utilities/zipLibrary.hpp"
 114 #if INCLUDE_CDS
 115 #include "classfile/systemDictionaryShared.hpp"
 116 #endif
 117 #if INCLUDE_JFR
 118 #include "jfr/jfr.hpp"
 119 #endif
 120 #if INCLUDE_MANAGEMENT
 121 #include "services/finalizerService.hpp"
 122 #endif
 123 
 124 #include <errno.h>
 125 
 126 /*
 127   NOTE about use of any ctor or function call that can trigger a safepoint/GC:
 128   such ctors and calls MUST NOT come between an oop declaration/init and its
 129   usage because if objects are move this may cause various memory stomps, bus
 130   errors and segfaults. Here is a cookbook for causing so called "naked oop
 131   failures":
 132 
 133       JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields<etc> {
 134           // Object address to be held directly in mirror & not visible to GC
 135           oop mirror = JNIHandles::resolve_non_null(ofClass);
 136 
 137           // If this ctor can hit a safepoint, moving objects around, then
 138           ComplexConstructor foo;
 139 
 140           // Boom! mirror may point to JUNK instead of the intended object
 141           (some dereference of mirror)
 142 
 143           // Here's another call that may block for GC, making mirror stale
 144           MutexLocker ml(some_lock);
 145 
 146           // And here's an initializer that can result in a stale oop
 147           // all in one step.
 148           oop o = call_that_can_throw_exception(TRAPS);
 149 
 150 
 151   The solution is to keep the oop declaration BELOW the ctor or function
 152   call that might cause a GC, do another resolve to reassign the oop, or
 153   consider use of a Handle instead of an oop so there is immunity from object
 154   motion. But note that the "QUICK" entries below do not have a handlemark
 155   and thus can only support use of handles passed in.
 156 */
 157 
 158 extern void trace_class_resolution(Klass* to_class) {
 159   ResourceMark rm;
 160   int line_number = -1;
 161   const char * source_file = nullptr;
 162   const char * trace = "explicit";
 163   InstanceKlass* caller = nullptr;
 164   JavaThread* jthread = JavaThread::current();
 165   if (jthread->has_last_Java_frame()) {
 166     vframeStream vfst(jthread);
 167 
 168     // Scan up the stack skipping ClassLoader frames.
 169     Method* last_caller = nullptr;
 170 
 171     while (!vfst.at_end()) {
 172       Method* m = vfst.method();
 173       if (!vfst.method()->method_holder()->is_subclass_of(vmClasses::ClassLoader_klass())) {
 174         break;
 175       }
 176       last_caller = m;
 177       vfst.next();
 178     }
 179     // if this is called from Class.forName0 and that is called from Class.forName,
 180     // then print the caller of Class.forName.  If this is Class.loadClass, then print
 181     // that caller, otherwise keep quiet since this should be picked up elsewhere.
 182     bool found_it = false;
 183     if (!vfst.at_end() &&
 184         vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() &&
 185         vfst.method()->name() == vmSymbols::forName0_name()) {
 186       vfst.next();
 187       if (!vfst.at_end() &&
 188           vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() &&
 189           vfst.method()->name() == vmSymbols::forName_name()) {
 190         vfst.next();
 191         found_it = true;
 192       }
 193     } else if (last_caller != nullptr &&
 194                last_caller->method_holder()->name() ==
 195                  vmSymbols::java_lang_ClassLoader() &&
 196                last_caller->name() == vmSymbols::loadClass_name()) {
 197       found_it = true;
 198     } else if (!vfst.at_end()) {
 199       if (vfst.method()->is_native()) {
 200         // JNI call
 201         found_it = true;
 202       }
 203     }
 204     if (found_it && !vfst.at_end()) {
 205       // found the caller
 206       caller = vfst.method()->method_holder();
 207       line_number = vfst.method()->line_number_from_bci(vfst.bci());
 208       if (line_number == -1) {
 209         // show method name if it's a native method
 210         trace = vfst.method()->name_and_sig_as_C_string();
 211       }
 212       Symbol* s = caller->source_file_name();
 213       if (s != nullptr) {
 214         source_file = s->as_C_string();
 215       }
 216     }
 217   }
 218   if (caller != nullptr) {
 219     if (to_class != caller) {
 220       const char * from = caller->external_name();
 221       const char * to = to_class->external_name();
 222       // print in a single call to reduce interleaving between threads
 223       if (source_file != nullptr) {
 224         log_debug(class, resolve)("%s %s %s:%d (%s)", from, to, source_file, line_number, trace);
 225       } else {
 226         log_debug(class, resolve)("%s %s (%s)", from, to, trace);
 227       }
 228     }
 229   }
 230 }
 231 
 232 // java.lang.System //////////////////////////////////////////////////////////////////////
 233 
 234 JVM_ENTRY(jboolean, JVM_AOTEndRecording(JNIEnv *env))
 235 #if INCLUDE_CDS
 236   if (CDSConfig::is_dumping_preimage_static_archive()) {
 237     if (!AOTMetaspace::preimage_static_archive_dumped()) {
 238       AOTMetaspace::dump_static_archive(THREAD);
 239       return JNI_TRUE;
 240     }
 241   }
 242   return JNI_FALSE;
 243 #else
 244   return JNI_FALSE;
 245 #endif // INCLUDE_CDS
 246 JVM_END
 247 
 248 JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored))
 249   return os::javaTimeMillis();
 250 JVM_END
 251 
 252 JVM_LEAF(jlong, JVM_NanoTime(JNIEnv *env, jclass ignored))
 253   return os::javaTimeNanos();
 254 JVM_END
 255 
 256 // The function below is actually exposed by jdk.internal.misc.VM and not
 257 // java.lang.System, but we choose to keep it here so that it stays next
 258 // to JVM_CurrentTimeMillis and JVM_NanoTime
 259 
 260 const jlong MAX_DIFF_SECS = CONST64(0x0100000000); //  2^32
 261 const jlong MIN_DIFF_SECS = -MAX_DIFF_SECS; // -2^32
 262 
 263 JVM_LEAF(jlong, JVM_GetNanoTimeAdjustment(JNIEnv *env, jclass ignored, jlong offset_secs))
 264   jlong seconds;
 265   jlong nanos;
 266 
 267   os::javaTimeSystemUTC(seconds, nanos);
 268 
 269   // We're going to verify that the result can fit in a long.
 270   // For that we need the difference in seconds between 'seconds'
 271   // and 'offset_secs' to be such that:
 272   //     |seconds - offset_secs| < (2^63/10^9)
 273   // We're going to approximate 10^9 ~< 2^30 (1000^3 ~< 1024^3)
 274   // which makes |seconds - offset_secs| < 2^33
 275   // and we will prefer +/- 2^32 as the maximum acceptable diff
 276   // as 2^32 has a more natural feel than 2^33...
 277   //
 278   // So if |seconds - offset_secs| >= 2^32 - we return a special
 279   // sentinel value (-1) which the caller should take as an
 280   // exception value indicating that the offset given to us is
 281   // too far from range of the current time - leading to too big
 282   // a nano adjustment. The caller is expected to recover by
 283   // computing a more accurate offset and calling this method
 284   // again. (For the record 2^32 secs is ~136 years, so that
 285   // should rarely happen)
 286   //
 287   jlong diff = seconds - offset_secs;
 288   if (diff >= MAX_DIFF_SECS || diff <= MIN_DIFF_SECS) {
 289      return -1; // sentinel value: the offset is too far off the target
 290   }
 291 
 292   // return the adjustment. If you compute a time by adding
 293   // this number of nanoseconds along with the number of seconds
 294   // in the offset you should get the current UTC time.
 295   return (diff * (jlong)1000000000) + nanos;
 296 JVM_END
 297 
 298 JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,
 299                                jobject dst, jint dst_pos, jint length))
 300   // Check if we have null pointers
 301   if (src == nullptr || dst == nullptr) {
 302     THROW(vmSymbols::java_lang_NullPointerException());
 303   }
 304   arrayOop s = arrayOop(JNIHandles::resolve_non_null(src));
 305   arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst));
 306   assert(oopDesc::is_oop(s), "JVM_ArrayCopy: src not an oop");
 307   assert(oopDesc::is_oop(d), "JVM_ArrayCopy: dst not an oop");
 308   // Do copy
 309   s->klass()->copy_array(s, src_pos, d, dst_pos, length, thread);
 310 JVM_END
 311 
 312 
 313 static void set_property(Handle props, const char* key, const char* value, TRAPS) {
 314   JavaValue r(T_OBJECT);
 315   // public synchronized Object put(Object key, Object value);
 316   HandleMark hm(THREAD);
 317   Handle key_str    = java_lang_String::create_from_platform_dependent_str(key, CHECK);
 318   Handle value_str  = java_lang_String::create_from_platform_dependent_str((value != nullptr ? value : ""), CHECK);
 319   JavaCalls::call_virtual(&r,
 320                           props,
 321                           vmClasses::Properties_klass(),
 322                           vmSymbols::put_name(),
 323                           vmSymbols::object_object_object_signature(),
 324                           key_str,
 325                           value_str,
 326                           THREAD);
 327 }
 328 
 329 
 330 #define PUTPROP(props, name, value) set_property((props), (name), (value), CHECK_(properties));
 331 
 332 /*
 333  * Return all of the system properties in a Java String array with alternating
 334  * names and values from the jvm SystemProperty.
 335  * Which includes some internal and all commandline -D defined properties.
 336  */
 337 JVM_ENTRY(jobjectArray, JVM_GetProperties(JNIEnv *env))
 338   ResourceMark rm(THREAD);
 339   HandleMark hm(THREAD);
 340   int ndx = 0;
 341   int fixedCount = 2;
 342 
 343   SystemProperty* p = Arguments::system_properties();
 344   int count = Arguments::PropertyList_count(p);
 345 
 346   // Allocate result String array
 347   InstanceKlass* ik = vmClasses::String_klass();
 348   objArrayOop r = oopFactory::new_objArray(ik, (count + fixedCount) * 2, CHECK_NULL);
 349   objArrayHandle result_h(THREAD, r);
 350 
 351   while (p != nullptr) {
 352     const char * key = p->key();
 353     if (strcmp(key, "sun.nio.MaxDirectMemorySize") != 0) {
 354         const char * value = p->value();
 355         Handle key_str    = java_lang_String::create_from_platform_dependent_str(key, CHECK_NULL);
 356         Handle value_str  = java_lang_String::create_from_platform_dependent_str((value != nullptr ? value : ""), CHECK_NULL);
 357         result_h->obj_at_put(ndx * 2,  key_str());
 358         result_h->obj_at_put(ndx * 2 + 1, value_str());
 359         ndx++;
 360     }
 361     p = p->next();
 362   }
 363 
 364   // Convert the -XX:MaxDirectMemorySize= command line flag
 365   // to the sun.nio.MaxDirectMemorySize property.
 366   // Do this after setting user properties to prevent people
 367   // from setting the value with a -D option, as requested.
 368   // Leave empty if not supplied
 369   if (!FLAG_IS_DEFAULT(MaxDirectMemorySize)) {
 370     char as_chars[256];
 371     jio_snprintf(as_chars, sizeof(as_chars), JULONG_FORMAT, MaxDirectMemorySize);
 372     Handle key_str = java_lang_String::create_from_platform_dependent_str("sun.nio.MaxDirectMemorySize", CHECK_NULL);
 373     Handle value_str  = java_lang_String::create_from_platform_dependent_str(as_chars, CHECK_NULL);
 374     result_h->obj_at_put(ndx * 2,  key_str());
 375     result_h->obj_at_put(ndx * 2 + 1, value_str());
 376     ndx++;
 377   }
 378 
 379   // JVM monitoring and management support
 380   // Add the sun.management.compiler property for the compiler's name
 381   {
 382 #undef CSIZE
 383 #if defined(_LP64)
 384   #define CSIZE "64-Bit "
 385 #else
 386   #define CSIZE
 387 #endif // 64bit
 388 
 389 #if COMPILER1_AND_COMPILER2
 390     const char* compiler_name = "HotSpot " CSIZE "Tiered Compilers";
 391 #else
 392 #if defined(COMPILER1)
 393     const char* compiler_name = "HotSpot " CSIZE "Client Compiler";
 394 #elif defined(COMPILER2)
 395     const char* compiler_name = "HotSpot " CSIZE "Server Compiler";
 396 #elif INCLUDE_JVMCI
 397     #error "INCLUDE_JVMCI should imply COMPILER1_OR_COMPILER2"
 398 #else
 399     const char* compiler_name = "";
 400 #endif // compilers
 401 #endif // COMPILER1_AND_COMPILER2
 402 
 403     if (*compiler_name != '\0' &&
 404         (Arguments::mode() != Arguments::_int)) {
 405       Handle key_str = java_lang_String::create_from_platform_dependent_str("sun.management.compiler", CHECK_NULL);
 406       Handle value_str  = java_lang_String::create_from_platform_dependent_str(compiler_name, CHECK_NULL);
 407       result_h->obj_at_put(ndx * 2,  key_str());
 408       result_h->obj_at_put(ndx * 2 + 1, value_str());
 409       ndx++;
 410     }
 411   }
 412 
 413   return (jobjectArray) JNIHandles::make_local(THREAD, result_h());
 414 JVM_END
 415 
 416 
 417 /*
 418  * Return the temporary directory that the VM uses for the attach
 419  * and perf data files.
 420  *
 421  * It is important that this directory is well-known and the
 422  * same for all VM instances. It cannot be affected by configuration
 423  * variables such as java.io.tmpdir.
 424  */
 425 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
 426   HandleMark hm(THREAD);
 427   const char* temp_dir = os::get_temp_directory();
 428   Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
 429   return (jstring) JNIHandles::make_local(THREAD, h());
 430 JVM_END
 431 
 432 static void validate_array_arguments(Klass* elmClass, jint len, TRAPS) {
 433   if (len < 0) {
 434     THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Array length is negative");
 435   }
 436   elmClass->initialize(CHECK);
 437   if (elmClass->is_array_klass() || elmClass->is_identity_class()) {
 438     THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Element class is not a value class");
 439   }
 440   if (elmClass->is_abstract()) {
 441     THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Element class is abstract");
 442   }
 443 }
 444 
 445 JVM_ENTRY(jarray, JVM_CopyOfSpecialArray(JNIEnv *env, jarray orig, jint from, jint to))
 446   oop o = JNIHandles::resolve_non_null(orig);
 447   assert(o->is_array(), "Must be");
 448   oop array = nullptr;
 449   arrayOop org = (arrayOop)o;
 450   arrayHandle oh(THREAD, org);
 451   ObjArrayKlass* ak = ObjArrayKlass::cast(org->klass());
 452   InlineKlass* vk = InlineKlass::cast(ak->element_klass());
 453   int len = to - from;  // length of the new array
 454   if (ak->is_null_free_array_klass()) {
 455     if ((len != 0) && (from >= org->length() || to > org->length())) {
 456       THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Copying of null-free array with uninitialized elements");
 457     }
 458   }
 459   if (org->is_flatArray()) {
 460     // The whole JVM_CopyOfSpecialArray is currently broken. Fix this in a separate bugfix.
 461     int org_length = org->length();
 462     int copy_len = MIN2(to, org_length) - MIN2(from, org_length);
 463     FlatArrayKlass* const fak = FlatArrayKlass::cast(org->klass());
 464     flatArrayOop dst = oopFactory::new_flatArray(fak, len, CHECK_NULL);
 465     assert(!ak->is_null_free_array_klass() || copy_len == len,
 466            "Failed to throw the IllegalArgumentException");
 467     if (copy_len != 0) {
 468       int start = MIN2(from, org_length - 1);
 469       FlatArrayPayload src_payload(flatArrayOop(oh()), start, fak);
 470       FlatArrayPayload dst_payload(dst, 0, fak);
 471       int end = to < oh()->length() ? to : oh()->length();
 472       for (int i = from; i < end; i++) {
 473         // Copy a value
 474         src_payload.copy_to(dst_payload);
 475 
 476         // Advance to the next element
 477         src_payload.next_element();
 478         dst_payload.next_element();
 479       }
 480     }
 481     array = dst;
 482   } else {
 483     const ArrayProperties props = ArrayProperties::Default().with_null_restricted(org->is_null_free_array());
 484 
 485     array = oopFactory::new_objArray(vk, len, props,  CHECK_NULL);
 486     int end = to < oh()->length() ? to : oh()->length();
 487     for (int i = from; i < end; i++) {
 488       if (i < ((objArrayOop)oh())->length()) {
 489         oop val = ((objArrayOop)oh())->obj_at(i, CHECK_NULL);
 490         ((objArrayOop)array)->obj_at_put(i - from, val);
 491       } else {
 492         assert(!ak->is_null_free_array_klass(), "Must be a nullable array");
 493         ((objArrayOop)array)->obj_at_put(i - from, nullptr);
 494       }
 495     }
 496   }
 497   return (jarray) JNIHandles::make_local(THREAD, array);
 498 JVM_END
 499 
 500 JVM_ENTRY(jarray, JVM_NewNullRestrictedNonAtomicArray(JNIEnv *env, jclass elmClass, jint len, jobject initVal))
 501   oop mirror = JNIHandles::resolve_non_null(elmClass);
 502   oop init = JNIHandles::resolve(initVal);
 503   if (init == nullptr) {
 504     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Initial value cannot be null");
 505   }
 506   Handle init_h(THREAD, init);
 507   Klass* klass = java_lang_Class::as_Klass(mirror);
 508   if (klass != init_h()->klass()) {
 509     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Type mismatch between array and initial value");
 510   }
 511   validate_array_arguments(klass, len, CHECK_NULL);
 512   const ArrayProperties props = ArrayProperties::Default()
 513     .with_null_restricted()
 514     .with_non_atomic();
 515 
 516   objArrayOop array = oopFactory::new_objArray(klass, len, props, CHECK_NULL);
 517   for (int i = 0; i < len; i++) {
 518     array->obj_at_put(i, init_h() /*, CHECK_NULL*/ );
 519   }
 520   return (jarray) JNIHandles::make_local(THREAD, array);
 521 JVM_END
 522 
 523 JVM_ENTRY(jarray, JVM_NewNullRestrictedAtomicArray(JNIEnv *env, jclass elmClass, jint len, jobject initVal))
 524   oop mirror = JNIHandles::resolve_non_null(elmClass);
 525   oop init = JNIHandles::resolve(initVal);
 526   if (init == nullptr) {
 527     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Initial value cannot be null");
 528   }
 529   Handle init_h(THREAD, init);
 530   Klass* klass = java_lang_Class::as_Klass(mirror);
 531   if (klass != init_h()->klass()) {
 532     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Type mismatch between array and initial value");
 533   }
 534   validate_array_arguments(klass, len, CHECK_NULL);
 535   const ArrayProperties props = ArrayProperties::Default().with_null_restricted();
 536   objArrayOop array = oopFactory::new_objArray(klass, len, props, CHECK_NULL);
 537   for (int i = 0; i < len; i++) {
 538     array->obj_at_put(i, init_h() /*, CHECK_NULL*/ );
 539   }
 540   return (jarray) JNIHandles::make_local(THREAD, array);
 541 JVM_END
 542 
 543 JVM_ENTRY(jarray, JVM_NewNullableAtomicArray(JNIEnv *env, jclass elmClass, jint len))
 544   oop mirror = JNIHandles::resolve_non_null(elmClass);
 545   Klass* klass = java_lang_Class::as_Klass(mirror);
 546   klass->initialize(CHECK_NULL);
 547   validate_array_arguments(klass, len, CHECK_NULL);
 548   objArrayOop array = oopFactory::new_objArray(klass, len, ArrayProperties::Default(), CHECK_NULL);
 549   return (jarray) JNIHandles::make_local(THREAD, array);
 550 JVM_END
 551 
 552 JVM_ENTRY(jarray, JVM_NewReferenceArray(JNIEnv *env, jclass elmClass, jint len))
 553   oop mirror = JNIHandles::resolve_non_null(elmClass);
 554   Klass* klass = java_lang_Class::as_Klass(mirror);
 555   validate_array_arguments(klass, len, CHECK_NULL);
 556   refArrayOop array = oopFactory::new_refArray(klass, len, ArrayProperties::Default(), CHECK_NULL);
 557   return (jarray) JNIHandles::make_local(THREAD, array);
 558 JVM_END
 559 
 560 JVM_ENTRY(jboolean, JVM_IsFlatArray(JNIEnv *env, jobject obj))
 561   arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj));
 562   return oop->is_flatArray();
 563 JVM_END
 564 
 565 JVM_ENTRY(jboolean, JVM_IsNullRestrictedArray(JNIEnv *env, jobject obj))
 566   arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj));
 567   return oop->is_null_free_array();
 568 JVM_END
 569 
 570 JVM_ENTRY(jboolean, JVM_IsAtomicArray(JNIEnv *env, jobject obj))
 571   // There are multiple cases where an array can/must support atomic access:
 572   //   - the array is a reference array
 573   //   - the array uses an atomic flat layout: NULLABLE_ATOMIC_FLAT or NULL_FREE_ATOMIC_FLAT
 574   //   - the array is flat and its component type is naturally atomic
 575   arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj));
 576   if (oop->is_refArray()) return true;
 577   if (oop->is_flatArray()) {
 578     FlatArrayKlass* fak = FlatArrayKlass::cast(oop->klass());
 579     if (LayoutKindHelper::is_atomic_flat(fak->layout_kind())) return true;
 580     if (fak->element_klass()->is_naturally_atomic()) return true;
 581   }
 582   return false;
 583 JVM_END
 584 
 585 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////
 586 
 587 extern volatile jint vm_created;
 588 
 589 JVM_ENTRY_NO_ENV(void, JVM_BeforeHalt())
 590   EventShutdown event;
 591   if (event.should_commit()) {
 592     event.set_reason("Shutdown requested from Java");
 593     event.commit();
 594   }
 595 JVM_END
 596 
 597 
 598 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
 599   before_exit(thread, true);
 600   vm_exit(code);
 601 JVM_END
 602 
 603 
 604 JVM_ENTRY_NO_ENV(void, JVM_GC(void))
 605   if (!DisableExplicitGC) {
 606     EventSystemGC event;
 607     event.set_invokedConcurrent(ExplicitGCInvokesConcurrent);
 608     Universe::heap()->collect(GCCause::_java_lang_system_gc);
 609     event.commit();
 610   }
 611 JVM_END
 612 
 613 
 614 JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))
 615   return Universe::heap()->millis_since_last_whole_heap_examined();
 616 JVM_END
 617 
 618 
 619 static inline jlong convert_size_t_to_jlong(size_t val) {
 620   // In the 64-bit vm, a size_t can overflow a jlong (which is signed).
 621   NOT_LP64 (return (jlong)val;)
 622   LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);)
 623 }
 624 
 625 JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void))
 626   size_t n = Universe::heap()->capacity();
 627   return convert_size_t_to_jlong(n);
 628 JVM_END
 629 
 630 
 631 JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void))
 632   size_t n = Universe::heap()->unused();
 633   return convert_size_t_to_jlong(n);
 634 JVM_END
 635 
 636 
 637 JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void))
 638   size_t n = Universe::heap()->max_capacity();
 639   return convert_size_t_to_jlong(n);
 640 JVM_END
 641 
 642 
 643 JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void))
 644   return os::active_processor_count();
 645 JVM_END
 646 
 647 JVM_LEAF(jboolean, JVM_IsUseContainerSupport(void))
 648 #ifdef LINUX
 649   if (UseContainerSupport) {
 650     return JNI_TRUE;
 651   }
 652 #endif
 653   return JNI_FALSE;
 654 JVM_END
 655 
 656 JVM_LEAF(jboolean, JVM_IsContainerized(void))
 657   if (os::is_containerized()) {
 658     return JNI_TRUE;
 659   }
 660   return JNI_FALSE;
 661 JVM_END
 662 
 663 // java.lang.Throwable //////////////////////////////////////////////////////
 664 
 665 JVM_ENTRY(void, JVM_FillInStackTrace(JNIEnv *env, jobject receiver))
 666   Handle exception(thread, JNIHandles::resolve_non_null(receiver));
 667   java_lang_Throwable::fill_in_stack_trace(exception);
 668 JVM_END
 669 
 670 // java.lang.NullPointerException ///////////////////////////////////////////
 671 
 672 JVM_ENTRY(jstring, JVM_GetExtendedNPEMessage(JNIEnv *env, jthrowable throwable))
 673   if (!ShowCodeDetailsInExceptionMessages) return nullptr;
 674 
 675   oop exc = JNIHandles::resolve_non_null(throwable);
 676 
 677   Method* method;
 678   int bci;
 679   if (!java_lang_Throwable::get_top_method_and_bci(exc, &method, &bci)) {
 680     return nullptr;
 681   }
 682   if (method->is_native()) {
 683     return nullptr;
 684   }
 685 
 686   stringStream ss;
 687   bool ok = BytecodeUtils::get_NPE_message_at(&ss, method, bci);
 688   if (ok) {
 689     oop result = java_lang_String::create_oop_from_str(ss.base(), CHECK_NULL);
 690     return (jstring) JNIHandles::make_local(THREAD, result);
 691   } else {
 692     return nullptr;
 693   }
 694 JVM_END
 695 
 696 // java.lang.StackTraceElement //////////////////////////////////////////////
 697 
 698 
 699 JVM_ENTRY(void, JVM_InitStackTraceElementArray(JNIEnv *env, jobjectArray elements, jobject backtrace, jint depth))
 700   Handle backtraceh(THREAD, JNIHandles::resolve(backtrace));
 701   objArrayOop st = objArrayOop(JNIHandles::resolve(elements));
 702   objArrayHandle stack_trace(THREAD, st);
 703   // Fill in the allocated stack trace
 704   java_lang_Throwable::get_stack_trace_elements(depth, backtraceh, stack_trace, CHECK);
 705 JVM_END
 706 
 707 
 708 JVM_ENTRY(void, JVM_InitStackTraceElement(JNIEnv* env, jobject element, jobject stackFrameInfo))
 709   Handle stack_frame_info(THREAD, JNIHandles::resolve_non_null(stackFrameInfo));
 710   Handle stack_trace_element(THREAD, JNIHandles::resolve_non_null(element));
 711   java_lang_StackFrameInfo::to_stack_trace_element(stack_frame_info, stack_trace_element, CHECK);
 712 JVM_END
 713 
 714 
 715 // java.lang.StackWalker //////////////////////////////////////////////////////
 716 JVM_ENTRY(void, JVM_ExpandStackFrameInfo(JNIEnv *env, jobject obj))
 717   Handle stack_frame_info(THREAD, JNIHandles::resolve_non_null(obj));
 718 
 719   bool have_name = (java_lang_StackFrameInfo::name(stack_frame_info()) != nullptr);
 720   bool have_type = (java_lang_StackFrameInfo::type(stack_frame_info()) != nullptr);
 721   Method* method = java_lang_StackFrameInfo::get_method(stack_frame_info());
 722   if (!have_name) {
 723     oop name = StringTable::intern(method->name(), CHECK);
 724     java_lang_StackFrameInfo::set_name(stack_frame_info(), name);
 725   }
 726   if (!have_type) {
 727     Handle type = java_lang_String::create_from_symbol(method->signature(), CHECK);
 728     java_lang_StackFrameInfo::set_type(stack_frame_info(), type());
 729   }
 730 JVM_END
 731 
 732 JVM_ENTRY(jobject, JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jint mode,
 733                                      jint skip_frames, jobject contScope, jobject cont,
 734                                      jint buffer_size, jint start_index, jobjectArray frames))
 735   if (!thread->has_last_Java_frame()) {
 736     THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: no stack trace", nullptr);
 737   }
 738 
 739   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
 740   Handle contScope_h(THREAD, JNIHandles::resolve(contScope));
 741   Handle cont_h(THREAD, JNIHandles::resolve(cont));
 742   // frames array is a ClassFrameInfo[] array when only getting caller reference,
 743   // and a StackFrameInfo[] array (or derivative) otherwise. It should never
 744   // be null.
 745   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
 746   objArrayHandle frames_array_h(THREAD, fa);
 747 
 748   if (frames_array_h->length() < buffer_size) {
 749     THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers", nullptr);
 750   }
 751 
 752   oop result = StackWalk::walk(stackStream_h, mode, skip_frames, contScope_h, cont_h,
 753                                buffer_size, start_index, frames_array_h, CHECK_NULL);
 754   return JNIHandles::make_local(THREAD, result);
 755 JVM_END
 756 
 757 
 758 JVM_ENTRY(jint, JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jint mode, jlong anchor,
 759                                   jint last_batch_count, jint buffer_size, jint start_index,
 760                                   jobjectArray frames))
 761   // frames array is a ClassFrameInfo[] array when only getting caller reference,
 762   // and a StackFrameInfo[] array (or derivative) otherwise. It should never
 763   // be null.
 764   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
 765   objArrayHandle frames_array_h(THREAD, fa);
 766 
 767   if (frames_array_h->length() < buffer_size) {
 768     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers");
 769   }
 770 
 771   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
 772   return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, last_batch_count, buffer_size,
 773                                   start_index, frames_array_h, THREAD);
 774 JVM_END
 775 
 776 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont))
 777   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
 778   objArrayHandle frames_array_h(THREAD, fa);
 779   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
 780   Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont));
 781 
 782   StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD);
 783 JVM_END
 784 
 785 // java.lang.Object ///////////////////////////////////////////////
 786 
 787 
 788 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
 789   // as implemented in the classic virtual machine; return 0 if object is null
 790   if (handle == nullptr) {
 791     return 0;
 792   }
 793   oop obj = JNIHandles::resolve_non_null(handle);
 794   if (Arguments::is_valhalla_enabled() && obj->klass()->is_inline_klass()) {
 795     const intptr_t obj_identity_hash = obj->mark().hash();
 796     // Check if mark word contains hash code already.
 797     // It is possible that the generated identity hash is 0, which is not
 798     // distinct from the no_hash value. In such a case, the hash will be
 799     // computed and set every time JVM_IHashCode is called. If that happens,
 800     // the only consequence is losing out on the optimization.
 801     if (obj_identity_hash != markWord::no_hash) {
 802       return checked_cast<jint>(obj_identity_hash);
 803     }
 804 
 805     // Compute hash by calling ValueObjectMethods.valueObjectHashCode.
 806     // The identity hash is invariantly immutable (see its JavaDoc comment).
 807     JavaValue result(T_INT);
 808     JavaCallArguments args;
 809     Handle ho(THREAD, obj);
 810     args.push_oop(ho);
 811     methodHandle method(THREAD, Universe::value_object_hash_code_method());
 812     JavaCalls::call(&result, method, &args, THREAD);
 813     if (HAS_PENDING_EXCEPTION) {
 814       if (!PENDING_EXCEPTION->is_a(vmClasses::Error_klass())) {
 815         Handle e(THREAD, PENDING_EXCEPTION);
 816         CLEAR_PENDING_EXCEPTION;
 817         THROW_MSG_CAUSE_(vmSymbols::java_lang_InternalError(), "Internal error in hashCode", e, false);
 818       }
 819     }
 820     const intptr_t identity_hash = result.get_jint();
 821 
 822     // We now have to set the hash via CAS. It's possible that this will race
 823     // other threads. By our invariant of immutability, when there is a
 824     // race, the identity hash code is going to be one of the following:
 825     // a) 0, another thread updated other markWord bits; b) identity_hash set
 826     // by another thread; or c) identity_hash set by the current thread.
 827     // A nonzero identity hash code that is not the identity_hash computed
 828     // earlier indicates a violation of the invariant.
 829     markWord current_mark, old_mark, new_mark;
 830     do {
 831       current_mark = ho->mark();
 832       new_mark = current_mark.copy_set_hash(identity_hash);
 833       old_mark = ho->cas_set_mark(new_mark, current_mark);
 834       assert(old_mark.has_no_hash() || old_mark.hash() == new_mark.hash(),
 835             "CAS identity hash invariant violated, expected=" INTPTR_FORMAT " actual=" INTPTR_FORMAT,
 836             new_mark.hash(),
 837             old_mark.hash());
 838     } while (old_mark != current_mark);
 839 
 840     return checked_cast<jint>(new_mark.hash());
 841   } else {
 842     return checked_cast<jint>(ObjectSynchronizer::FastHashCode(THREAD, obj));
 843   }
 844 JVM_END
 845 
 846 
 847 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
 848   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
 849   ObjectSynchronizer::wait(obj, ms, CHECK);
 850 JVM_END
 851 
 852 
 853 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
 854   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
 855   ObjectSynchronizer::notify(obj, CHECK);
 856 JVM_END
 857 
 858 
 859 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))
 860   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
 861   ObjectSynchronizer::notifyall(obj, CHECK);
 862 JVM_END
 863 
 864 
 865 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
 866   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
 867   Klass* klass = obj->klass();
 868   JvmtiVMObjectAllocEventCollector oam;
 869 
 870 #ifdef ASSERT
 871   // Just checking that the cloneable flag is set correct
 872   if (obj->is_array()) {
 873     guarantee(klass->is_cloneable(), "all arrays are cloneable");
 874   } else {
 875     guarantee(obj->is_instance(), "should be instanceOop");
 876     bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass());
 877     guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
 878   }
 879 #endif
 880 
 881   // Check if class of obj supports the Cloneable interface.
 882   // All arrays are considered to be cloneable (See JLS 20.1.5).
 883   // All j.l.r.Reference classes are considered non-cloneable.
 884   if (!klass->is_cloneable() ||
 885       (klass->is_instance_klass() &&
 886        InstanceKlass::cast(klass)->reference_type() != REF_NONE)) {
 887     ResourceMark rm(THREAD);
 888     THROW_MSG_NULL(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
 889   }
 890 
 891   if (klass->is_inline_klass()) {
 892     // Value instances have no identity, so return the current instance instead of allocating a new one
 893     // Value classes cannot have finalizers, so the method can return immediately
 894     return JNIHandles::make_local(THREAD, obj());
 895   }
 896 
 897   // Make shallow object copy
 898   const size_t size = obj->size();
 899   oop new_obj_oop = nullptr;
 900   if (obj->is_array()) {
 901     const int length = ((arrayOop)obj())->length();
 902     new_obj_oop = Universe::heap()->array_allocate(klass, size, length,
 903                                                    /* do_zero */ true, CHECK_NULL);
 904   } else {
 905     new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL);
 906   }
 907 
 908   HeapAccess<>::clone(obj(), new_obj_oop, size);
 909 
 910   Handle new_obj(THREAD, new_obj_oop);
 911   // Caution: this involves a java upcall, so the clone should be
 912   // "gc-robust" by this stage.
 913   if (klass->has_finalizer()) {
 914     assert(obj->is_instance(), "should be instanceOop");
 915     new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL);
 916     new_obj = Handle(THREAD, new_obj_oop);
 917   }
 918 
 919   return JNIHandles::make_local(THREAD, new_obj());
 920 JVM_END
 921 
 922 // java.lang.ref.Finalizer ////////////////////////////////////////////////////
 923 
 924 JVM_ENTRY(void, JVM_ReportFinalizationComplete(JNIEnv * env, jobject finalizee))
 925   MANAGEMENT_ONLY(FinalizerService::on_complete(JNIHandles::resolve_non_null(finalizee), THREAD);)
 926 JVM_END
 927 
 928 JVM_LEAF(jboolean, JVM_IsFinalizationEnabled(JNIEnv * env))
 929   return InstanceKlass::is_finalization_enabled();
 930 JVM_END
 931 
 932 // jdk.internal.vm.Continuation /////////////////////////////////////////////////////
 933 
 934 JVM_ENTRY(void, JVM_RegisterContinuationMethods(JNIEnv *env, jclass cls))
 935   CONT_RegisterNativeMethods(env, cls);
 936 JVM_END
 937 
 938 // java.io.File ///////////////////////////////////////////////////////////////
 939 
 940 JVM_LEAF(char*, JVM_NativePath(char* path))
 941   return os::native_path(path);
 942 JVM_END
 943 
 944 
 945 // Misc. class handling ///////////////////////////////////////////////////////////
 946 
 947 
 948 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env))
 949   // Getting the class of the caller frame.
 950   //
 951   // The call stack at this point looks something like this:
 952   //
 953   // [0] [ @CallerSensitive public jdk.internal.reflect.Reflection.getCallerClass ]
 954   // [1] [ @CallerSensitive API.method                                   ]
 955   // [.] [ (skipped intermediate frames)                                 ]
 956   // [n] [ caller                                                        ]
 957   vframeStream vfst(thread);
 958   // Cf. LibraryCallKit::inline_native_Reflection_getCallerClass
 959   for (int n = 0; !vfst.at_end(); vfst.security_next(), n++) {
 960     Method* m = vfst.method();
 961     assert(m != nullptr, "sanity");
 962     switch (n) {
 963     case 0:
 964       // This must only be called from Reflection.getCallerClass
 965       if (m->intrinsic_id() != vmIntrinsics::_getCallerClass) {
 966         THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "JVM_GetCallerClass must only be called from Reflection.getCallerClass");
 967       }
 968       // fall-through
 969     case 1:
 970       // Frame 0 and 1 must be caller sensitive.
 971       if (!m->caller_sensitive()) {
 972         THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), err_msg("CallerSensitive annotation expected at frame %d", n));
 973       }
 974       break;
 975     default:
 976       if (!m->is_ignored_by_security_stack_walk()) {
 977         // We have reached the desired frame; return the holder class.
 978         return (jclass) JNIHandles::make_local(THREAD, m->method_holder()->java_mirror());
 979       }
 980       break;
 981     }
 982   }
 983   return nullptr;
 984 JVM_END
 985 
 986 
 987 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))
 988   oop mirror = nullptr;
 989   BasicType t = name2type(utf);
 990   if (t != T_ILLEGAL && !is_reference_type(t)) {
 991     mirror = Universe::java_mirror(t);
 992   }
 993   if (mirror == nullptr) {
 994     THROW_MSG_NULL(vmSymbols::java_lang_ClassNotFoundException(), (char*) utf);
 995   } else {
 996     return (jclass) JNIHandles::make_local(THREAD, mirror);
 997   }
 998 JVM_END
 999 
1000 
1001 // Returns a class loaded by the bootstrap class loader; or null
1002 // if not found.  ClassNotFoundException is not thrown.
1003 // FindClassFromBootLoader is exported to the launcher for windows.
1004 JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env,
1005                                               const char* name))
1006   // Java libraries should ensure that name is never null or illegal.
1007   if (name == nullptr || (int)strlen(name) > Symbol::max_length()) {
1008     // It's impossible to create this class;  the name cannot fit
1009     // into the constant pool.
1010     return nullptr;
1011   }
1012   assert(UTF8::is_legal_utf8((const unsigned char*)name, strlen(name), false), "illegal UTF name");
1013 
1014   TempNewSymbol h_name = SymbolTable::new_symbol(name);
1015   Klass* k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL);
1016   if (k == nullptr) {
1017     return nullptr;
1018   }
1019 
1020   if (log_is_enabled(Debug, class, resolve)) {
1021     trace_class_resolution(k);
1022   }
1023   return (jclass) JNIHandles::make_local(THREAD, k->java_mirror());
1024 JVM_END
1025 
1026 // Find a class with this name in this loader.
1027 JVM_ENTRY(jclass, JVM_FindClassFromLoader(JNIEnv* env, const char* name,
1028                                           jboolean init, jobject loader))
1029   TempNewSymbol h_name =
1030        SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_ClassNotFoundException(),
1031                                            CHECK_NULL);
1032 
1033   oop loader_oop = JNIHandles::resolve(loader);
1034   Handle h_loader(THREAD, loader_oop);
1035 
1036   jclass result = find_class_from_class_loader(env, h_name, init, h_loader,
1037                                                false, THREAD);
1038 
1039   if (log_is_enabled(Debug, class, resolve) && result != nullptr) {
1040     trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
1041   }
1042   return result;
1043 JVM_END
1044 
1045 // Currently only called from the old verifier.
1046 JVM_ENTRY(jclass, JVM_FindClassFromClass(JNIEnv *env, const char *name,
1047                                          jboolean init, jclass from))
1048   TempNewSymbol h_name =
1049        SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_ClassNotFoundException(),
1050                                            CHECK_NULL);
1051   oop from_class_oop = JNIHandles::resolve(from);
1052   assert(from_class_oop != nullptr, "must be");
1053   Klass* from_class = java_lang_Class::as_Klass(from_class_oop);
1054   assert(from_class != nullptr, "must be");
1055   oop class_loader = from_class->class_loader();
1056 
1057   Handle h_loader(THREAD, class_loader);
1058   jclass result = find_class_from_class_loader(env, h_name, init, h_loader, true, thread);
1059 
1060   if (log_is_enabled(Debug, class, resolve) && result != nullptr) {
1061     // this function is generally only used for class loading during verification.
1062     ResourceMark rm;
1063     const char* from_name = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(from))->external_name();
1064     const char* to_name = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result))->external_name();
1065     log_debug(class, resolve)("%s %s (verification)", from_name, to_name);
1066   }
1067 
1068 #if INCLUDE_CDS
1069   if (CDSConfig::is_preserving_verification_constraints() && from_class->is_instance_klass()) {
1070     InstanceKlass* ik = InstanceKlass::cast(from_class);
1071     SystemDictionaryShared::add_old_verification_constraint(THREAD, ik, h_name);
1072   }
1073 #endif
1074 
1075   return result;
1076 JVM_END
1077 
1078 // common code for JVM_DefineClass() and JVM_DefineClassWithSource()
1079 static jclass jvm_define_class_common(const char *name,
1080                                       jobject loader, const jbyte *buf,
1081                                       jsize len, jobject pd, const char *source,
1082                                       TRAPS) {
1083   if (source == nullptr)  source = "__JVM_DefineClass__";
1084 
1085   JavaThread* jt = THREAD;
1086 
1087   PerfClassTraceTime vmtimer(ClassLoader::perf_define_appclass_time(),
1088                              ClassLoader::perf_define_appclass_selftime(),
1089                              ClassLoader::perf_define_appclasses(),
1090                              jt->get_thread_stat()->perf_recursion_counts_addr(),
1091                              jt->get_thread_stat()->perf_timers_addr(),
1092                              PerfClassTraceTime::DEFINE_CLASS);
1093 
1094   if (UsePerfData) {
1095     ClassLoader::perf_app_classfile_bytes_read()->inc(len);
1096   }
1097 
1098   // Class resolution will get the class name from the .class stream if the name is null.
1099   TempNewSymbol class_name = name == nullptr ? nullptr :
1100        SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_NoClassDefFoundError(),
1101                                            CHECK_NULL);
1102 
1103   ResourceMark rm(THREAD);
1104   ClassFileStream st((u1*)buf, len, source);
1105   Handle class_loader (THREAD, JNIHandles::resolve(loader));
1106   Handle protection_domain (THREAD, JNIHandles::resolve(pd));
1107   ClassLoadInfo cl_info(protection_domain);
1108   Klass* k = SystemDictionary::resolve_from_stream(&st, class_name,
1109                                                    class_loader,
1110                                                    cl_info,
1111                                                    CHECK_NULL);
1112 
1113   if (log_is_enabled(Debug, class, resolve)) {
1114     trace_class_resolution(k);
1115   }
1116 
1117   return (jclass) JNIHandles::make_local(THREAD, k->java_mirror());
1118 }
1119 
1120 enum {
1121   NESTMATE              = java_lang_invoke_MemberName::MN_NESTMATE_CLASS,
1122   HIDDEN_CLASS          = java_lang_invoke_MemberName::MN_HIDDEN_CLASS,
1123   STRONG_LOADER_LINK    = java_lang_invoke_MemberName::MN_STRONG_LOADER_LINK,
1124   ACCESS_VM_ANNOTATIONS = java_lang_invoke_MemberName::MN_ACCESS_VM_ANNOTATIONS
1125 };
1126 
1127 /*
1128  * Define a class with the specified flags that indicates if it's a nestmate,
1129  * hidden, or strongly referenced from class loader.
1130  */
1131 static jclass jvm_lookup_define_class(jclass lookup, const char *name,
1132                                       const jbyte *buf, jsize len, jobject pd,
1133                                       jboolean init, int flags, jobject classData, TRAPS) {
1134   ResourceMark rm(THREAD);
1135 
1136   InstanceKlass* lookup_k = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(lookup));
1137   // Lookup class must not be a primitive class (whose mirror has a null Klass*)
1138   if (lookup_k == nullptr) {
1139     // The error message is wrong. We come here only if lookup is a primitive class
1140     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Lookup class is null");
1141   }
1142 
1143   Handle class_loader (THREAD, lookup_k->class_loader());
1144 
1145   bool is_nestmate = (flags & NESTMATE) == NESTMATE;
1146   bool is_hidden = (flags & HIDDEN_CLASS) == HIDDEN_CLASS;
1147   bool is_strong = (flags & STRONG_LOADER_LINK) == STRONG_LOADER_LINK;
1148   bool vm_annotations = (flags & ACCESS_VM_ANNOTATIONS) == ACCESS_VM_ANNOTATIONS;
1149 
1150   InstanceKlass* host_class = nullptr;
1151   if (is_nestmate) {
1152     host_class = lookup_k->nest_host(CHECK_NULL);
1153   }
1154 
1155   log_info(class, nestmates)("LookupDefineClass: %s - %s%s, %s, %s, %s",
1156                              name,
1157                              is_nestmate ? "with dynamic nest-host " : "non-nestmate",
1158                              is_nestmate ? host_class->external_name() : "",
1159                              is_hidden ? "hidden" : "not hidden",
1160                              is_strong ? "strong" : "weak",
1161                              vm_annotations ? "with vm annotations" : "without vm annotation");
1162 
1163   if (!is_hidden) {
1164     // classData is only applicable for hidden classes
1165     if (classData != nullptr) {
1166       THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "classData is only applicable for hidden classes");
1167     }
1168     if (is_nestmate) {
1169       THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "dynamic nestmate is only applicable for hidden classes");
1170     }
1171     if (!is_strong) {
1172       THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "an ordinary class must be strongly referenced by its defining loader");
1173     }
1174     if (vm_annotations) {
1175       THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "vm annotations only allowed for hidden classes");
1176     }
1177     if (flags != STRONG_LOADER_LINK) {
1178       THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(),
1179                      err_msg("invalid flag 0x%x", flags));
1180     }
1181   }
1182 
1183   // Class resolution will get the class name from the .class stream if the name is null.
1184   TempNewSymbol class_name = name == nullptr ? nullptr :
1185        SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_NoClassDefFoundError(),
1186                                            CHECK_NULL);
1187 
1188   Handle protection_domain (THREAD, JNIHandles::resolve(pd));
1189   const char* source = is_nestmate ? host_class->external_name() : "__JVM_LookupDefineClass__";
1190   ClassFileStream st((u1*)buf, len, source);
1191 
1192   InstanceKlass* ik = nullptr;
1193   if (!is_hidden) {
1194     ClassLoadInfo cl_info(protection_domain);
1195     ik = SystemDictionary::resolve_from_stream(&st, class_name,
1196                                                class_loader,
1197                                                cl_info,
1198                                                CHECK_NULL);
1199 
1200     if (log_is_enabled(Debug, class, resolve)) {
1201       trace_class_resolution(ik);
1202     }
1203   } else { // hidden
1204     Handle classData_h(THREAD, JNIHandles::resolve(classData));
1205     ClassLoadInfo cl_info(protection_domain,
1206                           host_class,
1207                           classData_h,
1208                           is_hidden,
1209                           is_strong,
1210                           vm_annotations);
1211     ik = SystemDictionary::resolve_from_stream(&st, class_name,
1212                                                class_loader,
1213                                                cl_info,
1214                                                CHECK_NULL);
1215 
1216     // The hidden class loader data has been artificially been kept alive to
1217     // this point. The mirror and any instances of this class have to keep
1218     // it alive afterwards.
1219     ik->class_loader_data()->dec_keep_alive_ref_count();
1220 
1221     if (is_nestmate && log_is_enabled(Debug, class, nestmates)) {
1222       ModuleEntry* module = ik->module();
1223       const char * module_name = module->is_named() ? module->name()->as_C_string() : UNNAMED_MODULE;
1224       log_debug(class, nestmates)("Dynamic nestmate: %s/%s, nest_host %s, %s",
1225                                   module_name,
1226                                   ik->external_name(),
1227                                   host_class->external_name(),
1228                                   ik->is_hidden() ? "is hidden" : "is not hidden");
1229     }
1230   }
1231 
1232   if ((!is_hidden || is_nestmate) && !Reflection::is_same_class_package(lookup_k, ik)) {
1233     // non-hidden class or nestmate class must be in the same package as the Lookup class
1234     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Lookup class and defined class are in different packages");
1235   }
1236 
1237   if (init) {
1238     ik->initialize(CHECK_NULL);
1239   } else {
1240     ik->link_class(CHECK_NULL);
1241   }
1242 
1243   return (jclass) JNIHandles::make_local(THREAD, ik->java_mirror());
1244 }
1245 
1246 JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd))
1247   return jvm_define_class_common(name, loader, buf, len, pd, nullptr, THREAD);
1248 JVM_END
1249 
1250 /*
1251  * Define a class with the specified lookup class.
1252  *  lookup:  Lookup class
1253  *  name:    the name of the class
1254  *  buf:     class bytes
1255  *  len:     length of class bytes
1256  *  pd:      protection domain
1257  *  init:    initialize the class
1258  *  flags:   properties of the class
1259  *  classData: private static pre-initialized field
1260  */
1261 JVM_ENTRY(jclass, JVM_LookupDefineClass(JNIEnv *env, jclass lookup, const char *name, const jbyte *buf,
1262           jsize len, jobject pd, jboolean initialize, int flags, jobject classData))
1263 
1264   if (lookup == nullptr) {
1265     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Lookup class is null");
1266   }
1267 
1268   assert(buf != nullptr, "buf must not be null");
1269 
1270   return jvm_lookup_define_class(lookup, name, buf, len, pd, initialize, flags, classData, THREAD);
1271 JVM_END
1272 
1273 JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source))
1274 
1275   return jvm_define_class_common(name, loader, buf, len, pd, source, THREAD);
1276 JVM_END
1277 
1278 JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name))
1279   ResourceMark rm(THREAD);
1280 
1281   Handle h_name (THREAD, JNIHandles::resolve_non_null(name));
1282   char* str = java_lang_String::as_utf8_string(h_name());
1283 
1284   // Sanity check, don't expect null
1285   if (str == nullptr) return nullptr;
1286 
1287   // Internalize the string, converting '.' to '/' in string.
1288   char* p = (char*)str;
1289   while (*p != '\0') {
1290     if (*p == '.') {
1291       *p = '/';
1292     }
1293     p++;
1294   }
1295 
1296   const int str_len = (int)(p - str);
1297   if (str_len > Symbol::max_length()) {
1298     // It's impossible to create this class;  the name cannot fit
1299     // into the constant pool.
1300     return nullptr;
1301   }
1302   TempNewSymbol klass_name = SymbolTable::new_symbol(str, str_len);
1303 
1304   // Security Note:
1305   //   The Java level wrapper will perform the necessary security check allowing
1306   //   us to pass the null as the initiating class loader.
1307   Handle h_loader(THREAD, JNIHandles::resolve(loader));
1308   Klass* k = SystemDictionary::find_instance_or_array_klass(THREAD, klass_name, h_loader);
1309 #if INCLUDE_CDS
1310   if (k == nullptr) {
1311     // If the class is not already loaded, try to see if it's in the shared
1312     // archive for the current classloader (h_loader).
1313     k = SystemDictionaryShared::find_or_load_shared_class(klass_name, h_loader, CHECK_NULL);
1314   }
1315 #endif
1316   return (k == nullptr) ? nullptr :
1317             (jclass) JNIHandles::make_local(THREAD, k->java_mirror());
1318 JVM_END
1319 
1320 // Module support //////////////////////////////////////////////////////////////////////////////
1321 
1322 JVM_ENTRY(void, JVM_DefineModule(JNIEnv *env, jobject module, jboolean is_open, jstring version,
1323                                  jstring location, jobjectArray packages))
1324   Handle h_module (THREAD, JNIHandles::resolve(module));
1325   Modules::define_module(h_module, is_open, version, location, packages, CHECK);
1326 JVM_END
1327 
1328 JVM_ENTRY(void, JVM_SetBootLoaderUnnamedModule(JNIEnv *env, jobject module))
1329   Handle h_module (THREAD, JNIHandles::resolve(module));
1330   Modules::set_bootloader_unnamed_module(h_module, CHECK);
1331 JVM_END
1332 
1333 JVM_ENTRY(void, JVM_AddModuleExports(JNIEnv *env, jobject from_module, jstring package, jobject to_module))
1334   Handle h_from_module (THREAD, JNIHandles::resolve(from_module));
1335   Handle h_to_module (THREAD, JNIHandles::resolve(to_module));
1336   Modules::add_module_exports_qualified(h_from_module, package, h_to_module, CHECK);
1337 JVM_END
1338 
1339 JVM_ENTRY(void, JVM_AddModuleExportsToAllUnnamed(JNIEnv *env, jobject from_module, jstring package))
1340   Handle h_from_module (THREAD, JNIHandles::resolve(from_module));
1341   Modules::add_module_exports_to_all_unnamed(h_from_module, package, CHECK);
1342 JVM_END
1343 
1344 JVM_ENTRY(void, JVM_AddModuleExportsToAll(JNIEnv *env, jobject from_module, jstring package))
1345   Handle h_from_module (THREAD, JNIHandles::resolve(from_module));
1346   Modules::add_module_exports(h_from_module, package, Handle(), CHECK);
1347 JVM_END
1348 
1349 JVM_ENTRY (void, JVM_AddReadsModule(JNIEnv *env, jobject from_module, jobject source_module))
1350   Handle h_from_module (THREAD, JNIHandles::resolve(from_module));
1351   Handle h_source_module (THREAD, JNIHandles::resolve(source_module));
1352   Modules::add_reads_module(h_from_module, h_source_module, CHECK);
1353 JVM_END
1354 
1355 JVM_ENTRY(void, JVM_DefineArchivedModules(JNIEnv *env, jobject platform_loader, jobject system_loader))
1356   Handle h_platform_loader (THREAD, JNIHandles::resolve(platform_loader));
1357   Handle h_system_loader (THREAD, JNIHandles::resolve(system_loader));
1358   Modules::define_archived_modules(h_platform_loader, h_system_loader, CHECK);
1359 JVM_END
1360 
1361 // Reflection support //////////////////////////////////////////////////////////////////////////////
1362 
1363 JVM_ENTRY(jstring, JVM_InitClassName(JNIEnv *env, jclass cls))
1364   assert (cls != nullptr, "illegal class");
1365   JvmtiVMObjectAllocEventCollector oam;
1366   ResourceMark rm(THREAD);
1367   HandleMark hm(THREAD);
1368   Handle java_class(THREAD, JNIHandles::resolve(cls));
1369   oop result = java_lang_Class::name(java_class, CHECK_NULL);
1370   return (jstring) JNIHandles::make_local(THREAD, result);
1371 JVM_END
1372 
1373 
1374 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1375   JvmtiVMObjectAllocEventCollector oam;
1376   oop mirror = JNIHandles::resolve_non_null(cls);
1377 
1378   // Special handling for primitive objects
1379   if (java_lang_Class::is_primitive(mirror)) {
1380     // Primitive objects does not have any interfaces
1381     objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1382     return (jobjectArray) JNIHandles::make_local(THREAD, r);
1383   }
1384 
1385   Klass* klass = java_lang_Class::as_Klass(mirror);
1386   // Figure size of result array
1387   int size;
1388   if (klass->is_instance_klass()) {
1389     InstanceKlass* ik = InstanceKlass::cast(klass);
1390     size = ik->local_interfaces()->length();
1391   } else {
1392     assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");
1393     size = 2;
1394   }
1395 
1396   // Allocate result array
1397   objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL);
1398   objArrayHandle result (THREAD, r);
1399   // Fill in result
1400   if (klass->is_instance_klass()) {
1401     // Regular instance klass, fill in all local interfaces
1402     for (int index = 0; index < size; index++) {
1403       InstanceKlass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);
1404       result->obj_at_put(index, k->java_mirror());
1405     }
1406   } else {
1407     // All arrays implement java.lang.Cloneable and java.io.Serializable
1408     result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror());
1409     result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror());
1410   }
1411   return (jobjectArray) JNIHandles::make_local(THREAD, result());
1412 JVM_END
1413 
1414 
1415 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1416   oop mirror = JNIHandles::resolve_non_null(cls);
1417   if (java_lang_Class::is_primitive(mirror)) {
1418     return JNI_FALSE;
1419   }
1420   Klass* k = java_lang_Class::as_Klass(mirror);
1421   return k->is_hidden();
1422 JVM_END
1423 
1424 
1425 JVM_ENTRY(jobject, JVM_FindScopedValueBindings(JNIEnv *env, jclass cls))
1426   ResourceMark rm(THREAD);
1427   GrowableArray<Handle>* local_array = new GrowableArray<Handle>(12);
1428   JvmtiVMObjectAllocEventCollector oam;
1429 
1430   // Iterate through Java frames
1431   vframeStream vfst(thread);
1432   for(; !vfst.at_end(); vfst.next()) {
1433     int loc = -1;
1434     // get method of frame
1435     Method* method = vfst.method();
1436 
1437     Symbol *name = method->name();
1438 
1439     InstanceKlass* holder = method->method_holder();
1440     if (name == vmSymbols::runWith_method_name()) {
1441       if (holder == vmClasses::Thread_klass()
1442           || holder == vmClasses::ScopedValue_Carrier_klass()) {
1443         loc = 1;
1444       }
1445     }
1446 
1447     if (loc != -1) {
1448       javaVFrame *frame = vfst.asJavaVFrame();
1449       StackValueCollection* locals = frame->locals();
1450       StackValue* head_sv = locals->at(loc); // java/lang/ScopedValue$Snapshot
1451       Handle result = head_sv->get_obj();
1452       assert(!head_sv->obj_is_scalar_replaced(), "found scalar-replaced object");
1453       if (result() != nullptr) {
1454         return JNIHandles::make_local(THREAD, result());
1455       }
1456     }
1457   }
1458 
1459   return nullptr;
1460 JVM_END
1461 
1462 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
1463   JvmtiVMObjectAllocEventCollector oam;
1464   // ofClass is a reference to a java_lang_Class object. The mirror object
1465   // of an InstanceKlass
1466   oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1467   if (java_lang_Class::is_primitive(ofMirror) ||
1468       ! java_lang_Class::as_Klass(ofMirror)->is_instance_klass()) {
1469     oop result = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1470     return (jobjectArray)JNIHandles::make_local(THREAD, result);
1471   }
1472 
1473   InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror);
1474   InnerClassesIterator iter(k);
1475 
1476   if (iter.length() == 0) {
1477     // Neither an inner nor outer class
1478     oop result = oopFactory::new_refArray(vmClasses::Class_klass(), 0, CHECK_NULL);
1479     return (jobjectArray)JNIHandles::make_local(THREAD, result);
1480   }
1481 
1482   // find inner class info
1483   constantPoolHandle cp(thread, k->constants());
1484   int length = iter.length();
1485 
1486   // Allocate temp. result array
1487   refArrayOop r = oopFactory::new_refArray(vmClasses::Class_klass(), length / 4, CHECK_NULL);
1488   refArrayHandle result(THREAD, r);
1489   int members = 0;
1490 
1491   for (; !iter.done(); iter.next()) {
1492     int ioff = iter.inner_class_info_index();
1493     int ooff = iter.outer_class_info_index();
1494 
1495     if (ioff != 0 && ooff != 0) {
1496       // Check to see if the name matches the class we're looking for
1497       // before attempting to find the class.
1498       if (cp->klass_name_at_matches(k, ooff)) {
1499         Klass* outer_klass = cp->klass_at(ooff, CHECK_NULL);
1500         if (outer_klass == k) {
1501            Klass* ik = cp->klass_at(ioff, CHECK_NULL);
1502            InstanceKlass* inner_klass = InstanceKlass::cast(ik);
1503 
1504            // Throws an exception if outer klass has not declared k as
1505            // an inner klass
1506            Reflection::check_for_inner_class(k, inner_klass, true, CHECK_NULL);
1507 
1508            result->obj_at_put(members, inner_klass->java_mirror());
1509            members++;
1510         }
1511       }
1512     }
1513   }
1514 
1515   if (members != length) {
1516     // Return array of right length
1517     refArrayOop res = oopFactory::new_refArray(vmClasses::Class_klass(), members, CHECK_NULL);
1518     for(int i = 0; i < members; i++) {
1519       res->obj_at_put(i, result->obj_at(i));
1520     }
1521     return (jobjectArray)JNIHandles::make_local(THREAD, res);
1522   }
1523 
1524   return (jobjectArray)JNIHandles::make_local(THREAD, result());
1525 JVM_END
1526 
1527 
1528 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
1529 {
1530   // ofClass is a reference to a java_lang_Class object.
1531   oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1532   if (java_lang_Class::is_primitive(ofMirror)) {
1533     return nullptr;
1534   }
1535   Klass* klass = java_lang_Class::as_Klass(ofMirror);
1536   if (!klass->is_instance_klass()) {
1537     return nullptr;
1538   }
1539 
1540   bool inner_is_member = false;
1541   Klass* outer_klass
1542     = InstanceKlass::cast(klass)->compute_enclosing_class(&inner_is_member, CHECK_NULL);
1543   if (outer_klass == nullptr)  return nullptr;  // already a top-level class
1544   if (!inner_is_member)  return nullptr;     // a hidden class (inside a method)
1545   return (jclass) JNIHandles::make_local(THREAD, outer_klass->java_mirror());
1546 }
1547 JVM_END
1548 
1549 JVM_ENTRY(jstring, JVM_GetSimpleBinaryName(JNIEnv *env, jclass cls))
1550 {
1551   oop mirror = JNIHandles::resolve_non_null(cls);
1552   if (java_lang_Class::is_primitive(mirror)) {
1553     return nullptr;
1554   }
1555   Klass* klass = java_lang_Class::as_Klass(mirror);
1556   if (!klass->is_instance_klass()) {
1557     return nullptr;
1558   }
1559   InstanceKlass* k = InstanceKlass::cast(klass);
1560   int ooff = 0, noff = 0;
1561   if (k->find_inner_classes_attr(&ooff, &noff, THREAD)) {
1562     if (noff != 0) {
1563       constantPoolHandle i_cp(thread, k->constants());
1564       Symbol* name = i_cp->symbol_at(noff);
1565       Handle str = java_lang_String::create_from_symbol(name, CHECK_NULL);
1566       return (jstring) JNIHandles::make_local(THREAD, str());
1567     }
1568   }
1569   return nullptr;
1570 }
1571 JVM_END
1572 
1573 JVM_ENTRY(jstring, JVM_GetClassSignature(JNIEnv *env, jclass cls))
1574   assert (cls != nullptr, "illegal class");
1575   JvmtiVMObjectAllocEventCollector oam;
1576   ResourceMark rm(THREAD);
1577   oop mirror = JNIHandles::resolve_non_null(cls);
1578   // Return null for arrays and primitives
1579   if (!java_lang_Class::is_primitive(mirror)) {
1580     Klass* k = java_lang_Class::as_Klass(mirror);
1581     if (k->is_instance_klass()) {
1582       Symbol* sym = InstanceKlass::cast(k)->generic_signature();
1583       if (sym == nullptr) return nullptr;
1584       Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
1585       return (jstring) JNIHandles::make_local(THREAD, str());
1586     }
1587   }
1588   return nullptr;
1589 JVM_END
1590 
1591 
1592 JVM_ENTRY(jbyteArray, JVM_GetClassAnnotations(JNIEnv *env, jclass cls))
1593   assert (cls != nullptr, "illegal class");
1594   oop mirror = JNIHandles::resolve_non_null(cls);
1595   // Return null for arrays and primitives
1596   if (!java_lang_Class::is_primitive(mirror)) {
1597     Klass* k = java_lang_Class::as_Klass(mirror);
1598     if (k->is_instance_klass()) {
1599       typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL);
1600       return (jbyteArray) JNIHandles::make_local(THREAD, a);
1601     }
1602   }
1603   return nullptr;
1604 JVM_END
1605 
1606 
1607 static bool jvm_get_field_common(jobject field, fieldDescriptor& fd) {
1608   // some of this code was adapted from from jni_FromReflectedField
1609 
1610   oop reflected = JNIHandles::resolve_non_null(field);
1611   oop mirror    = java_lang_reflect_Field::clazz(reflected);
1612   int slot      = java_lang_reflect_Field::slot(reflected);
1613   int modifiers = java_lang_reflect_Field::modifiers(reflected);
1614 
1615   InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
1616   int offset = ik->field_offset(slot);
1617 
1618   if (modifiers & JVM_ACC_STATIC) {
1619     // for static fields we only look in the current class
1620     if (!ik->find_local_field_from_offset(offset, true, &fd)) {
1621       assert(false, "cannot find static field");
1622       return false;
1623     }
1624   } else {
1625     // for instance fields we start with the current class and work
1626     // our way up through the superclass chain
1627     if (!ik->find_field_from_offset(offset, false, &fd)) {
1628       assert(false, "cannot find instance field");
1629       return false;
1630     }
1631   }
1632   return true;
1633 }
1634 
1635 static Method* jvm_get_method_common(jobject method) {
1636   // some of this code was adapted from from jni_FromReflectedMethod
1637 
1638   oop reflected = JNIHandles::resolve_non_null(method);
1639   oop mirror    = nullptr;
1640   int slot      = 0;
1641 
1642   if (reflected->klass() == vmClasses::reflect_Constructor_klass()) {
1643     mirror = java_lang_reflect_Constructor::clazz(reflected);
1644     slot   = java_lang_reflect_Constructor::slot(reflected);
1645   } else {
1646     assert(reflected->klass() == vmClasses::reflect_Method_klass(),
1647            "wrong type");
1648     mirror = java_lang_reflect_Method::clazz(reflected);
1649     slot   = java_lang_reflect_Method::slot(reflected);
1650   }
1651   InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
1652 
1653   Method* m = ik->method_with_idnum(slot);
1654   assert(m != nullptr, "cannot find method");
1655   return m;  // caller has to deal with null in product mode
1656 }
1657 
1658 /* Type use annotations support (JDK 1.8) */
1659 
1660 JVM_ENTRY(jbyteArray, JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls))
1661   assert (cls != nullptr, "illegal class");
1662   ResourceMark rm(THREAD);
1663   // Return null for arrays and primitives
1664   if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
1665     Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
1666     if (k->is_instance_klass()) {
1667       AnnotationArray* type_annotations = InstanceKlass::cast(k)->class_type_annotations();
1668       if (type_annotations != nullptr) {
1669         typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL);
1670         return (jbyteArray) JNIHandles::make_local(THREAD, a);
1671       }
1672     }
1673   }
1674   return nullptr;
1675 JVM_END
1676 
1677 JVM_ENTRY(jbyteArray, JVM_GetMethodTypeAnnotations(JNIEnv *env, jobject method))
1678   assert (method != nullptr, "illegal method");
1679   // method is a handle to a java.lang.reflect.Method object
1680   Method* m = jvm_get_method_common(method);
1681   if (m == nullptr) {
1682     return nullptr;
1683   }
1684 
1685   AnnotationArray* type_annotations = m->type_annotations();
1686   if (type_annotations != nullptr) {
1687     typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL);
1688     return (jbyteArray) JNIHandles::make_local(THREAD, a);
1689   }
1690 
1691   return nullptr;
1692 JVM_END
1693 
1694 JVM_ENTRY(jbyteArray, JVM_GetFieldTypeAnnotations(JNIEnv *env, jobject field))
1695   assert (field != nullptr, "illegal field");
1696   fieldDescriptor fd;
1697   bool gotFd = jvm_get_field_common(field, fd);
1698   if (!gotFd) {
1699     return nullptr;
1700   }
1701 
1702   return (jbyteArray) JNIHandles::make_local(THREAD, Annotations::make_java_array(fd.type_annotations(), THREAD));
1703 JVM_END
1704 
1705 static void bounds_check(const constantPoolHandle& cp, jint index, TRAPS) {
1706   if (!cp->is_within_bounds(index)) {
1707     THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Constant pool index out of bounds");
1708   }
1709 }
1710 
1711 JVM_ENTRY(jobjectArray, JVM_GetMethodParameters(JNIEnv *env, jobject method))
1712 {
1713   // method is a handle to a java.lang.reflect.Method object
1714   Method* method_ptr = jvm_get_method_common(method);
1715   methodHandle mh (THREAD, method_ptr);
1716   Handle reflected_method (THREAD, JNIHandles::resolve_non_null(method));
1717   const int num_params = mh->method_parameters_length();
1718 
1719   if (num_params < 0) {
1720     // A -1 return value from method_parameters_length means there is no
1721     // parameter data.  Return null to indicate this to the reflection
1722     // API.
1723     assert(num_params == -1, "num_params should be -1 if it is less than zero");
1724     return (jobjectArray)nullptr;
1725   } else {
1726     // Otherwise, we return something up to reflection, even if it is
1727     // a zero-length array.  Why?  Because in some cases this can
1728     // trigger a MalformedParametersException.
1729 
1730     // make sure all the symbols are properly formatted
1731     for (int i = 0; i < num_params; i++) {
1732       MethodParametersElement* params = mh->method_parameters_start();
1733       int index = params[i].name_cp_index;
1734       constantPoolHandle cp(THREAD, mh->constants());
1735       bounds_check(cp, index, CHECK_NULL);
1736 
1737       if (0 != index && !mh->constants()->tag_at(index).is_utf8()) {
1738         THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(),
1739                        "Wrong type at constant pool index");
1740       }
1741 
1742     }
1743 
1744     objArrayOop result_oop = oopFactory::new_objArray(vmClasses::reflect_Parameter_klass(), num_params, CHECK_NULL);
1745     objArrayHandle result (THREAD, result_oop);
1746 
1747     for (int i = 0; i < num_params; i++) {
1748       MethodParametersElement* params = mh->method_parameters_start();
1749       // For a 0 index, give a null symbol
1750       Symbol* sym = 0 != params[i].name_cp_index ?
1751         mh->constants()->symbol_at(params[i].name_cp_index) : nullptr;
1752       int flags = params[i].flags;
1753       oop param = Reflection::new_parameter(reflected_method, i, sym,
1754                                             flags, CHECK_NULL);
1755       result->obj_at_put(i, param);
1756     }
1757     return (jobjectArray)JNIHandles::make_local(THREAD, result());
1758   }
1759 }
1760 JVM_END
1761 
1762 // New (JDK 1.4) reflection implementation /////////////////////////////////////
1763 
1764 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1765 {
1766   JvmtiVMObjectAllocEventCollector oam;
1767 
1768   oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1769   // Exclude primitive types and array types
1770   if (java_lang_Class::is_primitive(ofMirror) ||
1771       java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1772     // Return empty array
1773     oop res = oopFactory::new_objArray(vmClasses::reflect_Field_klass(), 0, CHECK_NULL);
1774     return (jobjectArray) JNIHandles::make_local(THREAD, res);
1775   }
1776 
1777   InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror);
1778   constantPoolHandle cp(THREAD, k->constants());
1779 
1780   // Ensure class is linked
1781   k->link_class(CHECK_NULL);
1782 
1783   // Allocate result
1784   int num_fields;
1785 
1786   if (publicOnly) {
1787     num_fields = 0;
1788     for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
1789       if (fs.access_flags().is_public()) ++num_fields;
1790     }
1791   } else {
1792     num_fields = k->java_fields_count();
1793   }
1794 
1795   objArrayOop r = oopFactory::new_objArray(vmClasses::reflect_Field_klass(), num_fields, CHECK_NULL);
1796   objArrayHandle result (THREAD, r);
1797 
1798   int out_idx = 0;
1799   fieldDescriptor fd;
1800   for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
1801     if (!publicOnly || fs.access_flags().is_public()) {
1802       fd.reinitialize(k, fs.to_FieldInfo());
1803       oop field = Reflection::new_field(&fd, CHECK_NULL);
1804       result->obj_at_put(out_idx, field);
1805       ++out_idx;
1806     }
1807   }
1808   assert(out_idx == num_fields, "just checking");
1809   return (jobjectArray) JNIHandles::make_local(THREAD, result());
1810 }
1811 JVM_END
1812 
1813 // A class is a record if and only if it is final and a direct subclass of
1814 // java.lang.Record and has a Record attribute; otherwise, it is not a record.
1815 JVM_ENTRY(jboolean, JVM_IsRecord(JNIEnv *env, jclass cls))
1816 {
1817   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1818   if (k != nullptr && k->is_instance_klass()) {
1819     InstanceKlass* ik = InstanceKlass::cast(k);
1820     return ik->is_record();
1821   } else {
1822     return false;
1823   }
1824 }
1825 JVM_END
1826 
1827 // Returns an array containing the components of the Record attribute,
1828 // or null if the attribute is not present.
1829 //
1830 // Note that this function returns the components of the Record attribute
1831 // even if the class is not a record.
1832 JVM_ENTRY(jobjectArray, JVM_GetRecordComponents(JNIEnv* env, jclass ofClass))
1833 {
1834   InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(ofClass));
1835 
1836   Array<RecordComponent*>* components = ik->record_components();
1837   if (components != nullptr) {
1838     JvmtiVMObjectAllocEventCollector oam;
1839     constantPoolHandle cp(THREAD, ik->constants());
1840     int length = components->length();
1841     assert(length >= 0, "unexpected record_components length");
1842     objArrayOop record_components =
1843       oopFactory::new_objArray(vmClasses::RecordComponent_klass(), length, CHECK_NULL);
1844     objArrayHandle components_h (THREAD, record_components);
1845 
1846     for (int x = 0; x < length; x++) {
1847       RecordComponent* component = components->at(x);
1848       assert(component != nullptr, "unexpected null record component");
1849       oop component_oop = java_lang_reflect_RecordComponent::create(ik, component, CHECK_NULL);
1850       components_h->obj_at_put(x, component_oop);
1851     }
1852     return (jobjectArray)JNIHandles::make_local(THREAD, components_h());
1853   }
1854 
1855   return nullptr;
1856 }
1857 JVM_END
1858 
1859 static jobjectArray get_class_declared_methods_helper(
1860                                   JNIEnv *env,
1861                                   jclass ofClass, jboolean publicOnly,
1862                                   bool want_constructor,
1863                                   Klass* klass, TRAPS) {
1864 
1865   JvmtiVMObjectAllocEventCollector oam;
1866 
1867   oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1868   // Exclude primitive types and array types
1869   if (java_lang_Class::is_primitive(ofMirror)
1870       || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1871     // Return empty array
1872     oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1873     return (jobjectArray) JNIHandles::make_local(THREAD, res);
1874   }
1875 
1876   InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror);
1877 
1878   // Ensure class is linked
1879   k->link_class(CHECK_NULL);
1880 
1881   Array<Method*>* methods = k->methods();
1882   int methods_length = methods->length();
1883 
1884   // Save original method_idnum in case of redefinition, which can change
1885   // the idnum of obsolete methods.  The new method will have the same idnum
1886   // but if we refresh the methods array, the counts will be wrong.
1887   ResourceMark rm(THREAD);
1888   GrowableArray<int>* idnums = new GrowableArray<int>(methods_length);
1889   int num_methods = 0;
1890 
1891   // Select methods matching the criteria.
1892   for (int i = 0; i < methods_length; i++) {
1893     Method* method = methods->at(i);
1894     if (want_constructor && !method->is_object_constructor()) {
1895       continue;
1896     }
1897     if (!want_constructor &&
1898         (method->is_object_constructor() || method->is_class_initializer() ||
1899          method->is_overpass())) {
1900       continue;
1901     }
1902     if (publicOnly && !method->is_public()) {
1903       continue;
1904     }
1905     idnums->push(method->method_idnum());
1906     ++num_methods;
1907   }
1908 
1909   // Allocate result
1910   objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1911   objArrayHandle result (THREAD, r);
1912 
1913   // Now just put the methods that we selected above, but go by their idnum
1914   // in case of redefinition.  The methods can be redefined at any safepoint,
1915   // so above when allocating the oop array and below when creating reflect
1916   // objects.
1917   for (int i = 0; i < num_methods; i++) {
1918     methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1919     if (method.is_null()) {
1920       // Method may have been deleted and seems this API can handle null
1921       // Otherwise should probably put a method that throws NSME
1922       result->obj_at_put(i, nullptr);
1923     } else {
1924       oop m;
1925       if (want_constructor) {
1926         assert(method->is_object_constructor(), "must be");
1927         m = Reflection::new_constructor(method, CHECK_NULL);
1928       } else {
1929         m = Reflection::new_method(method, false, CHECK_NULL);
1930       }
1931       result->obj_at_put(i, m);
1932     }
1933   }
1934 
1935   return (jobjectArray) JNIHandles::make_local(THREAD, result());
1936 }
1937 
1938 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1939 {
1940   return get_class_declared_methods_helper(env, ofClass, publicOnly,
1941                                            /*want_constructor*/ false,
1942                                            vmClasses::reflect_Method_klass(), THREAD);
1943 }
1944 JVM_END
1945 
1946 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1947 {
1948   return get_class_declared_methods_helper(env, ofClass, publicOnly,
1949                                            /*want_constructor*/ true,
1950                                            vmClasses::reflect_Constructor_klass(), THREAD);
1951 }
1952 JVM_END
1953 
1954 JVM_ENTRY(jboolean, JVM_AreNestMates(JNIEnv *env, jclass current, jclass member))
1955 {
1956   InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current));
1957   InstanceKlass* m = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(member));
1958   return c->has_nestmate_access_to(m, THREAD);
1959 }
1960 JVM_END
1961 
1962 JVM_ENTRY(jclass, JVM_GetNestHost(JNIEnv* env, jclass current))
1963 {
1964   // current is not a primitive or array class
1965   InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current));
1966   InstanceKlass* host = c->nest_host(THREAD);
1967   return (jclass) (host == nullptr ? nullptr :
1968                    JNIHandles::make_local(THREAD, host->java_mirror()));
1969 }
1970 JVM_END
1971 
1972 JVM_ENTRY(jobjectArray, JVM_GetNestMembers(JNIEnv* env, jclass current))
1973 {
1974   // current is not a primitive or array class
1975   ResourceMark rm(THREAD);
1976   InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current));
1977   InstanceKlass* host = c->nest_host(THREAD);
1978 
1979   log_trace(class, nestmates)("Calling GetNestMembers for type %s with nest-host %s",
1980                               c->external_name(), host->external_name());
1981   {
1982     JvmtiVMObjectAllocEventCollector oam;
1983     Array<u2>* members = host->nest_members();
1984     int length = members == nullptr ? 0 : members->length();
1985 
1986     log_trace(class, nestmates)(" - host has %d listed nest members", length);
1987 
1988     // nest host is first in the array so make it one bigger
1989     refArrayOop r = oopFactory::new_refArray(vmClasses::Class_klass(), length + 1, CHECK_NULL);
1990     refArrayHandle result(THREAD, r);

1991     result->obj_at_put(0, host->java_mirror());
1992     if (length != 0) {
1993       int count = 0;
1994       for (int i = 0; i < length; i++) {
1995         int cp_index = members->at(i);
1996         Klass* k = host->constants()->klass_at(cp_index, THREAD);
1997         if (HAS_PENDING_EXCEPTION) {
1998           if (PENDING_EXCEPTION->is_a(vmClasses::VirtualMachineError_klass())) {
1999             return nullptr; // propagate VMEs
2000           }
2001           if (log_is_enabled(Trace, class, nestmates)) {
2002             stringStream ss;
2003             char* target_member_class = host->constants()->klass_name_at(cp_index)->as_C_string();
2004             ss.print(" - resolution of nest member %s failed: ", target_member_class);
2005             java_lang_Throwable::print(PENDING_EXCEPTION, &ss);
2006             log_trace(class, nestmates)("%s", ss.as_string());
2007           }
2008           CLEAR_PENDING_EXCEPTION;
2009           continue;
2010         }
2011         if (k->is_instance_klass()) {
2012           InstanceKlass* ik = InstanceKlass::cast(k);
2013           InstanceKlass* nest_host_k = ik->nest_host(CHECK_NULL);
2014           if (nest_host_k == host) {
2015             result->obj_at_put(count+1, k->java_mirror());
2016             count++;
2017             log_trace(class, nestmates)(" - [%d] = %s", count, ik->external_name());
2018           } else {
2019             log_trace(class, nestmates)(" - skipping member %s with different host %s",
2020                                         ik->external_name(), nest_host_k->external_name());
2021           }
2022         } else {
2023           log_trace(class, nestmates)(" - skipping member %s that is not an instance class",
2024                                       k->external_name());
2025         }
2026       }
2027       if (count < length) {
2028         // we had invalid entries so we need to compact the array
2029         log_trace(class, nestmates)(" - compacting array from length %d to %d",
2030                                     length + 1, count + 1);
2031 
2032         objArrayOop r2 = oopFactory::new_objArray(vmClasses::Class_klass(),
2033                                                   count + 1, CHECK_NULL);
2034         objArrayHandle result2(THREAD, r2);
2035         for (int i = 0; i < count + 1; i++) {
2036           result2->obj_at_put(i, result->obj_at(i));
2037         }
2038         return (jobjectArray)JNIHandles::make_local(THREAD, result2());
2039       }
2040     }
2041     else {
2042       assert(host == c || c->is_hidden(), "must be singleton nest or dynamic nestmate");
2043     }
2044     return (jobjectArray)JNIHandles::make_local(THREAD, result());
2045   }
2046 }
2047 JVM_END
2048 
2049 JVM_ENTRY(jobjectArray, JVM_GetPermittedSubclasses(JNIEnv* env, jclass current))
2050 {
2051   oop mirror = JNIHandles::resolve_non_null(current);
2052   assert(!java_lang_Class::is_primitive(mirror), "should not be");
2053   InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
2054 
2055   ResourceMark rm(THREAD);
2056   log_trace(class, sealed)("Calling GetPermittedSubclasses for %s type %s",
2057                            ik->is_sealed() ? "sealed" : "non-sealed", ik->external_name());
2058   if (ik->is_sealed()) {
2059     JvmtiVMObjectAllocEventCollector oam;
2060     Array<u2>* subclasses = ik->permitted_subclasses();
2061     int length = subclasses->length();
2062 
2063     log_trace(class, sealed)(" - sealed class has %d permitted subclasses", length);
2064 
2065     refArrayOop r = oopFactory::new_refArray(vmClasses::Class_klass(), length, CHECK_NULL);
2066     refArrayHandle result(THREAD, r);

2067     int count = 0;
2068     for (int i = 0; i < length; i++) {
2069       int cp_index = subclasses->at(i);
2070       Klass* k = ik->constants()->klass_at(cp_index, THREAD);
2071       if (HAS_PENDING_EXCEPTION) {
2072         if (PENDING_EXCEPTION->is_a(vmClasses::VirtualMachineError_klass())) {
2073           return nullptr; // propagate VMEs
2074         }
2075         if (log_is_enabled(Trace, class, sealed)) {
2076           stringStream ss;
2077           char* permitted_subclass = ik->constants()->klass_name_at(cp_index)->as_C_string();
2078           ss.print(" - resolution of permitted subclass %s failed: ", permitted_subclass);
2079           java_lang_Throwable::print(PENDING_EXCEPTION, &ss);
2080           log_trace(class, sealed)("%s", ss.as_string());
2081         }
2082 
2083         CLEAR_PENDING_EXCEPTION;
2084         continue;
2085       }
2086       if (k->is_instance_klass()) {
2087         result->obj_at_put(count++, k->java_mirror());
2088         log_trace(class, sealed)(" - [%d] = %s", count, k->external_name());
2089       }
2090     }
2091     if (count < length) {
2092       // we had invalid entries so we need to compact the array
2093       objArrayOop r2 = oopFactory::new_objArray(vmClasses::Class_klass(),
2094                                                 count, CHECK_NULL);
2095       objArrayHandle result2(THREAD, r2);
2096       for (int i = 0; i < count; i++) {
2097         result2->obj_at_put(i, result->obj_at(i));
2098       }
2099       return (jobjectArray)JNIHandles::make_local(THREAD, result2());
2100     }
2101     return (jobjectArray)JNIHandles::make_local(THREAD, result());
2102   } else {
2103     return nullptr;
2104   }
2105 }
2106 JVM_END
2107 
2108 // Constant pool access //////////////////////////////////////////////////////////
2109 
2110 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv *env, jclass cls))
2111 {
2112   JvmtiVMObjectAllocEventCollector oam;
2113   oop mirror = JNIHandles::resolve_non_null(cls);
2114   // Return null for primitives and arrays
2115   if (!java_lang_Class::is_primitive(mirror)) {
2116     Klass* k = java_lang_Class::as_Klass(mirror);
2117     if (k->is_instance_klass()) {
2118       InstanceKlass* k_h = InstanceKlass::cast(k);
2119       Handle jcp = reflect_ConstantPool::create(CHECK_NULL);
2120       reflect_ConstantPool::set_cp(jcp(), k_h->constants());
2121       return JNIHandles::make_local(THREAD, jcp());
2122     }
2123   }
2124   return nullptr;
2125 }
2126 JVM_END
2127 
2128 
2129 JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject obj))
2130 {
2131   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2132   return cp->length();
2133 }
2134 JVM_END
2135 
2136 
2137 JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject obj, jint index))
2138 {
2139   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2140   bounds_check(cp, index, CHECK_NULL);
2141   constantTag tag = cp->tag_at(index);
2142   if (!tag.is_klass() && !tag.is_unresolved_klass()) {
2143     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2144   }
2145   Klass* k = cp->klass_at(index, CHECK_NULL);
2146   return (jclass) JNIHandles::make_local(THREAD, k->java_mirror());
2147 }
2148 JVM_END
2149 
2150 JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject obj, jint index))
2151 {
2152   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2153   bounds_check(cp, index, CHECK_NULL);
2154   constantTag tag = cp->tag_at(index);
2155   if (!tag.is_klass() && !tag.is_unresolved_klass()) {
2156     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2157   }
2158   Klass* k = ConstantPool::klass_at_if_loaded(cp, index);
2159   if (k == nullptr) return nullptr;
2160   return (jclass) JNIHandles::make_local(THREAD, k->java_mirror());
2161 }
2162 JVM_END
2163 
2164 static jobject get_method_at_helper(const constantPoolHandle& cp, jint index, bool force_resolution, TRAPS) {
2165   constantTag tag = cp->tag_at(index);
2166   if (!tag.is_method() && !tag.is_interface_method()) {
2167     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2168   }
2169   int klass_ref  = cp->uncached_klass_ref_index_at(index);
2170   Klass* k_o;
2171   if (force_resolution) {
2172     k_o = cp->klass_at(klass_ref, CHECK_NULL);
2173   } else {
2174     k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2175     if (k_o == nullptr) return nullptr;
2176   }
2177   InstanceKlass* k = InstanceKlass::cast(k_o);
2178   Symbol* name = cp->uncached_name_ref_at(index);
2179   Symbol* sig  = cp->uncached_signature_ref_at(index);
2180   methodHandle m (THREAD, k->find_method(name, sig));
2181   if (m.is_null()) {
2182     THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
2183   }
2184   oop method;
2185   if (m->is_object_constructor()) {
2186     method = Reflection::new_constructor(m, CHECK_NULL);
2187   } else {

2188     method = Reflection::new_method(m, true, CHECK_NULL);
2189   }
2190   return JNIHandles::make_local(THREAD, method);
2191 }
2192 
2193 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jint index))
2194 {
2195   JvmtiVMObjectAllocEventCollector oam;
2196   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2197   bounds_check(cp, index, CHECK_NULL);
2198   jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
2199   return res;
2200 }
2201 JVM_END
2202 
2203 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jint index))
2204 {
2205   JvmtiVMObjectAllocEventCollector oam;
2206   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2207   bounds_check(cp, index, CHECK_NULL);
2208   jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);
2209   return res;
2210 }
2211 JVM_END
2212 
2213 static jobject get_field_at_helper(constantPoolHandle cp, jint index, bool force_resolution, TRAPS) {
2214   constantTag tag = cp->tag_at(index);
2215   if (!tag.is_field()) {
2216     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2217   }
2218   int klass_ref  = cp->uncached_klass_ref_index_at(index);
2219   Klass* k_o;
2220   if (force_resolution) {
2221     k_o = cp->klass_at(klass_ref, CHECK_NULL);
2222   } else {
2223     k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2224     if (k_o == nullptr) return nullptr;
2225   }
2226   InstanceKlass* k = InstanceKlass::cast(k_o);
2227   Symbol* name = cp->uncached_name_ref_at(index);
2228   Symbol* sig  = cp->uncached_signature_ref_at(index);
2229   fieldDescriptor fd;
2230   Klass* target_klass = k->find_field(name, sig, &fd);
2231   if (target_klass == nullptr) {
2232     THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class");
2233   }
2234   oop field = Reflection::new_field(&fd, CHECK_NULL);
2235   return JNIHandles::make_local(THREAD, field);
2236 }
2237 
2238 JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject obj, jint index))
2239 {
2240   JvmtiVMObjectAllocEventCollector oam;
2241   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2242   bounds_check(cp, index, CHECK_NULL);
2243   jobject res = get_field_at_helper(cp, index, true, CHECK_NULL);
2244   return res;
2245 }
2246 JVM_END
2247 
2248 JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject obj, jint index))
2249 {
2250   JvmtiVMObjectAllocEventCollector oam;
2251   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2252   bounds_check(cp, index, CHECK_NULL);
2253   jobject res = get_field_at_helper(cp, index, false, CHECK_NULL);
2254   return res;
2255 }
2256 JVM_END
2257 
2258 JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject obj, jint index))
2259 {
2260   JvmtiVMObjectAllocEventCollector oam;
2261   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2262   bounds_check(cp, index, CHECK_NULL);
2263   constantTag tag = cp->tag_at(index);
2264   if (!tag.is_field_or_method()) {
2265     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2266   }
2267   int klass_ref = cp->uncached_klass_ref_index_at(index);
2268   Symbol*  klass_name  = cp->klass_name_at(klass_ref);
2269   Symbol*  member_name = cp->uncached_name_ref_at(index);
2270   Symbol*  member_sig  = cp->uncached_signature_ref_at(index);
2271   objArrayOop  dest_o = oopFactory::new_objArray(vmClasses::String_klass(), 3, CHECK_NULL);
2272   objArrayHandle dest(THREAD, dest_o);
2273   Handle str = java_lang_String::create_from_symbol(klass_name, CHECK_NULL);
2274   dest->obj_at_put(0, str());
2275   str = java_lang_String::create_from_symbol(member_name, CHECK_NULL);
2276   dest->obj_at_put(1, str());
2277   str = java_lang_String::create_from_symbol(member_sig, CHECK_NULL);
2278   dest->obj_at_put(2, str());
2279   return (jobjectArray) JNIHandles::make_local(THREAD, dest());
2280 }
2281 JVM_END
2282 
2283 JVM_ENTRY(jint, JVM_ConstantPoolGetClassRefIndexAt(JNIEnv *env, jobject obj, jint index))
2284 {
2285   JvmtiVMObjectAllocEventCollector oam;
2286   constantPoolHandle cp(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2287   bounds_check(cp, index, CHECK_0);
2288   constantTag tag = cp->tag_at(index);
2289   if (!tag.is_field_or_method()) {
2290     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2291   }
2292   return (jint) cp->uncached_klass_ref_index_at(index);
2293 }
2294 JVM_END
2295 
2296 JVM_ENTRY(jint, JVM_ConstantPoolGetNameAndTypeRefIndexAt(JNIEnv *env, jobject obj, jint index))
2297 {
2298   JvmtiVMObjectAllocEventCollector oam;
2299   constantPoolHandle cp(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2300   bounds_check(cp, index, CHECK_0);
2301   constantTag tag = cp->tag_at(index);
2302   if (!tag.is_invoke_dynamic() && !tag.is_field_or_method()) {
2303     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2304   }
2305   return (jint) cp->uncached_name_and_type_ref_index_at(index);
2306 }
2307 JVM_END
2308 
2309 JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetNameAndTypeRefInfoAt(JNIEnv *env, jobject obj, jint index))
2310 {
2311   JvmtiVMObjectAllocEventCollector oam;
2312   constantPoolHandle cp(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2313   bounds_check(cp, index, CHECK_NULL);
2314   constantTag tag = cp->tag_at(index);
2315   if (!tag.is_name_and_type()) {
2316     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2317   }
2318   Symbol* member_name = cp->symbol_at(cp->name_ref_index_at(index));
2319   Symbol* member_sig = cp->symbol_at(cp->signature_ref_index_at(index));
2320   objArrayOop dest_o = oopFactory::new_objArray(vmClasses::String_klass(), 2, CHECK_NULL);
2321   objArrayHandle dest(THREAD, dest_o);
2322   Handle str = java_lang_String::create_from_symbol(member_name, CHECK_NULL);
2323   dest->obj_at_put(0, str());
2324   str = java_lang_String::create_from_symbol(member_sig, CHECK_NULL);
2325   dest->obj_at_put(1, str());
2326   return (jobjectArray) JNIHandles::make_local(THREAD, dest());
2327 }
2328 JVM_END
2329 
2330 JVM_ENTRY(jint, JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject obj, jint index))
2331 {
2332   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2333   bounds_check(cp, index, CHECK_0);
2334   constantTag tag = cp->tag_at(index);
2335   if (!tag.is_int()) {
2336     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2337   }
2338   return cp->int_at(index);
2339 }
2340 JVM_END
2341 
2342 JVM_ENTRY(jlong, JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject obj, jint index))
2343 {
2344   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2345   bounds_check(cp, index, CHECK_(0L));
2346   constantTag tag = cp->tag_at(index);
2347   if (!tag.is_long()) {
2348     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2349   }
2350   return cp->long_at(index);
2351 }
2352 JVM_END
2353 
2354 JVM_ENTRY(jfloat, JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject obj, jint index))
2355 {
2356   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2357   bounds_check(cp, index, CHECK_(0.0f));
2358   constantTag tag = cp->tag_at(index);
2359   if (!tag.is_float()) {
2360     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2361   }
2362   return cp->float_at(index);
2363 }
2364 JVM_END
2365 
2366 JVM_ENTRY(jdouble, JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject obj, jint index))
2367 {
2368   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2369   bounds_check(cp, index, CHECK_(0.0));
2370   constantTag tag = cp->tag_at(index);
2371   if (!tag.is_double()) {
2372     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2373   }
2374   return cp->double_at(index);
2375 }
2376 JVM_END
2377 
2378 JVM_ENTRY(jstring, JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject obj, jint index))
2379 {
2380   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2381   bounds_check(cp, index, CHECK_NULL);
2382   constantTag tag = cp->tag_at(index);
2383   if (!tag.is_string()) {
2384     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2385   }
2386   oop str = cp->string_at(index, CHECK_NULL);
2387   return (jstring) JNIHandles::make_local(THREAD, str);
2388 }
2389 JVM_END
2390 
2391 JVM_ENTRY(jstring, JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject obj, jint index))
2392 {
2393   JvmtiVMObjectAllocEventCollector oam;
2394   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2395   bounds_check(cp, index, CHECK_NULL);
2396   constantTag tag = cp->tag_at(index);
2397   if (!tag.is_symbol()) {
2398     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2399   }
2400   Symbol* sym = cp->symbol_at(index);
2401   Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
2402   return (jstring) JNIHandles::make_local(THREAD, str());
2403 }
2404 JVM_END
2405 
2406 JVM_ENTRY(jbyte, JVM_ConstantPoolGetTagAt(JNIEnv *env, jobject obj, jint index))
2407 {
2408   constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2409   bounds_check(cp, index, CHECK_0);
2410   constantTag tag = cp->tag_at(index);
2411   jbyte result = tag.value();
2412   // If returned tag values are not from the JVM spec, e.g. tags from 100 to 105,
2413   // they are changed to the corresponding tags from the JVM spec, so that java code in
2414   // sun.reflect.ConstantPool will return only tags from the JVM spec, not internal ones.
2415   if (tag.is_klass_or_reference()) {
2416       result = JVM_CONSTANT_Class;
2417   } else if (tag.is_string_index()) {
2418       result = JVM_CONSTANT_String;
2419   } else if (tag.is_method_type_in_error()) {
2420       result = JVM_CONSTANT_MethodType;
2421   } else if (tag.is_method_handle_in_error()) {
2422       result = JVM_CONSTANT_MethodHandle;
2423   } else if (tag.is_dynamic_constant_in_error()) {
2424       result = JVM_CONSTANT_Dynamic;
2425   }
2426   return result;
2427 }
2428 JVM_END
2429 
2430 // Assertion support. //////////////////////////////////////////////////////////
2431 
2432 JVM_ENTRY(jboolean, JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls))
2433   assert(cls != nullptr, "bad class");
2434 
2435   oop r = JNIHandles::resolve(cls);
2436   assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed");
2437   if (java_lang_Class::is_primitive(r)) return false;
2438 
2439   Klass* k = java_lang_Class::as_Klass(r);
2440   assert(k->is_instance_klass(), "must be an instance klass");
2441   if (!k->is_instance_klass()) return false;
2442 
2443   ResourceMark rm(THREAD);
2444   const char* name = k->name()->as_C_string();
2445   bool system_class = k->class_loader() == nullptr;
2446   return JavaAssertions::enabled(name, system_class);
2447 
2448 JVM_END
2449 
2450 
2451 // Return a new AssertionStatusDirectives object with the fields filled in with
2452 // command-line assertion arguments (i.e., -ea, -da).
2453 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2454   JvmtiVMObjectAllocEventCollector oam;
2455   oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2456   return JNIHandles::make_local(THREAD, asd);
2457 JVM_END
2458 
2459 // Verification ////////////////////////////////////////////////////////////////////////////////
2460 
2461 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2462 
2463 // RedefineClasses support: bug 6214132 caused verification to fail.
2464 // All functions from this section, unless noted otherwise, should call the functions
2465 //   get_klass_considering_redefinition(), or
2466 //   get_instance_klass_considering_redefinition()
2467 // These functions return JvmtiThreadState::_scratch_class if the verifier
2468 // was invoked in the middle of the redefinition of cls.
2469 // See jvmtiThreadState.hpp for details.
2470 
2471 inline Klass* get_klass_considering_redefinition(jclass cls, JavaThread* thread) {
2472   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2473   if (k->is_instance_klass()) {
2474     return JvmtiThreadState::class_to_verify_considering_redefinition(InstanceKlass::cast(k), thread);
2475   } else {
2476     return k;
2477   }
2478 }
2479 
2480 inline InstanceKlass* get_instance_klass_considering_redefinition(jclass cls, JavaThread* thread) {
2481   InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(cls));
2482   return JvmtiThreadState::class_to_verify_considering_redefinition(ik, thread);
2483 }
2484 
2485 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
2486   oop mirror = JNIHandles::resolve_non_null(cls);
2487   if (java_lang_Class::is_primitive(mirror)) {
2488     return JNI_FALSE;
2489   }
2490   Klass* k = java_lang_Class::as_Klass(mirror);
2491   // This isn't necessary since answer is the same because redefinition
2492   // has already checked this matches for the scratch class.
2493   // k = get_klass_considering_redefinition(cls, thread)
2494   jboolean result = k->is_interface();
2495   assert(!result || k->is_instance_klass(),
2496          "all interfaces are instance types");
2497   return result;
2498 JVM_END
2499 
2500 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
2501   // No need to call get_klass_considering_redefinition() as redefinition cannot change a class's name.
2502   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2503   return k->name()->as_utf8();
2504 JVM_END
2505 
2506 
2507 JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
2508   Klass* k = get_klass_considering_redefinition(cls, thread);
2509   // types will have length zero if this is not an InstanceKlass
2510   // (length is determined by call to JVM_GetClassCPEntriesCount)
2511   if (k->is_instance_klass()) {
2512     ConstantPool* cp = InstanceKlass::cast(k)->constants();
2513     for (int index = cp->length() - 1; index >= 0; index--) {
2514       constantTag tag = cp->tag_at(index);
2515       types[index] = (tag.is_unresolved_klass()) ? (unsigned char) JVM_CONSTANT_Class : tag.value();
2516     }
2517   }
2518 JVM_END
2519 
2520 
2521 JVM_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls))
2522   Klass* k = get_klass_considering_redefinition(cls, thread);
2523   return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->constants()->length();
2524 JVM_END
2525 
2526 
2527 JVM_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls))
2528   Klass* k = get_klass_considering_redefinition(cls, thread);
2529   return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->java_fields_count();
2530 JVM_END
2531 
2532 
2533 JVM_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls))
2534   Klass* k = get_klass_considering_redefinition(cls, thread);
2535   return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->methods()->length();
2536 JVM_END
2537 
2538 
2539 // The following methods, used for the verifier, are never called with
2540 // array klasses, so a direct cast to InstanceKlass is safe.
2541 // Typically, these methods are called in a loop with bounds determined
2542 // by the results of JVM_GetClass{Fields,Methods}Count, which return
2543 // zero for arrays.
2544 JVM_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions))
2545   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2546   Method* method = ik->methods()->at(method_index);
2547   int length = method->checked_exceptions_length();
2548   if (length > 0) {
2549     CheckedExceptionElement* table= method->checked_exceptions_start();
2550     for (int i = 0; i < length; i++) {
2551       exceptions[i] = table[i].class_cp_index;
2552     }
2553   }
2554 JVM_END
2555 
2556 
2557 JVM_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index))
2558   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2559   Method* method = ik->methods()->at(method_index);
2560   return method->checked_exceptions_length();
2561 JVM_END
2562 
2563 
2564 JVM_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code))
2565   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2566   Method* method = ik->methods()->at(method_index);
2567   memcpy(code, method->code_base(), method->code_size());
2568 JVM_END
2569 
2570 
2571 JVM_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index))
2572   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2573   Method* method = ik->methods()->at(method_index);
2574   return method->code_size();
2575 JVM_END
2576 
2577 
2578 JVM_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry))
2579   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2580   Method* method = ik->methods()->at(method_index);
2581   ExceptionTable extable(method);
2582   entry->start_pc   = extable.start_pc(entry_index);
2583   entry->end_pc     = extable.end_pc(entry_index);
2584   entry->handler_pc = extable.handler_pc(entry_index);
2585   entry->catchType  = extable.catch_type_index(entry_index);
2586 JVM_END
2587 
2588 
2589 JVM_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index))
2590   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2591   Method* method = ik->methods()->at(method_index);
2592   return method->exception_table_length();
2593 JVM_END
2594 
2595 
2596 JVM_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index))
2597   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2598   Method* method = ik->methods()->at(method_index);
2599   return method->access_flags().as_method_flags();
2600 JVM_END
2601 
2602 
2603 JVM_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index))
2604   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2605   return ik->field_access_flags(field_index);
2606 JVM_END
2607 
2608 
2609 JVM_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index))
2610   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2611   Method* method = ik->methods()->at(method_index);
2612   return method->max_locals();
2613 JVM_END
2614 
2615 
2616 JVM_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index))
2617   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2618   Method* method = ik->methods()->at(method_index);
2619   return method->size_of_parameters();
2620 JVM_END
2621 
2622 
2623 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2624   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2625   Method* method = ik->methods()->at(method_index);
2626   return method->verifier_max_stack();
2627 JVM_END
2628 
2629 
2630 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2631   ResourceMark rm(THREAD);
2632   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2633   Method* method = ik->methods()->at(method_index);
2634   return method->is_object_constructor();
2635 JVM_END
2636 
2637 
2638 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2639   ResourceMark rm(THREAD);
2640   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2641   Method* method = ik->methods()->at(method_index);
2642   return method->is_overpass();
2643 JVM_END
2644 
2645 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2646   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2647   Method* method = ik->methods()->at(method_index);
2648   return method->name()->as_utf8();
2649 JVM_END
2650 
2651 
2652 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
2653   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2654   Method* method = ik->methods()->at(method_index);
2655   return method->signature()->as_utf8();
2656 JVM_END
2657 
2658 /**
2659  * All of these JVM_GetCP-xxx methods are used by the old verifier to
2660  * read entries in the constant pool.  Since the old verifier always
2661  * works on a copy of the code, it will not see any rewriting that
2662  * may possibly occur in the middle of verification.  So it is important
2663  * that nothing it calls tries to use the cpCache instead of the raw
2664  * constant pool, so we must use cp->uncached_x methods when appropriate.
2665  */
2666 JVM_ENTRY(const char*, JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2667   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2668   ConstantPool* cp = ik->constants();
2669   switch (cp->tag_at(cp_index).value()) {
2670     case JVM_CONSTANT_Fieldref:
2671       return cp->uncached_name_ref_at(cp_index)->as_utf8();
2672     default:
2673       fatal("JVM_GetCPFieldNameUTF: illegal constant");
2674   }
2675   ShouldNotReachHere();
2676   return nullptr;
2677 JVM_END
2678 
2679 
2680 JVM_ENTRY(const char*, JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2681   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2682   ConstantPool* cp = ik->constants();
2683   switch (cp->tag_at(cp_index).value()) {
2684     case JVM_CONSTANT_InterfaceMethodref:
2685     case JVM_CONSTANT_Methodref:
2686       return cp->uncached_name_ref_at(cp_index)->as_utf8();
2687     default:
2688       fatal("JVM_GetCPMethodNameUTF: illegal constant");
2689   }
2690   ShouldNotReachHere();
2691   return nullptr;
2692 JVM_END
2693 
2694 
2695 JVM_ENTRY(const char*, JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index))
2696   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2697   ConstantPool* cp = ik->constants();
2698   switch (cp->tag_at(cp_index).value()) {
2699     case JVM_CONSTANT_InterfaceMethodref:
2700     case JVM_CONSTANT_Methodref:
2701       return cp->uncached_signature_ref_at(cp_index)->as_utf8();
2702     default:
2703       fatal("JVM_GetCPMethodSignatureUTF: illegal constant");
2704   }
2705   ShouldNotReachHere();
2706   return nullptr;
2707 JVM_END
2708 
2709 
2710 JVM_ENTRY(const char*, JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index))
2711   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2712   ConstantPool* cp = ik->constants();
2713   switch (cp->tag_at(cp_index).value()) {
2714     case JVM_CONSTANT_Fieldref:
2715       return cp->uncached_signature_ref_at(cp_index)->as_utf8();
2716     default:
2717       fatal("JVM_GetCPFieldSignatureUTF: illegal constant");
2718   }
2719   ShouldNotReachHere();
2720   return nullptr;
2721 JVM_END
2722 
2723 
2724 JVM_ENTRY(const char*, JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2725   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2726   ConstantPool* cp = ik->constants();
2727   Symbol* classname = cp->klass_name_at(cp_index);
2728   return classname->as_utf8();
2729 JVM_END
2730 
2731 
2732 JVM_ENTRY(const char*, JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2733   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2734   ConstantPool* cp = ik->constants();
2735   switch (cp->tag_at(cp_index).value()) {
2736     case JVM_CONSTANT_Fieldref: {
2737       int class_index = cp->uncached_klass_ref_index_at(cp_index);
2738       Symbol* classname = cp->klass_name_at(class_index);
2739       return classname->as_utf8();
2740     }
2741     default:
2742       fatal("JVM_GetCPFieldClassNameUTF: illegal constant");
2743   }
2744   ShouldNotReachHere();
2745   return nullptr;
2746 JVM_END
2747 
2748 
2749 JVM_ENTRY(const char*, JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2750   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2751   ConstantPool* cp = ik->constants();
2752   switch (cp->tag_at(cp_index).value()) {
2753     case JVM_CONSTANT_Methodref:
2754     case JVM_CONSTANT_InterfaceMethodref: {
2755       int class_index = cp->uncached_klass_ref_index_at(cp_index);
2756       Symbol* classname = cp->klass_name_at(class_index);
2757       return classname->as_utf8();
2758     }
2759     default:
2760       fatal("JVM_GetCPMethodClassNameUTF: illegal constant");
2761   }
2762   ShouldNotReachHere();
2763   return nullptr;
2764 JVM_END
2765 
2766 
2767 JVM_ENTRY(jint, JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))
2768   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2769   InstanceKlass* ik_called = get_instance_klass_considering_redefinition(called_cls, thread);
2770   ConstantPool* cp = ik->constants();
2771   ConstantPool* cp_called = ik_called->constants();
2772   switch (cp->tag_at(cp_index).value()) {
2773     case JVM_CONSTANT_Fieldref: {
2774       Symbol* name      = cp->uncached_name_ref_at(cp_index);
2775       Symbol* signature = cp->uncached_signature_ref_at(cp_index);
2776       for (JavaFieldStream fs(ik_called); !fs.done(); fs.next()) {
2777         if (fs.name() == name && fs.signature() == signature) {
2778           return fs.access_flags().as_field_flags();
2779         }
2780       }
2781       return -1;
2782     }
2783     default:
2784       fatal("JVM_GetCPFieldModifiers: illegal constant");
2785   }
2786   ShouldNotReachHere();
2787   return 0;
2788 JVM_END
2789 
2790 
2791 JVM_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))
2792   InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread);
2793   InstanceKlass* ik_called = get_instance_klass_considering_redefinition(called_cls, thread);
2794   ConstantPool* cp = ik->constants();
2795   switch (cp->tag_at(cp_index).value()) {
2796     case JVM_CONSTANT_Methodref:
2797     case JVM_CONSTANT_InterfaceMethodref: {
2798       Symbol* name      = cp->uncached_name_ref_at(cp_index);
2799       Symbol* signature = cp->uncached_signature_ref_at(cp_index);
2800       Array<Method*>* methods = ik_called->methods();
2801       int methods_count = methods->length();
2802       for (int i = 0; i < methods_count; i++) {
2803         Method* method = methods->at(i);
2804         if (method->name() == name && method->signature() == signature) {
2805             return method->access_flags().as_method_flags();
2806         }
2807       }
2808       return -1;
2809     }
2810     default:
2811       fatal("JVM_GetCPMethodModifiers: illegal constant");
2812   }
2813   ShouldNotReachHere();
2814   return 0;
2815 JVM_END
2816 
2817 
2818 // Misc //////////////////////////////////////////////////////////////////////////////////////////////
2819 
2820 JVM_LEAF(void, JVM_ReleaseUTF(const char *utf))
2821   // So long as UTF8::convert_to_utf8 returns resource strings, we don't have to do anything
2822 JVM_END
2823 
2824 
2825 JVM_ENTRY(jboolean, JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2))
2826   oop class1_mirror = JNIHandles::resolve_non_null(class1);
2827   oop class2_mirror = JNIHandles::resolve_non_null(class2);
2828   Klass* klass1 = java_lang_Class::as_Klass(class1_mirror);
2829   Klass* klass2 = java_lang_Class::as_Klass(class2_mirror);
2830   return (jboolean) Reflection::is_same_class_package(klass1, klass2);
2831 JVM_END
2832 
2833 // Printing support //////////////////////////////////////////////////
2834 extern "C" {
2835 
2836 ATTRIBUTE_PRINTF(3, 0)
2837 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args) {
2838   // Reject count values that are negative signed values converted to
2839   // unsigned; see bug 4399518, 4417214
2840   if ((intptr_t)count <= 0) return -1;
2841 
2842   int result = os::vsnprintf(str, count, fmt, args);
2843   if (result > 0 && (size_t)result >= count) {
2844     result = -1;
2845   }
2846 
2847   return result;
2848 }
2849 
2850 ATTRIBUTE_PRINTF(3, 4)
2851 int jio_snprintf(char *str, size_t count, const char *fmt, ...) {
2852   va_list args;
2853   int len;
2854   va_start(args, fmt);
2855   len = jio_vsnprintf(str, count, fmt, args);
2856   va_end(args);
2857   return len;
2858 }
2859 
2860 ATTRIBUTE_PRINTF(2, 3)
2861 int jio_fprintf(FILE* f, const char *fmt, ...) {
2862   int len;
2863   va_list args;
2864   va_start(args, fmt);
2865   len = jio_vfprintf(f, fmt, args);
2866   va_end(args);
2867   return len;
2868 }
2869 
2870 ATTRIBUTE_PRINTF(2, 0)
2871 int jio_vfprintf(FILE* f, const char *fmt, va_list args) {
2872   if (Arguments::vfprintf_hook() != nullptr) {
2873      return Arguments::vfprintf_hook()(f, fmt, args);
2874   } else {
2875     return vfprintf(f, fmt, args);
2876   }
2877 }
2878 
2879 ATTRIBUTE_PRINTF(1, 2)
2880 JNIEXPORT int jio_printf(const char *fmt, ...) {
2881   int len;
2882   va_list args;
2883   va_start(args, fmt);
2884   len = jio_vfprintf(defaultStream::output_stream(), fmt, args);
2885   va_end(args);
2886   return len;
2887 }
2888 
2889 // HotSpot specific jio method
2890 void jio_print(const char* s, size_t len) {
2891   // Try to make this function as atomic as possible.
2892   if (Arguments::vfprintf_hook() != nullptr) {
2893     jio_fprintf(defaultStream::output_stream(), "%.*s", (int)len, s);
2894   } else {
2895     // Make an unused local variable to avoid warning from gcc compiler.
2896     bool dummy = os::write(defaultStream::output_fd(), s, len);
2897   }
2898 }
2899 
2900 } // Extern C
2901 
2902 // java.lang.Thread //////////////////////////////////////////////////////////////////////////////
2903 
2904 // In most of the JVM thread support functions we need to access the
2905 // thread through a ThreadsListHandle to prevent it from exiting and
2906 // being reclaimed while we try to operate on it. The exceptions to this
2907 // rule are when operating on the current thread, or if the monitor of
2908 // the target java.lang.Thread is locked at the Java level - in both
2909 // cases the target cannot exit.
2910 
2911 static void thread_entry(JavaThread* thread, TRAPS) {
2912   HandleMark hm(THREAD);
2913   Handle obj(THREAD, thread->threadObj());
2914   JavaValue result(T_VOID);
2915   JavaCalls::call_virtual(&result,
2916                           obj,
2917                           vmClasses::Thread_klass(),
2918                           vmSymbols::run_method_name(),
2919                           vmSymbols::void_method_signature(),
2920                           THREAD);
2921 }
2922 
2923 
2924 JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
2925 #if INCLUDE_CDS
2926   if (CDSConfig::allow_only_single_java_thread()) {
2927     // During java -Xshare:dump, if we allow multiple Java threads to
2928     // execute in parallel, symbols and classes may be loaded in
2929     // random orders which will make the resulting CDS archive
2930     // non-deterministic.
2931     //
2932     // Lucikly, during java -Xshare:dump, it's important to run only
2933     // the code in the main Java thread (which is NOT started here) that
2934     // creates the module graph, etc. It's safe to not start the other
2935     // threads which are launched by class static initializers
2936     // (ReferenceHandler, FinalizerThread and CleanerImpl).
2937     if (log_is_enabled(Info, aot)) {
2938       ResourceMark rm;
2939       oop t = JNIHandles::resolve_non_null(jthread);
2940       log_info(aot)("JVM_StartThread() ignored: %s", t->klass()->external_name());
2941     }
2942     return;
2943   }
2944 #endif
2945   JavaThread *native_thread = nullptr;
2946 
2947   // We cannot hold the Threads_lock when we throw an exception,
2948   // due to rank ordering issues. Example:  we might need to grab the
2949   // Heap_lock while we construct the exception.
2950   bool throw_illegal_thread_state = false;
2951 
2952   // We must release the Threads_lock before we can post a jvmti event
2953   // in Thread::start.
2954   {
2955     ConditionalMutexLocker throttle_ml(ThreadsLockThrottle_lock, UseThreadsLockThrottleLock);
2956     // Ensure that the C++ Thread and OSThread structures aren't freed before
2957     // we operate.
2958     MutexLocker ml(Threads_lock);
2959 
2960     // Since JDK 5 the java.lang.Thread threadStatus is used to prevent
2961     // re-starting an already started thread, so we should usually find
2962     // that the JavaThread is null. However for a JNI attached thread
2963     // there is a small window between the Thread object being created
2964     // (with its JavaThread set) and the update to its threadStatus, so we
2965     // have to check for this
2966     if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != nullptr) {
2967       throw_illegal_thread_state = true;
2968     } else {
2969       jlong size =
2970              java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));
2971       // Allocate the C++ Thread structure and create the native thread.  The
2972       // stack size retrieved from java is 64-bit signed, but the constructor takes
2973       // size_t (an unsigned type), which may be 32 or 64-bit depending on the platform.
2974       //  - Avoid truncating on 32-bit platforms if size is greater than UINT_MAX.
2975       //  - Avoid passing negative values which would result in really large stacks.
2976       NOT_LP64(if (size > SIZE_MAX) size = SIZE_MAX;)
2977       size_t sz = size > 0 ? (size_t) size : 0;
2978       native_thread = new JavaThread(&thread_entry, sz);
2979 
2980       // At this point it may be possible that no osthread was created for the
2981       // JavaThread due to lack of memory. Check for this situation and throw
2982       // an exception if necessary. Eventually we may want to change this so
2983       // that we only grab the lock if the thread was created successfully -
2984       // then we can also do this check and throw the exception in the
2985       // JavaThread constructor.
2986       if (native_thread->osthread() != nullptr) {
2987         // Note: the current thread is not being used within "prepare".
2988         native_thread->prepare(jthread);
2989       }
2990     }
2991   }
2992 
2993   if (throw_illegal_thread_state) {
2994     THROW(vmSymbols::java_lang_IllegalThreadStateException());
2995   }
2996 
2997   assert(native_thread != nullptr, "Starting null thread?");
2998 
2999   if (native_thread->osthread() == nullptr) {
3000     ResourceMark rm(thread);
3001     log_warning(os, thread)("Failed to start the native thread for java.lang.Thread \"%s\"",
3002                             JavaThread::name_for(JNIHandles::resolve_non_null(jthread)));
3003     // No one should hold a reference to the 'native_thread'.
3004     native_thread->smr_delete();
3005     if (JvmtiExport::should_post_resource_exhausted()) {
3006       JvmtiExport::post_resource_exhausted(
3007         JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS,
3008         os::native_thread_creation_failed_msg());
3009     }
3010     THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),
3011               os::native_thread_creation_failed_msg());
3012   }
3013 
3014   JFR_ONLY(Jfr::on_java_thread_start(thread, native_thread);)
3015 
3016   Thread::start(native_thread);
3017 
3018 JVM_END
3019 
3020 
3021 JVM_ENTRY(void, JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio))
3022   ThreadsListHandle tlh(thread);
3023   oop java_thread = nullptr;
3024   JavaThread* receiver = nullptr;
3025   bool is_alive = tlh.cv_internal_thread_to_JavaThread(jthread, &receiver, &java_thread);
3026   java_lang_Thread::set_priority(java_thread, (ThreadPriority)prio);
3027 
3028   if (is_alive) {
3029     // jthread refers to a live JavaThread.
3030     Thread::set_priority(receiver, (ThreadPriority)prio);
3031   }
3032   // Implied else: If the JavaThread hasn't started yet, then the
3033   // priority set in the java.lang.Thread object above will be pushed
3034   // down when it does start.
3035 JVM_END
3036 
3037 
3038 JVM_LEAF(void, JVM_Yield(JNIEnv *env, jclass threadClass))
3039   HOTSPOT_THREAD_YIELD();
3040   os::naked_yield();
3041 JVM_END
3042 
3043 JVM_ENTRY(void, JVM_SleepNanos(JNIEnv* env, jclass threadClass, jlong nanos))
3044   if (nanos < 0) {
3045     THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nanosecond timeout value out of range");
3046   }
3047 
3048   if (thread->is_interrupted(true) && !HAS_PENDING_EXCEPTION) {
3049     THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
3050   }
3051 
3052   // Save current thread state and restore it at the end of this block.
3053   // And set new thread state to SLEEPING.
3054   JavaThreadSleepState jtss(thread);
3055 
3056   HOTSPOT_THREAD_SLEEP_BEGIN(nanos / NANOSECS_PER_MILLISEC);
3057 
3058   if (nanos == 0) {
3059     os::naked_yield();
3060   } else {
3061     ThreadState old_state = thread->osthread()->get_state();
3062     thread->osthread()->set_state(SLEEPING);
3063     if (!thread->sleep_nanos(nanos)) { // interrupted or async exception was installed
3064       // An asynchronous exception could have been thrown on
3065       // us while we were sleeping. We do not overwrite those.
3066       if (!HAS_PENDING_EXCEPTION) {
3067         HOTSPOT_THREAD_SLEEP_END(1);
3068         if (!thread->has_async_exception_condition()) {
3069           // TODO-FIXME: THROW_MSG returns which means we will not call set_state()
3070           // to properly restore the thread state.  That's likely wrong.
3071           THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
3072         }
3073       }
3074     }
3075     thread->osthread()->set_state(old_state);
3076   }
3077   HOTSPOT_THREAD_SLEEP_END(0);
3078 JVM_END
3079 
3080 JVM_ENTRY(jobject, JVM_CurrentCarrierThread(JNIEnv* env, jclass threadClass))
3081   oop jthread = thread->threadObj();
3082   assert(jthread != nullptr, "no current carrier thread!");
3083   return JNIHandles::make_local(THREAD, jthread);
3084 JVM_END
3085 
3086 JVM_ENTRY(jobject, JVM_CurrentThread(JNIEnv* env, jclass threadClass))
3087   oop theThread = thread->vthread();
3088   assert(theThread != (oop)nullptr, "no current thread!");
3089   return JNIHandles::make_local(THREAD, theThread);
3090 JVM_END
3091 
3092 JVM_ENTRY(void, JVM_SetCurrentThread(JNIEnv* env, jobject thisThread,
3093                                      jobject theThread))
3094   oop threadObj = JNIHandles::resolve(theThread);
3095   thread->set_vthread(threadObj);
3096 
3097   // Set _monitor_owner_id of new current Thread
3098   thread->set_monitor_owner_id(java_lang_Thread::thread_id(threadObj));
3099 
3100   JFR_ONLY(Jfr::on_set_current_thread(thread, threadObj);)
3101 JVM_END
3102 
3103 JVM_ENTRY(jlong, JVM_GetNextThreadIdOffset(JNIEnv* env, jclass threadClass))
3104   return ThreadIdentifier::unsafe_offset();
3105 JVM_END
3106 
3107 JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread))
3108   ThreadsListHandle tlh(thread);
3109   JavaThread* receiver = nullptr;
3110   bool is_alive = tlh.cv_internal_thread_to_JavaThread(jthread, &receiver, nullptr);
3111   if (is_alive) {
3112     // jthread refers to a live JavaThread.
3113     receiver->interrupt();
3114   }
3115 JVM_END
3116 
3117 // Return true iff the current thread has locked the object passed in
3118 
3119 JVM_ENTRY(jboolean, JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj))
3120   if (obj == nullptr) {
3121     THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE);
3122   }
3123   Handle h_obj(THREAD, JNIHandles::resolve(obj));
3124   return ObjectSynchronizer::current_thread_holds_lock(thread, h_obj);
3125 JVM_END
3126 
3127 JVM_ENTRY(jobjectArray, JVM_GetStackTrace(JNIEnv *env, jobject jthread))
3128   oop trace = java_lang_Thread::async_get_stack_trace(jthread, THREAD);
3129   return (jobjectArray) JNIHandles::make_local(THREAD, trace);
3130 JVM_END
3131 
3132 JVM_ENTRY(jobject, JVM_CreateThreadSnapshot(JNIEnv* env, jobject jthread))
3133   oop snapshot = ThreadSnapshotFactory::get_thread_snapshot(jthread, THREAD);
3134   return JNIHandles::make_local(THREAD, snapshot);
3135 JVM_END
3136 
3137 JVM_ENTRY(void, JVM_SetNativeThreadName(JNIEnv* env, jobject jthread, jstring name))
3138   // We don't use a ThreadsListHandle here because the current thread
3139   // must be alive.
3140   oop java_thread = JNIHandles::resolve_non_null(jthread);
3141   JavaThread* thr = java_lang_Thread::thread(java_thread);
3142   if (thread == thr && !thr->has_attached_via_jni()) {
3143     // Thread naming is only supported for the current thread and
3144     // we don't set the name of an attached thread to avoid stepping
3145     // on other programs.
3146     ResourceMark rm(thread);
3147     const char *thread_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name));
3148     os::set_native_thread_name(thread_name);
3149   }
3150 JVM_END
3151 
3152 JVM_ENTRY(jobject, JVM_ScopedValueCache(JNIEnv* env, jclass threadClass))
3153   oop theCache = thread->scopedValueCache();
3154   return JNIHandles::make_local(THREAD, theCache);
3155 JVM_END
3156 
3157 JVM_ENTRY(void, JVM_SetScopedValueCache(JNIEnv* env, jclass threadClass,
3158                                        jobject theCache))
3159   arrayOop objs = arrayOop(JNIHandles::resolve(theCache));
3160   thread->set_scopedValueCache(objs);
3161 JVM_END
3162 
3163 
3164 // java.lang.Package ////////////////////////////////////////////////////////////////
3165 
3166 
3167 JVM_ENTRY(jstring, JVM_GetSystemPackage(JNIEnv *env, jstring name))
3168   ResourceMark rm(THREAD);
3169   JvmtiVMObjectAllocEventCollector oam;
3170   char* str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name));
3171   oop result = ClassLoader::get_system_package(str, CHECK_NULL);
3172 return (jstring) JNIHandles::make_local(THREAD, result);
3173 JVM_END
3174 
3175 
3176 JVM_ENTRY(jobjectArray, JVM_GetSystemPackages(JNIEnv *env))
3177   JvmtiVMObjectAllocEventCollector oam;
3178   objArrayOop result = ClassLoader::get_system_packages(CHECK_NULL);
3179   return (jobjectArray) JNIHandles::make_local(THREAD, result);
3180 JVM_END
3181 
3182 
3183 // java.lang.ref.Reference ///////////////////////////////////////////////////////////////
3184 
3185 
3186 JVM_ENTRY(jobject, JVM_GetAndClearReferencePendingList(JNIEnv* env))
3187   MonitorLocker ml(Heap_lock);
3188   oop ref = Universe::reference_pending_list();
3189   if (ref != nullptr) {
3190     Universe::clear_reference_pending_list();
3191   }
3192   return JNIHandles::make_local(THREAD, ref);
3193 JVM_END
3194 
3195 JVM_ENTRY(jboolean, JVM_HasReferencePendingList(JNIEnv* env))
3196   MonitorLocker ml(Heap_lock);
3197   return Universe::has_reference_pending_list();
3198 JVM_END
3199 
3200 JVM_ENTRY(void, JVM_WaitForReferencePendingList(JNIEnv* env))
3201   MonitorLocker ml(Heap_lock);
3202   while (!Universe::has_reference_pending_list()) {
3203     ml.wait();
3204   }
3205 JVM_END
3206 
3207 JVM_ENTRY(jobject, JVM_ReferenceGet(JNIEnv* env, jobject ref))
3208   oop ref_oop = JNIHandles::resolve_non_null(ref);
3209   // PhantomReference has its own implementation of get().
3210   assert(!java_lang_ref_Reference::is_phantom(ref_oop), "precondition");
3211   oop referent = java_lang_ref_Reference::weak_referent(ref_oop);
3212   return JNIHandles::make_local(THREAD, referent);
3213 JVM_END
3214 
3215 JVM_ENTRY(jboolean, JVM_ReferenceRefersTo(JNIEnv* env, jobject ref, jobject o))
3216   oop ref_oop = JNIHandles::resolve_non_null(ref);
3217   // PhantomReference has its own implementation of refersTo().
3218   // See: JVM_PhantomReferenceRefersTo
3219   assert(!java_lang_ref_Reference::is_phantom(ref_oop), "precondition");
3220   oop referent = java_lang_ref_Reference::weak_referent_no_keepalive(ref_oop);
3221   return referent == JNIHandles::resolve(o);
3222 JVM_END
3223 
3224 JVM_ENTRY(void, JVM_ReferenceClear(JNIEnv* env, jobject ref))
3225   oop ref_oop = JNIHandles::resolve_non_null(ref);
3226   // FinalReference has it's own implementation of clear().
3227   assert(!java_lang_ref_Reference::is_final(ref_oop), "precondition");
3228   if (java_lang_ref_Reference::unknown_referent_no_keepalive(ref_oop) == nullptr) {
3229     // If the referent has already been cleared then done.
3230     // However, if the referent is dead but has not yet been cleared by
3231     // concurrent reference processing, it should NOT be cleared here.
3232     // Instead, clearing should be left to the GC.  Clearing it here could
3233     // detectably lose an expected notification, which is impossible with
3234     // STW reference processing.  The clearing in enqueue() doesn't have
3235     // this problem, since the enqueue covers the notification, but it's not
3236     // worth the effort to handle that case specially.
3237     return;
3238   }
3239   java_lang_ref_Reference::clear_referent(ref_oop);
3240 JVM_END
3241 
3242 
3243 // java.lang.ref.PhantomReference //////////////////////////////////////////////////
3244 
3245 
3246 JVM_ENTRY(jboolean, JVM_PhantomReferenceRefersTo(JNIEnv* env, jobject ref, jobject o))
3247   oop ref_oop = JNIHandles::resolve_non_null(ref);
3248   oop referent = java_lang_ref_Reference::phantom_referent_no_keepalive(ref_oop);
3249   return referent == JNIHandles::resolve(o);
3250 JVM_END
3251 
3252 
3253 // ObjectInputStream ///////////////////////////////////////////////////////////////
3254 
3255 // Return the first user-defined class loader up the execution stack, or null
3256 // if only code from the bootstrap or platform class loader is on the stack.
3257 
3258 JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))
3259   for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
3260     InstanceKlass* ik = vfst.method()->method_holder();
3261     oop loader = ik->class_loader();
3262     if (loader != nullptr && !SystemDictionary::is_platform_class_loader(loader)) {
3263       return JNIHandles::make_local(THREAD, loader);
3264     }
3265   }
3266   return nullptr;
3267 JVM_END
3268 
3269 
3270 // Array ///////////////////////////////////////////////////////////////////////////////////////////
3271 
3272 
3273 // resolve array handle and check arguments
3274 static inline arrayOop check_array(JNIEnv *env, jobject arr, bool type_array_only, TRAPS) {
3275   if (arr == nullptr) {
3276     THROW_NULL(vmSymbols::java_lang_NullPointerException());
3277   }
3278   oop a = JNIHandles::resolve_non_null(arr);
3279   if (!a->is_array()) {
3280     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array");
3281   } else if (type_array_only && !a->is_typeArray()) {
3282     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array of primitive type");
3283   }
3284   return arrayOop(a);
3285 }
3286 
3287 
3288 JVM_ENTRY(jint, JVM_GetArrayLength(JNIEnv *env, jobject arr))
3289   arrayOop a = check_array(env, arr, false, CHECK_0);
3290   return a->length();
3291 JVM_END
3292 
3293 
3294 JVM_ENTRY(jobject, JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index))
3295   JvmtiVMObjectAllocEventCollector oam;
3296   arrayOop a = check_array(env, arr, false, CHECK_NULL);
3297   jvalue value;
3298   BasicType type = Reflection::array_get(&value, a, index, CHECK_NULL);
3299   oop box = Reflection::box(&value, type, CHECK_NULL);
3300   return JNIHandles::make_local(THREAD, box);
3301 JVM_END
3302 
3303 
3304 JVM_ENTRY(jvalue, JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode))
3305   jvalue value;
3306   value.i = 0; // to initialize value before getting used in CHECK
3307   arrayOop a = check_array(env, arr, true, CHECK_(value));
3308   assert(a->is_typeArray(), "just checking");
3309   BasicType type = Reflection::array_get(&value, a, index, CHECK_(value));
3310   BasicType wide_type = (BasicType) wCode;
3311   if (type != wide_type) {
3312     Reflection::widen(&value, type, wide_type, CHECK_(value));
3313   }
3314   return value;
3315 JVM_END
3316 
3317 
3318 JVM_ENTRY(void, JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val))
3319   arrayOop a = check_array(env, arr, false, CHECK);
3320   oop box = JNIHandles::resolve(val);
3321   jvalue value;
3322   value.i = 0; // to initialize value before getting used in CHECK
3323   BasicType value_type;
3324   if (a->is_objArray()) {
3325     // Make sure we do no unbox e.g. java/lang/Integer instances when storing into an object array
3326     value_type = Reflection::unbox_for_regular_object(box, &value);
3327   } else {
3328     value_type = Reflection::unbox_for_primitive(box, &value, CHECK);
3329   }
3330   Reflection::array_set(&value, a, index, value_type, CHECK);
3331 JVM_END
3332 
3333 
3334 JVM_ENTRY(void, JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode))
3335   arrayOop a = check_array(env, arr, true, CHECK);
3336   assert(a->is_typeArray(), "just checking");
3337   BasicType value_type = (BasicType) vCode;
3338   Reflection::array_set(&v, a, index, value_type, CHECK);
3339 JVM_END
3340 
3341 
3342 JVM_ENTRY(jobject, JVM_NewArray(JNIEnv *env, jclass eltClass, jint length))
3343   JvmtiVMObjectAllocEventCollector oam;
3344   oop element_mirror = JNIHandles::resolve(eltClass);
3345   oop result = Reflection::reflect_new_array(element_mirror, length, CHECK_NULL);
3346   return JNIHandles::make_local(THREAD, result);
3347 JVM_END
3348 
3349 
3350 JVM_ENTRY(jobject, JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim))
3351   JvmtiVMObjectAllocEventCollector oam;
3352   arrayOop dim_array = check_array(env, dim, true, CHECK_NULL);
3353   oop element_mirror = JNIHandles::resolve(eltClass);
3354   assert(dim_array->is_typeArray(), "just checking");
3355   oop result = Reflection::reflect_new_multi_array(element_mirror, typeArrayOop(dim_array), CHECK_NULL);
3356   return JNIHandles::make_local(THREAD, result);
3357 JVM_END
3358 
3359 
3360 // Library support ///////////////////////////////////////////////////////////////////////////
3361 
3362 JVM_LEAF(void*, JVM_LoadZipLibrary())
3363   return ZipLibrary::handle();
3364 JVM_END
3365 
3366 JVM_ENTRY_NO_ENV(void*, JVM_LoadLibrary(const char* name, jboolean throwException))
3367   //%note jvm_ct
3368   char ebuf[1024];
3369   void *load_result;
3370   {
3371     ThreadToNativeFromVM ttnfvm(thread);
3372     load_result = os::dll_load(name, ebuf, sizeof ebuf);
3373   }
3374   if (load_result == nullptr) {
3375     if (throwException) {
3376       char msg[1024];
3377       jio_snprintf(msg, sizeof msg, "%s: %s", name, ebuf);
3378       // Since 'ebuf' may contain a string encoded using
3379       // platform encoding scheme, we need to pass
3380       // Exceptions::unsafe_to_utf8 to the new_exception method
3381       // as the last argument. See bug 6367357.
3382       Handle h_exception =
3383         Exceptions::new_exception(thread,
3384                                   vmSymbols::java_lang_UnsatisfiedLinkError(),
3385                                   msg, Exceptions::unsafe_to_utf8);
3386 
3387       THROW_HANDLE_NULL(h_exception);
3388     } else {
3389       log_info(library)("Failed to load library %s", name);
3390       return load_result;
3391     }
3392   }
3393   log_info(library)("Loaded library %s, handle " INTPTR_FORMAT, name, p2i(load_result));
3394   return load_result;
3395 JVM_END
3396 
3397 
3398 JVM_LEAF(void, JVM_UnloadLibrary(void* handle))
3399   os::dll_unload(handle);
3400   log_info(library)("Unloaded library with handle " INTPTR_FORMAT, p2i(handle));
3401 JVM_END
3402 
3403 
3404 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3405   void* find_result = os::dll_lookup(handle, name);
3406   log_info(library)("%s %s in library with handle " INTPTR_FORMAT,
3407                     find_result != nullptr ? "Found" : "Failed to find",
3408                     name, p2i(handle));
3409   return find_result;
3410 JVM_END
3411 
3412 
3413 // JNI version ///////////////////////////////////////////////////////////////////////////////
3414 
3415 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3416   return Threads::is_supported_jni_version_including_1_1(version);
3417 JVM_END
3418 
3419 
3420 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void))
3421   return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE;
3422 JVM_END
3423 
3424 JVM_LEAF(jboolean, JVM_IsValhallaEnabled(void))
3425   return Arguments::is_valhalla_enabled() ? JNI_TRUE : JNI_FALSE;
3426 JVM_END
3427 
3428 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void))
3429   return VMContinuations ? JNI_TRUE : JNI_FALSE;
3430 JVM_END
3431 
3432 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void))
3433   return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE;
3434 JVM_END
3435 
3436 JVM_LEAF(jboolean, JVM_IsStaticallyLinked(void))
3437   return is_vm_statically_linked() ? JNI_TRUE : JNI_FALSE;
3438 JVM_END
3439 
3440 // String support ///////////////////////////////////////////////////////////////////////////
3441 
3442 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3443   JvmtiVMObjectAllocEventCollector oam;
3444   if (str == nullptr) return nullptr;
3445   oop string = JNIHandles::resolve_non_null(str);
3446   oop result = StringTable::intern(string, CHECK_NULL);
3447   return (jstring) JNIHandles::make_local(THREAD, result);
3448 JVM_END
3449 
3450 
3451 // VM Raw monitor support //////////////////////////////////////////////////////////////////////
3452 
3453 // VM Raw monitors (not to be confused with JvmtiRawMonitors) are a simple mutual exclusion
3454 // lock (not actually monitors: no wait/notify) that is exported by the VM for use by JDK
3455 // library code. They may be used by JavaThreads and non-JavaThreads and do not participate
3456 // in the safepoint protocol, thread suspension, thread interruption, or most things of that
3457 // nature, except JavaThreads will be blocked by VM_Exit::block_if_vm_exited if the VM has
3458 // shutdown. JavaThreads will be "in native" when using this API from JDK code.
3459 
3460 
3461 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void) {
3462   VM_Exit::block_if_vm_exited();
3463   return new PlatformMutex();
3464 }
3465 
3466 
3467 JNIEXPORT void JNICALL  JVM_RawMonitorDestroy(void *mon) {
3468   VM_Exit::block_if_vm_exited();
3469   delete ((PlatformMutex*) mon);
3470 }
3471 
3472 
3473 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon) {
3474   VM_Exit::block_if_vm_exited();
3475   ((PlatformMutex*) mon)->lock();
3476   return 0;
3477 }
3478 
3479 
3480 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon) {
3481   VM_Exit::block_if_vm_exited();
3482   ((PlatformMutex*) mon)->unlock();
3483 }
3484 
3485 
3486 // Shared JNI/JVM entry points //////////////////////////////////////////////////////////////
3487 
3488 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init,
3489                                     Handle loader, jboolean throwError, TRAPS) {
3490   Klass* klass = SystemDictionary::resolve_or_fail(name, loader, throwError != 0, CHECK_NULL);
3491 
3492   // Check if we should initialize the class
3493   if (init && klass->is_instance_klass()) {
3494     klass->initialize(CHECK_NULL);
3495   }
3496   return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror());
3497 }
3498 
3499 
3500 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3501 
3502 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3503   Handle method_handle;
3504   if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3505     method_handle = Handle(THREAD, JNIHandles::resolve(method));
3506     Handle receiver(THREAD, JNIHandles::resolve(obj));
3507     objArrayHandle args(THREAD, (objArrayOop)JNIHandles::resolve(args0));
3508     assert(args() == nullptr || !args->is_flatArray(), "args are never flat or are they???");
3509 
3510     oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3511     jobject res = JNIHandles::make_local(THREAD, result);
3512     if (JvmtiExport::should_post_vm_object_alloc()) {
3513       oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3514       assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!");
3515       if (java_lang_Class::is_primitive(ret_type)) {
3516         // Only for primitive type vm allocates memory for java object.
3517         // See box() method.
3518         JvmtiExport::post_vm_object_alloc(thread, result);
3519       }
3520     }
3521     return res;
3522   } else {
3523     THROW_NULL(vmSymbols::java_lang_StackOverflowError());
3524   }
3525 JVM_END
3526 
3527 
3528 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3529   objArrayHandle args(THREAD, (objArrayOop)JNIHandles::resolve(args0));
3530   assert(args() == nullptr || !args->is_flatArray(), "args are never flat or are they???");
3531   oop constructor_mirror = JNIHandles::resolve(c);

3532   oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3533   jobject res = JNIHandles::make_local(THREAD, result);
3534   if (JvmtiExport::should_post_vm_object_alloc()) {
3535     JvmtiExport::post_vm_object_alloc(thread, result);
3536   }
3537   return res;
3538 JVM_END
3539 
3540 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls))
3541   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3542   HeapShared::initialize_from_archived_subgraph(THREAD, k);
3543 JVM_END
3544 
3545 JVM_ENTRY(void, JVM_RegisterLambdaProxyClassForArchiving(JNIEnv* env,
3546                                               jclass caller,
3547                                               jstring interfaceMethodName,
3548                                               jobject factoryType,
3549                                               jobject interfaceMethodType,
3550                                               jobject implementationMember,
3551                                               jobject dynamicMethodType,
3552                                               jclass lambdaProxyClass))
3553 #if INCLUDE_CDS
3554   if (!CDSConfig::is_dumping_archive() || !CDSConfig::is_dumping_lambdas_in_legacy_mode()) {
3555     return;
3556   }
3557 
3558   InstanceKlass* caller_ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(caller));
3559   if (caller_ik->is_hidden()) {
3560     // Hidden classes not of type lambda proxy classes are currently not being archived.
3561     // If the caller_ik is of one of the above types, the corresponding lambda proxy class won't be
3562     // registered for archiving.
3563     return;
3564   }
3565   InstanceKlass* lambda_ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(lambdaProxyClass));
3566   assert(lambda_ik->is_hidden(), "must be a hidden class");
3567   assert(!lambda_ik->is_non_strong_hidden(), "expected a strong hidden class");
3568 
3569   Symbol* interface_method_name = nullptr;
3570   if (interfaceMethodName != nullptr) {
3571     interface_method_name = java_lang_String::as_symbol(JNIHandles::resolve_non_null(interfaceMethodName));
3572   }
3573   Handle factory_type_oop(THREAD, JNIHandles::resolve_non_null(factoryType));
3574   Symbol* factory_type = java_lang_invoke_MethodType::as_signature(factory_type_oop(), true);
3575 
3576   Handle interface_method_type_oop(THREAD, JNIHandles::resolve_non_null(interfaceMethodType));
3577   Symbol* interface_method_type = java_lang_invoke_MethodType::as_signature(interface_method_type_oop(), true);
3578 
3579   Handle implementation_member_oop(THREAD, JNIHandles::resolve_non_null(implementationMember));
3580   assert(java_lang_invoke_MemberName::is_method(implementation_member_oop()), "must be");
3581   Method* m = java_lang_invoke_MemberName::vmtarget(implementation_member_oop());
3582 
3583   Handle dynamic_method_type_oop(THREAD, JNIHandles::resolve_non_null(dynamicMethodType));
3584   Symbol* dynamic_method_type = java_lang_invoke_MethodType::as_signature(dynamic_method_type_oop(), true);
3585 
3586   LambdaProxyClassDictionary::add_lambda_proxy_class(caller_ik, lambda_ik, interface_method_name, factory_type,
3587                                                      interface_method_type, m, dynamic_method_type, THREAD);
3588 #endif // INCLUDE_CDS
3589 JVM_END
3590 
3591 JVM_ENTRY(jclass, JVM_LookupLambdaProxyClassFromArchive(JNIEnv* env,
3592                                                         jclass caller,
3593                                                         jstring interfaceMethodName,
3594                                                         jobject factoryType,
3595                                                         jobject interfaceMethodType,
3596                                                         jobject implementationMember,
3597                                                         jobject dynamicMethodType))
3598 #if INCLUDE_CDS
3599 
3600   if (interfaceMethodName == nullptr || factoryType == nullptr || interfaceMethodType == nullptr ||
3601       implementationMember == nullptr || dynamicMethodType == nullptr) {
3602     THROW_(vmSymbols::java_lang_NullPointerException(), nullptr);
3603   }
3604 
3605   InstanceKlass* caller_ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(caller));
3606   if (!caller_ik->in_aot_cache()) {
3607     // there won't be a shared lambda class if the caller_ik is not in the shared archive.
3608     return nullptr;
3609   }
3610 
3611   Symbol* interface_method_name = java_lang_String::as_symbol(JNIHandles::resolve_non_null(interfaceMethodName));
3612   Handle factory_type_oop(THREAD, JNIHandles::resolve_non_null(factoryType));
3613   Symbol* factory_type = java_lang_invoke_MethodType::as_signature(factory_type_oop(), true);
3614 
3615   Handle interface_method_type_oop(THREAD, JNIHandles::resolve_non_null(interfaceMethodType));
3616   Symbol* interface_method_type = java_lang_invoke_MethodType::as_signature(interface_method_type_oop(), true);
3617 
3618   Handle implementation_member_oop(THREAD, JNIHandles::resolve_non_null(implementationMember));
3619   assert(java_lang_invoke_MemberName::is_method(implementation_member_oop()), "must be");
3620   Method* m = java_lang_invoke_MemberName::vmtarget(implementation_member_oop());
3621 
3622   Handle dynamic_method_type_oop(THREAD, JNIHandles::resolve_non_null(dynamicMethodType));
3623   Symbol* dynamic_method_type = java_lang_invoke_MethodType::as_signature(dynamic_method_type_oop(), true);
3624 
3625   InstanceKlass* loaded_lambda =
3626     LambdaProxyClassDictionary::load_shared_lambda_proxy_class(caller_ik, interface_method_name, factory_type,
3627                                                                interface_method_type, m, dynamic_method_type,
3628                                                                CHECK_(nullptr));
3629   return loaded_lambda == nullptr ? nullptr : (jclass) JNIHandles::make_local(THREAD, loaded_lambda->java_mirror());
3630 #else
3631   return nullptr;
3632 #endif // INCLUDE_CDS
3633 JVM_END
3634 
3635 JVM_ENTRY_NO_ENV(jlong, JVM_GetRandomSeedForDumping())
3636   if (CDSConfig::is_dumping_static_archive()) {
3637     // We do this so that the default CDS archive can be deterministic.
3638     const char* release = VM_Version::vm_release();
3639     const char* dbg_level = VM_Version::jdk_debug_level();
3640     const char* version = VM_Version::internal_vm_info_string();
3641     jlong seed = (jlong)(java_lang_String::hash_code((const jbyte*)release, (int)strlen(release)) ^
3642                          java_lang_String::hash_code((const jbyte*)dbg_level, (int)strlen(dbg_level)) ^
3643                          java_lang_String::hash_code((const jbyte*)version, (int)strlen(version)));
3644     seed += (jlong)VM_Version::vm_major_version();
3645     seed += (jlong)VM_Version::vm_minor_version();
3646     seed += (jlong)VM_Version::vm_security_version();
3647     seed += (jlong)VM_Version::vm_patch_version();
3648     if (seed == 0) { // don't let this ever be zero.
3649       seed = 0x87654321;
3650     }
3651     log_debug(aot)("JVM_GetRandomSeedForDumping() = " JLONG_FORMAT, seed);
3652     return seed;
3653   } else {
3654     return 0;
3655   }
3656 JVM_END
3657 
3658 JVM_ENTRY_NO_ENV(jint, JVM_GetCDSConfigStatus())
3659   return CDSConfig::get_status();
3660 JVM_END
3661 
3662 JVM_ENTRY(void, JVM_LogLambdaFormInvoker(JNIEnv *env, jstring line))
3663 #if INCLUDE_CDS
3664   assert(CDSConfig::is_logging_lambda_form_invokers(), "sanity");
3665   if (line != nullptr) {
3666     ResourceMark rm(THREAD);
3667     Handle h_line (THREAD, JNIHandles::resolve_non_null(line));
3668     char* c_line = java_lang_String::as_utf8_string(h_line());
3669     if (CDSConfig::is_dumping_dynamic_archive()) {
3670       // Note: LambdaFormInvokers::append take same format which is not
3671       // same as below the print format. The line does not include LAMBDA_FORM_TAG.
3672       LambdaFormInvokers::append(os::strdup((const char*)c_line, mtInternal));
3673     }
3674     if (ClassListWriter::is_enabled()) {
3675       ClassListWriter w;
3676       w.stream()->print_cr("%s %s", ClassListParser::lambda_form_tag(), c_line);
3677     }
3678   }
3679 #endif // INCLUDE_CDS
3680 JVM_END
3681 
3682 JVM_ENTRY(void, JVM_DumpClassListToFile(JNIEnv *env, jstring listFileName))
3683 #if INCLUDE_CDS
3684   ResourceMark rm(THREAD);
3685   Handle file_handle(THREAD, JNIHandles::resolve_non_null(listFileName));
3686   char* file_name  = java_lang_String::as_utf8_string(file_handle());
3687   AOTMetaspace::dump_loaded_classes(file_name, THREAD);
3688 #endif // INCLUDE_CDS
3689 JVM_END
3690 
3691 JVM_ENTRY(void, JVM_DumpDynamicArchive(JNIEnv *env, jstring archiveName))
3692 #if INCLUDE_CDS
3693   ResourceMark rm(THREAD);
3694   Handle file_handle(THREAD, JNIHandles::resolve_non_null(archiveName));
3695   char* archive_name  = java_lang_String::as_utf8_string(file_handle());
3696   DynamicArchive::dump_for_jcmd(archive_name, CHECK);
3697 #endif // INCLUDE_CDS
3698 JVM_END
3699 
3700 JVM_ENTRY(jboolean, JVM_NeedsClassInitBarrierForCDS(JNIEnv* env, jclass cls))
3701 #if INCLUDE_CDS
3702   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
3703   if (!k->is_instance_klass()) {
3704     return false;
3705   } else {
3706     if (InstanceKlass::cast(k)->is_enum_subclass() ||
3707         AOTClassInitializer::can_archive_initialized_mirror(InstanceKlass::cast(k))) {
3708       // This class will be cached in AOT-initialized state. No need for init barriers.
3709       return false;
3710     } else {
3711       // If we cannot cache the class in AOT-initialized state, java.lang.invoke handles
3712       // must emit barriers to ensure class initialization during production run.
3713       ResourceMark rm(THREAD);
3714       log_debug(aot)("NeedsClassInitBarrierForCDS: %s", k->external_name());
3715       return true;
3716     }
3717   }
3718 #else
3719   return false;
3720 #endif // INCLUDE_CDS
3721 JVM_END
3722 
3723 // Returns an array of all live Thread objects (VM internal JavaThreads,
3724 // jvmti agent threads, and JNI attaching threads  are skipped)
3725 // See CR 6404306 regarding JNI attaching threads
3726 JVM_ENTRY(jobjectArray, JVM_GetAllThreads(JNIEnv *env, jclass dummy))
3727   ResourceMark rm(THREAD);
3728   ThreadsListEnumerator tle(THREAD, false, false);
3729   JvmtiVMObjectAllocEventCollector oam;
3730 
3731   int num_threads = tle.num_threads();
3732   objArrayOop r = oopFactory::new_objArray(vmClasses::Thread_klass(), num_threads, CHECK_NULL);
3733   objArrayHandle threads_ah(THREAD, r);
3734 
3735   for (int i = 0; i < num_threads; i++) {
3736     Handle h = tle.get_threadObj(i);
3737     threads_ah->obj_at_put(i, h());
3738   }
3739 
3740   return (jobjectArray) JNIHandles::make_local(THREAD, threads_ah());
3741 JVM_END
3742 
3743 
3744 // Support for java.lang.Thread.getStackTrace() and getAllStackTraces() methods
3745 // Return StackTraceElement[][], each element is the stack trace of a thread in
3746 // the corresponding entry in the given threads array
3747 JVM_ENTRY(jobjectArray, JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads))
3748   JvmtiVMObjectAllocEventCollector oam;
3749 
3750   // Check if threads is null
3751   if (threads == nullptr) {
3752     THROW_NULL(vmSymbols::java_lang_NullPointerException());
3753   }
3754 
3755   refArrayOop a = oop_cast<refArrayOop>(JNIHandles::resolve_non_null(threads));
3756   refArrayHandle ah(THREAD, a);
3757   int num_threads = ah->length();
3758   // check if threads is non-empty array
3759   if (num_threads == 0) {
3760     THROW_NULL(vmSymbols::java_lang_IllegalArgumentException());
3761   }
3762 
3763   // check if threads is not an array of objects of Thread class
3764   Klass* k = ObjArrayKlass::cast(ah->klass())->element_klass();
3765   if (k != vmClasses::Thread_klass()) {
3766     THROW_NULL(vmSymbols::java_lang_IllegalArgumentException());
3767   }
3768 
3769   ResourceMark rm(THREAD);
3770 
3771   GrowableArray<instanceHandle>* thread_handle_array = new GrowableArray<instanceHandle>(num_threads);
3772   for (int i = 0; i < num_threads; i++) {
3773     oop thread_obj = ah->obj_at(i);
3774     instanceHandle h(THREAD, (instanceOop) thread_obj);
3775     thread_handle_array->append(h);
3776   }
3777 
3778   // The JavaThread references in thread_handle_array are validated
3779   // in VM_ThreadDump::doit().
3780   Handle stacktraces = ThreadService::dump_stack_traces(thread_handle_array, num_threads, CHECK_NULL);
3781   return (jobjectArray)JNIHandles::make_local(THREAD, stacktraces());
3782 
3783 JVM_END
3784 
3785 // JVM monitoring and management support
3786 JVM_LEAF(void*, JVM_GetManagement(jint version))
3787   return Management::get_jmm_interface(version);
3788 JVM_END
3789 
3790 // com.sun.tools.attach.VirtualMachine agent properties support
3791 //
3792 // Initialize the agent properties with the properties maintained in the VM
3793 JVM_ENTRY(jobject, JVM_InitAgentProperties(JNIEnv *env, jobject properties))
3794   ResourceMark rm;
3795 
3796   Handle props(THREAD, JNIHandles::resolve_non_null(properties));
3797 
3798   PUTPROP(props, "sun.java.command", Arguments::java_command());
3799   PUTPROP(props, "sun.jvm.flags", Arguments::jvm_flags());
3800   PUTPROP(props, "sun.jvm.args", Arguments::jvm_args());
3801   return properties;
3802 JVM_END
3803 
3804 JVM_ENTRY(jobjectArray, JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass))
3805 {
3806   JvmtiVMObjectAllocEventCollector oam;
3807 
3808   if (ofClass == nullptr) {
3809     return nullptr;
3810   }
3811   Handle mirror(THREAD, JNIHandles::resolve_non_null(ofClass));
3812   // Special handling for primitive objects
3813   if (java_lang_Class::is_primitive(mirror())) {
3814     return nullptr;
3815   }
3816   Klass* k = java_lang_Class::as_Klass(mirror());
3817   if (!k->is_instance_klass()) {
3818     return nullptr;
3819   }
3820   InstanceKlass* ik = InstanceKlass::cast(k);
3821   int encl_method_class_idx = ik->enclosing_method_class_index();
3822   if (encl_method_class_idx == 0) {
3823     return nullptr;
3824   }
3825   objArrayOop dest_o = oopFactory::new_objArray(vmClasses::Object_klass(), 3, CHECK_NULL);
3826   objArrayHandle dest(THREAD, dest_o);
3827   Klass* enc_k = ik->constants()->klass_at(encl_method_class_idx, CHECK_NULL);
3828   dest->obj_at_put(0, enc_k->java_mirror());
3829   int encl_method_method_idx = ik->enclosing_method_method_index();
3830   if (encl_method_method_idx != 0) {
3831     Symbol* sym = ik->constants()->symbol_at(
3832                         extract_low_short_from_int(
3833                           ik->constants()->name_and_type_at(encl_method_method_idx)));
3834     Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
3835     dest->obj_at_put(1, str());
3836     sym = ik->constants()->symbol_at(
3837               extract_high_short_from_int(
3838                 ik->constants()->name_and_type_at(encl_method_method_idx)));
3839     str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
3840     dest->obj_at_put(2, str());
3841   }
3842   return (jobjectArray) JNIHandles::make_local(THREAD, dest());
3843 }
3844 JVM_END
3845 
3846 // Returns an array of java.lang.String objects containing the input arguments to the VM.
3847 JVM_ENTRY(jobjectArray, JVM_GetVmArguments(JNIEnv *env))
3848   ResourceMark rm(THREAD);
3849 
3850   if (Arguments::num_jvm_args() == 0 && Arguments::num_jvm_flags() == 0) {
3851     return nullptr;
3852   }
3853 
3854   char** vm_flags = Arguments::jvm_flags_array();
3855   char** vm_args = Arguments::jvm_args_array();
3856   int num_flags = Arguments::num_jvm_flags();
3857   int num_args = Arguments::num_jvm_args();
3858 
3859   InstanceKlass* ik = vmClasses::String_klass();
3860   objArrayOop r = oopFactory::new_objArray(ik, num_args + num_flags, CHECK_NULL);
3861   objArrayHandle result_h(THREAD, r);
3862 
3863   int index = 0;
3864   for (int j = 0; j < num_flags; j++, index++) {
3865     Handle h = java_lang_String::create_from_platform_dependent_str(vm_flags[j], CHECK_NULL);
3866     result_h->obj_at_put(index, h());
3867   }
3868   for (int i = 0; i < num_args; i++, index++) {
3869     Handle h = java_lang_String::create_from_platform_dependent_str(vm_args[i], CHECK_NULL);
3870     result_h->obj_at_put(index, h());
3871   }
3872   return (jobjectArray) JNIHandles::make_local(THREAD, result_h());
3873 JVM_END
3874 
3875 JVM_LEAF(jint, JVM_FindSignal(const char *name))
3876   return os::get_signal_number(name);
3877 JVM_END
3878 
3879 JVM_ENTRY(void, JVM_VirtualThreadEndFirstTransition(JNIEnv* env, jobject vthread))
3880   oop vt = JNIHandles::resolve_external_guard(vthread);
3881   MountUnmountDisabler::end_transition(thread, vt, true /*is_mount*/, true /*is_thread_start*/);
3882 JVM_END
3883 
3884 JVM_ENTRY(void, JVM_VirtualThreadStartFinalTransition(JNIEnv* env, jobject vthread))
3885   oop vt = JNIHandles::resolve_external_guard(vthread);
3886   MountUnmountDisabler::start_transition(thread, vt, false /*is_mount */, true /*is_thread_end*/);
3887 JVM_END
3888 
3889 JVM_ENTRY(void, JVM_VirtualThreadStartTransition(JNIEnv* env, jobject vthread, jboolean is_mount))
3890   oop vt = JNIHandles::resolve_external_guard(vthread);
3891   MountUnmountDisabler::start_transition(thread, vt, is_mount, false /*is_thread_end*/);
3892 JVM_END
3893 
3894 JVM_ENTRY(void, JVM_VirtualThreadEndTransition(JNIEnv* env, jobject vthread, jboolean is_mount))
3895   oop vt = JNIHandles::resolve_external_guard(vthread);
3896   MountUnmountDisabler::end_transition(thread, vt, is_mount, false /*is_thread_start*/);
3897 JVM_END
3898 
3899 // Notification from VirtualThread about disabling JVMTI Suspend in a sync critical section.
3900 // Needed to avoid deadlocks with JVMTI suspend mechanism.
3901 JVM_ENTRY(void, JVM_VirtualThreadDisableSuspend(JNIEnv* env, jclass clazz, jboolean enter))
3902 #if INCLUDE_JVMTI
3903   if (!DoJVMTIVirtualThreadTransitions) {
3904     assert(!JvmtiExport::can_support_virtual_threads(), "sanity check");
3905     return;
3906   }
3907   assert(thread->is_disable_suspend() != (bool)enter,
3908          "nested or unbalanced monitor enter/exit is not allowed");
3909   thread->toggle_is_disable_suspend();
3910 #endif
3911 JVM_END
3912 
3913 JVM_ENTRY(void, JVM_VirtualThreadPinnedEvent(JNIEnv* env, jclass ignored, jstring op))
3914 #if INCLUDE_JFR
3915   freeze_result result = THREAD->last_freeze_fail_result();
3916   assert(result != freeze_ok, "sanity check");
3917   EventVirtualThreadPinned event(UNTIMED);
3918   event.set_starttime(THREAD->last_freeze_fail_time());
3919   if (event.should_commit()) {
3920     ResourceMark rm(THREAD);
3921     const char *str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(op));
3922     THREAD->post_vthread_pinned_event(&event, str, result);
3923   }
3924 #endif
3925 JVM_END
3926 
3927 JVM_ENTRY(jobject, JVM_TakeVirtualThreadListToUnblock(JNIEnv* env, jclass ignored))
3928   ParkEvent* parkEvent = ObjectMonitor::vthread_unparker_ParkEvent();
3929   assert(parkEvent != nullptr, "not initialized");
3930 
3931   OopHandle& list_head = ObjectMonitor::vthread_list_head();
3932   oop vthread_head = nullptr;
3933   while (true) {
3934     if (list_head.peek() != nullptr) {
3935       for (;;) {
3936         oop head = list_head.resolve();
3937         if (list_head.cmpxchg(head, nullptr) == head) {
3938           return JNIHandles::make_local(THREAD, head);
3939         }
3940       }
3941     }
3942     ThreadBlockInVM tbivm(THREAD);
3943     parkEvent->park();
3944   }
3945 JVM_END
3946 
3947 /*
3948  * Return the current class's class file version.  The low order 16 bits of the
3949  * returned jint contain the class's major version.  The high order 16 bits
3950  * contain the class's minor version.
3951  */
3952 JVM_ENTRY(jint, JVM_GetClassFileVersion(JNIEnv* env, jclass current))
3953   oop mirror = JNIHandles::resolve_non_null(current);
3954   if (java_lang_Class::is_primitive(mirror)) {
3955     // return latest major version and minor version of 0.
3956     return JVM_CLASSFILE_MAJOR_VERSION;
3957   }
3958   InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror);
3959   return (ik->minor_version() << 16) | ik->major_version();
3960 JVM_END
3961 
3962 /*
3963  * Ensure that code doing a stackwalk and using javaVFrame::locals() to
3964  * get the value will see a materialized value and not a scalar-replaced
3965  * null value.
3966  */
3967 JVM_ENTRY(void, JVM_EnsureMaterializedForStackWalk_func(JNIEnv* env, jobject vthread, jobject value))
3968   JVM_EnsureMaterializedForStackWalk(env, value);
3969 JVM_END
3970 
3971 /*
3972  * Return JNI_TRUE if warnings are printed when agents are dynamically loaded.
3973  */
3974 JVM_LEAF(jboolean, JVM_PrintWarningAtDynamicAgentLoad(void))
3975   return (EnableDynamicAgentLoading && !FLAG_IS_CMDLINE(EnableDynamicAgentLoading)) ? JNI_TRUE : JNI_FALSE;
3976 JVM_END
--- EOF ---