1 /* 2 * Copyright (c) 1997, 2025, 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/instanceKlass.hpp" 63 #include "oops/klass.inline.hpp" 64 #include "oops/method.hpp" 65 #include "oops/objArrayKlass.hpp" 66 #include "oops/objArrayOop.inline.hpp" 67 #include "oops/oop.inline.hpp" 68 #include "oops/recordComponent.hpp" 69 #include "oops/refArrayOop.inline.hpp" 70 #include "prims/foreignGlobals.hpp" 71 #include "prims/jvm_misc.hpp" 72 #include "prims/jvmtiExport.hpp" 73 #include "prims/jvmtiThreadState.inline.hpp" 74 #include "prims/stackwalk.hpp" 75 #include "runtime/arguments.hpp" 76 #include "runtime/atomicAccess.hpp" 77 #include "runtime/continuation.hpp" 78 #include "runtime/deoptimization.hpp" 79 #include "runtime/globals_extension.hpp" 80 #include "runtime/handles.inline.hpp" 81 #include "runtime/handshake.hpp" 82 #include "runtime/init.hpp" 83 #include "runtime/interfaceSupport.inline.hpp" 84 #include "runtime/java.hpp" 85 #include "runtime/javaCalls.hpp" 86 #include "runtime/javaThread.hpp" 87 #include "runtime/jfieldIDWorkaround.hpp" 88 #include "runtime/jniHandles.inline.hpp" 89 #include "runtime/os.inline.hpp" 90 #include "runtime/osThread.hpp" 91 #include "runtime/perfData.hpp" 92 #include "runtime/reflection.hpp" 93 #include "runtime/synchronizer.hpp" 94 #include "runtime/threadIdentifier.hpp" 95 #include "runtime/threadSMR.hpp" 96 #include "runtime/vframe.inline.hpp" 97 #include "runtime/vm_version.hpp" 98 #include "runtime/vmOperations.hpp" 99 #include "services/attachListener.hpp" 100 #include "services/management.hpp" 101 #include "services/threadService.hpp" 102 #include "utilities/checkedCast.hpp" 103 #include "utilities/copy.hpp" 104 #include "utilities/defaultStream.hpp" 105 #include "utilities/dtrace.hpp" 106 #include "utilities/events.hpp" 107 #include "utilities/macros.hpp" 108 #include "utilities/utf8.hpp" 109 #include "utilities/zipLibrary.hpp" 110 #if INCLUDE_CDS 111 #include "classfile/systemDictionaryShared.hpp" 112 #endif 113 #if INCLUDE_JFR 114 #include "jfr/jfr.hpp" 115 #endif 116 #if INCLUDE_MANAGEMENT 117 #include "services/finalizerService.hpp" 118 #endif 119 #ifdef LINUX 120 #include "osContainer_linux.hpp" 121 #endif 122 123 #include <errno.h> 124 125 /* 126 NOTE about use of any ctor or function call that can trigger a safepoint/GC: 127 such ctors and calls MUST NOT come between an oop declaration/init and its 128 usage because if objects are move this may cause various memory stomps, bus 129 errors and segfaults. Here is a cookbook for causing so called "naked oop 130 failures": 131 132 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields<etc> { 133 // Object address to be held directly in mirror & not visible to GC 134 oop mirror = JNIHandles::resolve_non_null(ofClass); 135 136 // If this ctor can hit a safepoint, moving objects around, then 137 ComplexConstructor foo; 138 139 // Boom! mirror may point to JUNK instead of the intended object 140 (some dereference of mirror) 141 142 // Here's another call that may block for GC, making mirror stale 143 MutexLocker ml(some_lock); 144 145 // And here's an initializer that can result in a stale oop 146 // all in one step. 147 oop o = call_that_can_throw_exception(TRAPS); 148 149 150 The solution is to keep the oop declaration BELOW the ctor or function 151 call that might cause a GC, do another resolve to reassign the oop, or 152 consider use of a Handle instead of an oop so there is immunity from object 153 motion. But note that the "QUICK" entries below do not have a handlemark 154 and thus can only support use of handles passed in. 155 */ 156 157 extern void trace_class_resolution(Klass* to_class) { 158 ResourceMark rm; 159 int line_number = -1; 160 const char * source_file = nullptr; 161 const char * trace = "explicit"; 162 InstanceKlass* caller = nullptr; 163 JavaThread* jthread = JavaThread::current(); 164 if (jthread->has_last_Java_frame()) { 165 vframeStream vfst(jthread); 166 167 // Scan up the stack skipping ClassLoader frames. 168 Method* last_caller = nullptr; 169 170 while (!vfst.at_end()) { 171 Method* m = vfst.method(); 172 if (!vfst.method()->method_holder()->is_subclass_of(vmClasses::ClassLoader_klass())) { 173 break; 174 } 175 last_caller = m; 176 vfst.next(); 177 } 178 // if this is called from Class.forName0 and that is called from Class.forName, 179 // then print the caller of Class.forName. If this is Class.loadClass, then print 180 // that caller, otherwise keep quiet since this should be picked up elsewhere. 181 bool found_it = false; 182 if (!vfst.at_end() && 183 vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() && 184 vfst.method()->name() == vmSymbols::forName0_name()) { 185 vfst.next(); 186 if (!vfst.at_end() && 187 vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() && 188 vfst.method()->name() == vmSymbols::forName_name()) { 189 vfst.next(); 190 found_it = true; 191 } 192 } else if (last_caller != nullptr && 193 last_caller->method_holder()->name() == 194 vmSymbols::java_lang_ClassLoader() && 195 last_caller->name() == vmSymbols::loadClass_name()) { 196 found_it = true; 197 } else if (!vfst.at_end()) { 198 if (vfst.method()->is_native()) { 199 // JNI call 200 found_it = true; 201 } 202 } 203 if (found_it && !vfst.at_end()) { 204 // found the caller 205 caller = vfst.method()->method_holder(); 206 line_number = vfst.method()->line_number_from_bci(vfst.bci()); 207 if (line_number == -1) { 208 // show method name if it's a native method 209 trace = vfst.method()->name_and_sig_as_C_string(); 210 } 211 Symbol* s = caller->source_file_name(); 212 if (s != nullptr) { 213 source_file = s->as_C_string(); 214 } 215 } 216 } 217 if (caller != nullptr) { 218 if (to_class != caller) { 219 const char * from = caller->external_name(); 220 const char * to = to_class->external_name(); 221 // print in a single call to reduce interleaving between threads 222 if (source_file != nullptr) { 223 log_debug(class, resolve)("%s %s %s:%d (%s)", from, to, source_file, line_number, trace); 224 } else { 225 log_debug(class, resolve)("%s %s (%s)", from, to, trace); 226 } 227 } 228 } 229 } 230 231 // java.lang.System ////////////////////////////////////////////////////////////////////// 232 233 234 JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)) 235 return os::javaTimeMillis(); 236 JVM_END 237 238 JVM_LEAF(jlong, JVM_NanoTime(JNIEnv *env, jclass ignored)) 239 return os::javaTimeNanos(); 240 JVM_END 241 242 // The function below is actually exposed by jdk.internal.misc.VM and not 243 // java.lang.System, but we choose to keep it here so that it stays next 244 // to JVM_CurrentTimeMillis and JVM_NanoTime 245 246 const jlong MAX_DIFF_SECS = CONST64(0x0100000000); // 2^32 247 const jlong MIN_DIFF_SECS = -MAX_DIFF_SECS; // -2^32 248 249 JVM_LEAF(jlong, JVM_GetNanoTimeAdjustment(JNIEnv *env, jclass ignored, jlong offset_secs)) 250 jlong seconds; 251 jlong nanos; 252 253 os::javaTimeSystemUTC(seconds, nanos); 254 255 // We're going to verify that the result can fit in a long. 256 // For that we need the difference in seconds between 'seconds' 257 // and 'offset_secs' to be such that: 258 // |seconds - offset_secs| < (2^63/10^9) 259 // We're going to approximate 10^9 ~< 2^30 (1000^3 ~< 1024^3) 260 // which makes |seconds - offset_secs| < 2^33 261 // and we will prefer +/- 2^32 as the maximum acceptable diff 262 // as 2^32 has a more natural feel than 2^33... 263 // 264 // So if |seconds - offset_secs| >= 2^32 - we return a special 265 // sentinel value (-1) which the caller should take as an 266 // exception value indicating that the offset given to us is 267 // too far from range of the current time - leading to too big 268 // a nano adjustment. The caller is expected to recover by 269 // computing a more accurate offset and calling this method 270 // again. (For the record 2^32 secs is ~136 years, so that 271 // should rarely happen) 272 // 273 jlong diff = seconds - offset_secs; 274 if (diff >= MAX_DIFF_SECS || diff <= MIN_DIFF_SECS) { 275 return -1; // sentinel value: the offset is too far off the target 276 } 277 278 // return the adjustment. If you compute a time by adding 279 // this number of nanoseconds along with the number of seconds 280 // in the offset you should get the current UTC time. 281 return (diff * (jlong)1000000000) + nanos; 282 JVM_END 283 284 JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, 285 jobject dst, jint dst_pos, jint length)) 286 // Check if we have null pointers 287 if (src == nullptr || dst == nullptr) { 288 THROW(vmSymbols::java_lang_NullPointerException()); 289 } 290 arrayOop s = arrayOop(JNIHandles::resolve_non_null(src)); 291 arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst)); 292 assert(oopDesc::is_oop(s), "JVM_ArrayCopy: src not an oop"); 293 assert(oopDesc::is_oop(d), "JVM_ArrayCopy: dst not an oop"); 294 // Do copy 295 s->klass()->copy_array(s, src_pos, d, dst_pos, length, thread); 296 JVM_END 297 298 299 static void set_property(Handle props, const char* key, const char* value, TRAPS) { 300 JavaValue r(T_OBJECT); 301 // public synchronized Object put(Object key, Object value); 302 HandleMark hm(THREAD); 303 Handle key_str = java_lang_String::create_from_platform_dependent_str(key, CHECK); 304 Handle value_str = java_lang_String::create_from_platform_dependent_str((value != nullptr ? value : ""), CHECK); 305 JavaCalls::call_virtual(&r, 306 props, 307 vmClasses::Properties_klass(), 308 vmSymbols::put_name(), 309 vmSymbols::object_object_object_signature(), 310 key_str, 311 value_str, 312 THREAD); 313 } 314 315 316 #define PUTPROP(props, name, value) set_property((props), (name), (value), CHECK_(properties)); 317 318 /* 319 * Return all of the system properties in a Java String array with alternating 320 * names and values from the jvm SystemProperty. 321 * Which includes some internal and all commandline -D defined properties. 322 */ 323 JVM_ENTRY(jobjectArray, JVM_GetProperties(JNIEnv *env)) 324 ResourceMark rm(THREAD); 325 HandleMark hm(THREAD); 326 int ndx = 0; 327 int fixedCount = 2; 328 329 SystemProperty* p = Arguments::system_properties(); 330 int count = Arguments::PropertyList_count(p); 331 332 // Allocate result String array 333 InstanceKlass* ik = vmClasses::String_klass(); 334 objArrayOop r = oopFactory::new_objArray(ik, (count + fixedCount) * 2, CHECK_NULL); 335 objArrayHandle result_h(THREAD, r); 336 337 while (p != nullptr) { 338 const char * key = p->key(); 339 if (strcmp(key, "sun.nio.MaxDirectMemorySize") != 0) { 340 const char * value = p->value(); 341 Handle key_str = java_lang_String::create_from_platform_dependent_str(key, CHECK_NULL); 342 Handle value_str = java_lang_String::create_from_platform_dependent_str((value != nullptr ? value : ""), CHECK_NULL); 343 result_h->obj_at_put(ndx * 2, key_str()); 344 result_h->obj_at_put(ndx * 2 + 1, value_str()); 345 ndx++; 346 } 347 p = p->next(); 348 } 349 350 // Convert the -XX:MaxDirectMemorySize= command line flag 351 // to the sun.nio.MaxDirectMemorySize property. 352 // Do this after setting user properties to prevent people 353 // from setting the value with a -D option, as requested. 354 // Leave empty if not supplied 355 if (!FLAG_IS_DEFAULT(MaxDirectMemorySize)) { 356 char as_chars[256]; 357 jio_snprintf(as_chars, sizeof(as_chars), JULONG_FORMAT, MaxDirectMemorySize); 358 Handle key_str = java_lang_String::create_from_platform_dependent_str("sun.nio.MaxDirectMemorySize", CHECK_NULL); 359 Handle value_str = java_lang_String::create_from_platform_dependent_str(as_chars, CHECK_NULL); 360 result_h->obj_at_put(ndx * 2, key_str()); 361 result_h->obj_at_put(ndx * 2 + 1, value_str()); 362 ndx++; 363 } 364 365 // JVM monitoring and management support 366 // Add the sun.management.compiler property for the compiler's name 367 { 368 #undef CSIZE 369 #if defined(_LP64) 370 #define CSIZE "64-Bit " 371 #else 372 #define CSIZE 373 #endif // 64bit 374 375 #if COMPILER1_AND_COMPILER2 376 const char* compiler_name = "HotSpot " CSIZE "Tiered Compilers"; 377 #else 378 #if defined(COMPILER1) 379 const char* compiler_name = "HotSpot " CSIZE "Client Compiler"; 380 #elif defined(COMPILER2) 381 const char* compiler_name = "HotSpot " CSIZE "Server Compiler"; 382 #elif INCLUDE_JVMCI 383 #error "INCLUDE_JVMCI should imply COMPILER1_OR_COMPILER2" 384 #else 385 const char* compiler_name = ""; 386 #endif // compilers 387 #endif // COMPILER1_AND_COMPILER2 388 389 if (*compiler_name != '\0' && 390 (Arguments::mode() != Arguments::_int)) { 391 Handle key_str = java_lang_String::create_from_platform_dependent_str("sun.management.compiler", CHECK_NULL); 392 Handle value_str = java_lang_String::create_from_platform_dependent_str(compiler_name, CHECK_NULL); 393 result_h->obj_at_put(ndx * 2, key_str()); 394 result_h->obj_at_put(ndx * 2 + 1, value_str()); 395 ndx++; 396 } 397 } 398 399 return (jobjectArray) JNIHandles::make_local(THREAD, result_h()); 400 JVM_END 401 402 403 /* 404 * Return the temporary directory that the VM uses for the attach 405 * and perf data files. 406 * 407 * It is important that this directory is well-known and the 408 * same for all VM instances. It cannot be affected by configuration 409 * variables such as java.io.tmpdir. 410 */ 411 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env)) 412 HandleMark hm(THREAD); 413 const char* temp_dir = os::get_temp_directory(); 414 Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL); 415 return (jstring) JNIHandles::make_local(THREAD, h()); 416 JVM_END 417 418 static void validate_array_arguments(Klass* elmClass, jint len, TRAPS) { 419 if (len < 0) { 420 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Array length is negative"); 421 } 422 elmClass->initialize(CHECK); 423 if (elmClass->is_array_klass() || elmClass->is_identity_class()) { 424 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Element class is not a value class"); 425 } 426 if (elmClass->is_abstract()) { 427 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Element class is abstract"); 428 } 429 } 430 431 JVM_ENTRY(jarray, JVM_CopyOfSpecialArray(JNIEnv *env, jarray orig, jint from, jint to)) 432 oop o = JNIHandles::resolve_non_null(orig); 433 assert(o->is_array(), "Must be"); 434 oop array = nullptr; 435 arrayOop org = (arrayOop)o; 436 arrayHandle oh(THREAD, org); 437 ObjArrayKlass* ak = ObjArrayKlass::cast(org->klass()); 438 InlineKlass* vk = InlineKlass::cast(ak->element_klass()); 439 int len = to - from; // length of the new array 440 if (ak->is_null_free_array_klass()) { 441 if ((len != 0) && (from >= org->length() || to > org->length())) { 442 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Copying of null-free array with uninitialized elements"); 443 } 444 } 445 if (org->is_flatArray()) { 446 FlatArrayKlass* fak = FlatArrayKlass::cast(org->klass()); 447 LayoutKind lk = fak->layout_kind(); 448 ArrayKlass::ArrayProperties props = ArrayKlass::array_properties_from_layout(lk); 449 array = oopFactory::new_flatArray(vk, len, props, lk, CHECK_NULL); 450 arrayHandle ah(THREAD, (arrayOop)array); 451 int end = to < oh()->length() ? to : oh()->length(); 452 for (int i = from; i < end; i++) { 453 void* src = ((flatArrayOop)oh())->value_at_addr(i, fak->layout_helper()); 454 void* dst = ((flatArrayOop)ah())->value_at_addr(i - from, fak->layout_helper()); 455 vk->copy_payload_to_addr(src, dst, lk, false); 456 } 457 array = ah(); 458 } else { 459 ArrayKlass::ArrayProperties props = org->is_null_free_array() ? ArrayKlass::ArrayProperties::NULL_RESTRICTED : ArrayKlass::ArrayProperties::DEFAULT; 460 array = oopFactory::new_objArray(vk, len, props, CHECK_NULL); 461 int end = to < oh()->length() ? to : oh()->length(); 462 for (int i = from; i < end; i++) { 463 if (i < ((objArrayOop)oh())->length()) { 464 ((objArrayOop)array)->obj_at_put(i - from, ((objArrayOop)oh())->obj_at(i)); 465 } else { 466 assert(!ak->is_null_free_array_klass(), "Must be a nullable array"); 467 ((objArrayOop)array)->obj_at_put(i - from, nullptr); 468 } 469 } 470 } 471 return (jarray) JNIHandles::make_local(THREAD, array); 472 JVM_END 473 474 JVM_ENTRY(jarray, JVM_NewNullRestrictedNonAtomicArray(JNIEnv *env, jclass elmClass, jint len, jobject initVal)) 475 oop mirror = JNIHandles::resolve_non_null(elmClass); 476 oop init = JNIHandles::resolve(initVal); 477 if (init == nullptr) { 478 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Initial value cannot be null"); 479 } 480 Handle init_h(THREAD, init); 481 Klass* klass = java_lang_Class::as_Klass(mirror); 482 if (klass != init_h()->klass()) { 483 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Type mismatch between array and initial value"); 484 } 485 validate_array_arguments(klass, len, CHECK_NULL); 486 InlineKlass* vk = InlineKlass::cast(klass); 487 ArrayKlass::ArrayProperties props = (ArrayKlass::ArrayProperties)(ArrayKlass::ArrayProperties::NON_ATOMIC | ArrayKlass::ArrayProperties::NULL_RESTRICTED); 488 objArrayOop array = oopFactory::new_objArray(klass, len, props, CHECK_NULL); 489 for (int i = 0; i < len; i++) { 490 array->obj_at_put(i, init_h() /*, CHECK_NULL*/ ); 491 } 492 return (jarray) JNIHandles::make_local(THREAD, array); 493 JVM_END 494 495 JVM_ENTRY(jarray, JVM_NewNullRestrictedAtomicArray(JNIEnv *env, jclass elmClass, jint len, jobject initVal)) 496 oop mirror = JNIHandles::resolve_non_null(elmClass); 497 oop init = JNIHandles::resolve(initVal); 498 if (init == nullptr) { 499 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Initial value cannot be null"); 500 } 501 Handle init_h(THREAD, init); 502 Klass* klass = java_lang_Class::as_Klass(mirror); 503 if (klass != init_h()->klass()) { 504 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Type mismatch between array and initial value"); 505 } 506 validate_array_arguments(klass, len, CHECK_NULL); 507 InlineKlass* vk = InlineKlass::cast(klass); 508 ArrayKlass::ArrayProperties props = (ArrayKlass::ArrayProperties)(ArrayKlass::ArrayProperties::NULL_RESTRICTED); 509 objArrayOop array = oopFactory::new_objArray(klass, len, props, CHECK_NULL); 510 for (int i = 0; i < len; i++) { 511 array->obj_at_put(i, init_h() /*, CHECK_NULL*/ ); 512 } 513 return (jarray) JNIHandles::make_local(THREAD, array); 514 JVM_END 515 516 JVM_ENTRY(jarray, JVM_NewNullableAtomicArray(JNIEnv *env, jclass elmClass, jint len)) 517 oop mirror = JNIHandles::resolve_non_null(elmClass); 518 Klass* klass = java_lang_Class::as_Klass(mirror); 519 klass->initialize(CHECK_NULL); 520 validate_array_arguments(klass, len, CHECK_NULL); 521 InlineKlass* vk = InlineKlass::cast(klass); 522 ArrayKlass::ArrayProperties props = (ArrayKlass::ArrayProperties)(ArrayKlass::ArrayProperties::DEFAULT); 523 objArrayOop array = oopFactory::new_objArray(klass, len, props, CHECK_NULL); 524 return (jarray) JNIHandles::make_local(THREAD, array); 525 JVM_END 526 527 JVM_ENTRY(jboolean, JVM_IsFlatArray(JNIEnv *env, jobject obj)) 528 arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj)); 529 return oop->is_flatArray(); 530 JVM_END 531 532 JVM_ENTRY(jboolean, JVM_IsNullRestrictedArray(JNIEnv *env, jobject obj)) 533 arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj)); 534 return oop->is_null_free_array(); 535 JVM_END 536 537 JVM_ENTRY(jboolean, JVM_IsAtomicArray(JNIEnv *env, jobject obj)) 538 // There are multiple cases where an array can/must support atomic access: 539 // - the array is a reference array 540 // - the array uses an atomic flat layout: NULLABLE_ATOMIC_FLAT or ATOMIC_FLAT 541 // - the array is flat and its component type is naturally atomic 542 arrayOop oop = arrayOop(JNIHandles::resolve_non_null(obj)); 543 if (oop->is_refArray()) return true; 544 if (oop->is_flatArray()) { 545 FlatArrayKlass* fak = FlatArrayKlass::cast(oop->klass()); 546 if (LayoutKindHelper::is_atomic_flat(fak->layout_kind())) return true; 547 if (fak->element_klass()->is_naturally_atomic()) return true; 548 } 549 return false; 550 JVM_END 551 552 // java.lang.Runtime ///////////////////////////////////////////////////////////////////////// 553 554 extern volatile jint vm_created; 555 556 JVM_ENTRY_NO_ENV(void, JVM_BeforeHalt()) 557 EventShutdown event; 558 if (event.should_commit()) { 559 event.set_reason("Shutdown requested from Java"); 560 event.commit(); 561 } 562 JVM_END 563 564 565 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code)) 566 before_exit(thread, true); 567 vm_exit(code); 568 JVM_END 569 570 571 JVM_ENTRY_NO_ENV(void, JVM_GC(void)) 572 if (!DisableExplicitGC) { 573 EventSystemGC event; 574 event.set_invokedConcurrent(ExplicitGCInvokesConcurrent); 575 Universe::heap()->collect(GCCause::_java_lang_system_gc); 576 event.commit(); 577 } 578 JVM_END 579 580 581 JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void)) 582 return Universe::heap()->millis_since_last_whole_heap_examined(); 583 JVM_END 584 585 586 static inline jlong convert_size_t_to_jlong(size_t val) { 587 // In the 64-bit vm, a size_t can overflow a jlong (which is signed). 588 NOT_LP64 (return (jlong)val;) 589 LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);) 590 } 591 592 JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void)) 593 size_t n = Universe::heap()->capacity(); 594 return convert_size_t_to_jlong(n); 595 JVM_END 596 597 598 JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void)) 599 size_t n = Universe::heap()->unused(); 600 return convert_size_t_to_jlong(n); 601 JVM_END 602 603 604 JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void)) 605 size_t n = Universe::heap()->max_capacity(); 606 return convert_size_t_to_jlong(n); 607 JVM_END 608 609 610 JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void)) 611 return os::active_processor_count(); 612 JVM_END 613 614 JVM_LEAF(jboolean, JVM_IsUseContainerSupport(void)) 615 #ifdef LINUX 616 if (UseContainerSupport) { 617 return JNI_TRUE; 618 } 619 #endif 620 return JNI_FALSE; 621 JVM_END 622 623 JVM_LEAF(jboolean, JVM_IsContainerized(void)) 624 #ifdef LINUX 625 if (OSContainer::is_containerized()) { 626 return JNI_TRUE; 627 } 628 #endif 629 return JNI_FALSE; 630 JVM_END 631 632 // java.lang.Throwable ////////////////////////////////////////////////////// 633 634 JVM_ENTRY(void, JVM_FillInStackTrace(JNIEnv *env, jobject receiver)) 635 Handle exception(thread, JNIHandles::resolve_non_null(receiver)); 636 java_lang_Throwable::fill_in_stack_trace(exception); 637 JVM_END 638 639 // java.lang.NullPointerException /////////////////////////////////////////// 640 641 JVM_ENTRY(jstring, JVM_GetExtendedNPEMessage(JNIEnv *env, jthrowable throwable)) 642 if (!ShowCodeDetailsInExceptionMessages) return nullptr; 643 644 oop exc = JNIHandles::resolve_non_null(throwable); 645 646 Method* method; 647 int bci; 648 if (!java_lang_Throwable::get_top_method_and_bci(exc, &method, &bci)) { 649 return nullptr; 650 } 651 if (method->is_native()) { 652 return nullptr; 653 } 654 655 stringStream ss; 656 bool ok = BytecodeUtils::get_NPE_message_at(&ss, method, bci); 657 if (ok) { 658 oop result = java_lang_String::create_oop_from_str(ss.base(), CHECK_NULL); 659 return (jstring) JNIHandles::make_local(THREAD, result); 660 } else { 661 return nullptr; 662 } 663 JVM_END 664 665 // java.lang.StackTraceElement ////////////////////////////////////////////// 666 667 668 JVM_ENTRY(void, JVM_InitStackTraceElementArray(JNIEnv *env, jobjectArray elements, jobject backtrace, jint depth)) 669 Handle backtraceh(THREAD, JNIHandles::resolve(backtrace)); 670 objArrayOop st = objArrayOop(JNIHandles::resolve(elements)); 671 objArrayHandle stack_trace(THREAD, st); 672 // Fill in the allocated stack trace 673 java_lang_Throwable::get_stack_trace_elements(depth, backtraceh, stack_trace, CHECK); 674 JVM_END 675 676 677 JVM_ENTRY(void, JVM_InitStackTraceElement(JNIEnv* env, jobject element, jobject stackFrameInfo)) 678 Handle stack_frame_info(THREAD, JNIHandles::resolve_non_null(stackFrameInfo)); 679 Handle stack_trace_element(THREAD, JNIHandles::resolve_non_null(element)); 680 java_lang_StackFrameInfo::to_stack_trace_element(stack_frame_info, stack_trace_element, CHECK); 681 JVM_END 682 683 684 // java.lang.StackWalker ////////////////////////////////////////////////////// 685 JVM_ENTRY(void, JVM_ExpandStackFrameInfo(JNIEnv *env, jobject obj)) 686 Handle stack_frame_info(THREAD, JNIHandles::resolve_non_null(obj)); 687 688 bool have_name = (java_lang_StackFrameInfo::name(stack_frame_info()) != nullptr); 689 bool have_type = (java_lang_StackFrameInfo::type(stack_frame_info()) != nullptr); 690 Method* method = java_lang_StackFrameInfo::get_method(stack_frame_info()); 691 if (!have_name) { 692 oop name = StringTable::intern(method->name(), CHECK); 693 java_lang_StackFrameInfo::set_name(stack_frame_info(), name); 694 } 695 if (!have_type) { 696 Handle type = java_lang_String::create_from_symbol(method->signature(), CHECK); 697 java_lang_StackFrameInfo::set_type(stack_frame_info(), type()); 698 } 699 JVM_END 700 701 JVM_ENTRY(jobject, JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jint mode, 702 jint skip_frames, jobject contScope, jobject cont, 703 jint buffer_size, jint start_index, jobjectArray frames)) 704 if (!thread->has_last_Java_frame()) { 705 THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: no stack trace", nullptr); 706 } 707 708 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream)); 709 Handle contScope_h(THREAD, JNIHandles::resolve(contScope)); 710 Handle cont_h(THREAD, JNIHandles::resolve(cont)); 711 // frames array is a ClassFrameInfo[] array when only getting caller reference, 712 // and a StackFrameInfo[] array (or derivative) otherwise. It should never 713 // be null. 714 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames)); 715 objArrayHandle frames_array_h(THREAD, fa); 716 717 if (frames_array_h->length() < buffer_size) { 718 THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers", nullptr); 719 } 720 721 oop result = StackWalk::walk(stackStream_h, mode, skip_frames, contScope_h, cont_h, 722 buffer_size, start_index, frames_array_h, CHECK_NULL); 723 return JNIHandles::make_local(THREAD, result); 724 JVM_END 725 726 727 JVM_ENTRY(jint, JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jint mode, jlong anchor, 728 jint last_batch_count, jint buffer_size, jint start_index, 729 jobjectArray frames)) 730 // frames array is a ClassFrameInfo[] array when only getting caller reference, 731 // and a StackFrameInfo[] array (or derivative) otherwise. It should never 732 // be null. 733 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames)); 734 objArrayHandle frames_array_h(THREAD, fa); 735 736 if (frames_array_h->length() < buffer_size) { 737 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers"); 738 } 739 740 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream)); 741 return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, last_batch_count, buffer_size, 742 start_index, frames_array_h, THREAD); 743 JVM_END 744 745 JVM_ENTRY(void, JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont)) 746 objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames)); 747 objArrayHandle frames_array_h(THREAD, fa); 748 Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream)); 749 Handle cont_h(THREAD, JNIHandles::resolve_non_null(cont)); 750 751 StackWalk::setContinuation(stackStream_h, anchor, frames_array_h, cont_h, THREAD); 752 JVM_END 753 754 // java.lang.Object /////////////////////////////////////////////// 755 756 757 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle)) 758 // as implemented in the classic virtual machine; return 0 if object is null 759 if (handle == nullptr) { 760 return 0; 761 } 762 oop obj = JNIHandles::resolve_non_null(handle); 763 if (EnableValhalla && obj->klass()->is_inline_klass()) { 764 JavaValue result(T_INT); 765 JavaCallArguments args; 766 Handle ho(THREAD, obj); 767 args.push_oop(ho); 768 methodHandle method(THREAD, Universe::value_object_hash_code_method()); 769 JavaCalls::call(&result, method, &args, THREAD); 770 if (HAS_PENDING_EXCEPTION) { 771 if (!PENDING_EXCEPTION->is_a(vmClasses::Error_klass())) { 772 Handle e(THREAD, PENDING_EXCEPTION); 773 CLEAR_PENDING_EXCEPTION; 774 THROW_MSG_CAUSE_(vmSymbols::java_lang_InternalError(), "Internal error in hashCode", e, false); 775 } 776 } 777 return result.get_jint(); 778 } else { 779 return checked_cast<jint>(ObjectSynchronizer::FastHashCode(THREAD, obj)); 780 } 781 JVM_END 782 783 784 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)) 785 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); 786 ObjectSynchronizer::wait(obj, ms, CHECK); 787 JVM_END 788 789 790 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle)) 791 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); 792 ObjectSynchronizer::notify(obj, CHECK); 793 JVM_END 794 795 796 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)) 797 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); 798 ObjectSynchronizer::notifyall(obj, CHECK); 799 JVM_END 800 801 802 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle)) 803 Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); 804 Klass* klass = obj->klass(); 805 JvmtiVMObjectAllocEventCollector oam; 806 807 #ifdef ASSERT 808 // Just checking that the cloneable flag is set correct 809 if (obj->is_array()) { 810 guarantee(klass->is_cloneable(), "all arrays are cloneable"); 811 } else { 812 guarantee(obj->is_instance(), "should be instanceOop"); 813 bool cloneable = klass->is_subtype_of(vmClasses::Cloneable_klass()); 814 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag"); 815 } 816 #endif 817 818 // Check if class of obj supports the Cloneable interface. 819 // All arrays are considered to be cloneable (See JLS 20.1.5). 820 // All j.l.r.Reference classes are considered non-cloneable. 821 if (!klass->is_cloneable() || 822 (klass->is_instance_klass() && 823 InstanceKlass::cast(klass)->reference_type() != REF_NONE)) { 824 ResourceMark rm(THREAD); 825 THROW_MSG_NULL(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name()); 826 } 827 828 if (klass->is_inline_klass()) { 829 // Value instances have no identity, so return the current instance instead of allocating a new one 830 // Value classes cannot have finalizers, so the method can return immediately 831 return JNIHandles::make_local(THREAD, obj()); 832 } 833 834 // Make shallow object copy 835 const size_t size = obj->size(); 836 oop new_obj_oop = nullptr; 837 if (obj->is_array()) { 838 const int length = ((arrayOop)obj())->length(); 839 new_obj_oop = Universe::heap()->array_allocate(klass, size, length, 840 /* do_zero */ true, CHECK_NULL); 841 } else { 842 new_obj_oop = Universe::heap()->obj_allocate(klass, size, CHECK_NULL); 843 } 844 845 HeapAccess<>::clone(obj(), new_obj_oop, size); 846 847 Handle new_obj(THREAD, new_obj_oop); 848 // Caution: this involves a java upcall, so the clone should be 849 // "gc-robust" by this stage. 850 if (klass->has_finalizer()) { 851 assert(obj->is_instance(), "should be instanceOop"); 852 new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL); 853 new_obj = Handle(THREAD, new_obj_oop); 854 } 855 856 return JNIHandles::make_local(THREAD, new_obj()); 857 JVM_END 858 859 // java.lang.ref.Finalizer //////////////////////////////////////////////////// 860 861 JVM_ENTRY(void, JVM_ReportFinalizationComplete(JNIEnv * env, jobject finalizee)) 862 MANAGEMENT_ONLY(FinalizerService::on_complete(JNIHandles::resolve_non_null(finalizee), THREAD);) 863 JVM_END 864 865 JVM_LEAF(jboolean, JVM_IsFinalizationEnabled(JNIEnv * env)) 866 return InstanceKlass::is_finalization_enabled(); 867 JVM_END 868 869 // jdk.internal.vm.Continuation ///////////////////////////////////////////////////// 870 871 JVM_ENTRY(void, JVM_RegisterContinuationMethods(JNIEnv *env, jclass cls)) 872 CONT_RegisterNativeMethods(env, cls); 873 JVM_END 874 875 // java.io.File /////////////////////////////////////////////////////////////// 876 877 JVM_LEAF(char*, JVM_NativePath(char* path)) 878 return os::native_path(path); 879 JVM_END 880 881 882 // Misc. class handling /////////////////////////////////////////////////////////// 883 884 885 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env)) 886 // Getting the class of the caller frame. 887 // 888 // The call stack at this point looks something like this: 889 // 890 // [0] [ @CallerSensitive public jdk.internal.reflect.Reflection.getCallerClass ] 891 // [1] [ @CallerSensitive API.method ] 892 // [.] [ (skipped intermediate frames) ] 893 // [n] [ caller ] 894 vframeStream vfst(thread); 895 // Cf. LibraryCallKit::inline_native_Reflection_getCallerClass 896 for (int n = 0; !vfst.at_end(); vfst.security_next(), n++) { 897 Method* m = vfst.method(); 898 assert(m != nullptr, "sanity"); 899 switch (n) { 900 case 0: 901 // This must only be called from Reflection.getCallerClass 902 if (m->intrinsic_id() != vmIntrinsics::_getCallerClass) { 903 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "JVM_GetCallerClass must only be called from Reflection.getCallerClass"); 904 } 905 // fall-through 906 case 1: 907 // Frame 0 and 1 must be caller sensitive. 908 if (!m->caller_sensitive()) { 909 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), err_msg("CallerSensitive annotation expected at frame %d", n)); 910 } 911 break; 912 default: 913 if (!m->is_ignored_by_security_stack_walk()) { 914 // We have reached the desired frame; return the holder class. 915 return (jclass) JNIHandles::make_local(THREAD, m->method_holder()->java_mirror()); 916 } 917 break; 918 } 919 } 920 return nullptr; 921 JVM_END 922 923 924 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf)) 925 oop mirror = nullptr; 926 BasicType t = name2type(utf); 927 if (t != T_ILLEGAL && !is_reference_type(t)) { 928 mirror = Universe::java_mirror(t); 929 } 930 if (mirror == nullptr) { 931 THROW_MSG_NULL(vmSymbols::java_lang_ClassNotFoundException(), (char*) utf); 932 } else { 933 return (jclass) JNIHandles::make_local(THREAD, mirror); 934 } 935 JVM_END 936 937 938 // Returns a class loaded by the bootstrap class loader; or null 939 // if not found. ClassNotFoundException is not thrown. 940 // FindClassFromBootLoader is exported to the launcher for windows. 941 JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env, 942 const char* name)) 943 // Java libraries should ensure that name is never null or illegal. 944 if (name == nullptr || (int)strlen(name) > Symbol::max_length()) { 945 // It's impossible to create this class; the name cannot fit 946 // into the constant pool. 947 return nullptr; 948 } 949 assert(UTF8::is_legal_utf8((const unsigned char*)name, strlen(name), false), "illegal UTF name"); 950 951 TempNewSymbol h_name = SymbolTable::new_symbol(name); 952 Klass* k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL); 953 if (k == nullptr) { 954 return nullptr; 955 } 956 957 if (log_is_enabled(Debug, class, resolve)) { 958 trace_class_resolution(k); 959 } 960 return (jclass) JNIHandles::make_local(THREAD, k->java_mirror()); 961 JVM_END 962 963 // Find a class with this name in this loader. 964 JVM_ENTRY(jclass, JVM_FindClassFromLoader(JNIEnv* env, const char* name, 965 jboolean init, jobject loader)) 966 TempNewSymbol h_name = 967 SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_ClassNotFoundException(), 968 CHECK_NULL); 969 970 oop loader_oop = JNIHandles::resolve(loader); 971 Handle h_loader(THREAD, loader_oop); 972 973 jclass result = find_class_from_class_loader(env, h_name, init, h_loader, 974 false, THREAD); 975 976 if (log_is_enabled(Debug, class, resolve) && result != nullptr) { 977 trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result))); 978 } 979 return result; 980 JVM_END 981 982 // Currently only called from the old verifier. 983 JVM_ENTRY(jclass, JVM_FindClassFromClass(JNIEnv *env, const char *name, 984 jboolean init, jclass from)) 985 TempNewSymbol h_name = 986 SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_ClassNotFoundException(), 987 CHECK_NULL); 988 oop from_class_oop = JNIHandles::resolve(from); 989 assert(from_class_oop != nullptr, "must be"); 990 Klass* from_class = java_lang_Class::as_Klass(from_class_oop); 991 assert(from_class != nullptr, "must be"); 992 oop class_loader = from_class->class_loader(); 993 994 Handle h_loader(THREAD, class_loader); 995 jclass result = find_class_from_class_loader(env, h_name, init, h_loader, true, thread); 996 997 if (log_is_enabled(Debug, class, resolve) && result != nullptr) { 998 // this function is generally only used for class loading during verification. 999 ResourceMark rm; 1000 const char* from_name = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(from))->external_name(); 1001 const char* to_name = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result))->external_name(); 1002 log_debug(class, resolve)("%s %s (verification)", from_name, to_name); 1003 } 1004 1005 #if INCLUDE_CDS 1006 if (CDSConfig::is_preserving_verification_constraints() && from_class->is_instance_klass()) { 1007 InstanceKlass* ik = InstanceKlass::cast(from_class); 1008 SystemDictionaryShared::add_old_verification_constraint(THREAD, ik, h_name); 1009 } 1010 #endif 1011 1012 return result; 1013 JVM_END 1014 1015 // common code for JVM_DefineClass() and JVM_DefineClassWithSource() 1016 static jclass jvm_define_class_common(const char *name, 1017 jobject loader, const jbyte *buf, 1018 jsize len, jobject pd, const char *source, 1019 TRAPS) { 1020 if (source == nullptr) source = "__JVM_DefineClass__"; 1021 1022 JavaThread* jt = THREAD; 1023 1024 PerfClassTraceTime vmtimer(ClassLoader::perf_define_appclass_time(), 1025 ClassLoader::perf_define_appclass_selftime(), 1026 ClassLoader::perf_define_appclasses(), 1027 jt->get_thread_stat()->perf_recursion_counts_addr(), 1028 jt->get_thread_stat()->perf_timers_addr(), 1029 PerfClassTraceTime::DEFINE_CLASS); 1030 1031 if (UsePerfData) { 1032 ClassLoader::perf_app_classfile_bytes_read()->inc(len); 1033 } 1034 1035 // Class resolution will get the class name from the .class stream if the name is null. 1036 TempNewSymbol class_name = name == nullptr ? nullptr : 1037 SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_NoClassDefFoundError(), 1038 CHECK_NULL); 1039 1040 ResourceMark rm(THREAD); 1041 ClassFileStream st((u1*)buf, len, source); 1042 Handle class_loader (THREAD, JNIHandles::resolve(loader)); 1043 Handle protection_domain (THREAD, JNIHandles::resolve(pd)); 1044 ClassLoadInfo cl_info(protection_domain); 1045 Klass* k = SystemDictionary::resolve_from_stream(&st, class_name, 1046 class_loader, 1047 cl_info, 1048 CHECK_NULL); 1049 1050 if (log_is_enabled(Debug, class, resolve)) { 1051 trace_class_resolution(k); 1052 } 1053 1054 return (jclass) JNIHandles::make_local(THREAD, k->java_mirror()); 1055 } 1056 1057 enum { 1058 NESTMATE = java_lang_invoke_MemberName::MN_NESTMATE_CLASS, 1059 HIDDEN_CLASS = java_lang_invoke_MemberName::MN_HIDDEN_CLASS, 1060 STRONG_LOADER_LINK = java_lang_invoke_MemberName::MN_STRONG_LOADER_LINK, 1061 ACCESS_VM_ANNOTATIONS = java_lang_invoke_MemberName::MN_ACCESS_VM_ANNOTATIONS 1062 }; 1063 1064 /* 1065 * Define a class with the specified flags that indicates if it's a nestmate, 1066 * hidden, or strongly referenced from class loader. 1067 */ 1068 static jclass jvm_lookup_define_class(jclass lookup, const char *name, 1069 const jbyte *buf, jsize len, jobject pd, 1070 jboolean init, int flags, jobject classData, TRAPS) { 1071 ResourceMark rm(THREAD); 1072 1073 InstanceKlass* lookup_k = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(lookup)); 1074 // Lookup class must not be a primitive class (whose mirror has a null Klass*) 1075 if (lookup_k == nullptr) { 1076 // The error message is wrong. We come here only if lookup is a primitive class 1077 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Lookup class is null"); 1078 } 1079 1080 Handle class_loader (THREAD, lookup_k->class_loader()); 1081 1082 bool is_nestmate = (flags & NESTMATE) == NESTMATE; 1083 bool is_hidden = (flags & HIDDEN_CLASS) == HIDDEN_CLASS; 1084 bool is_strong = (flags & STRONG_LOADER_LINK) == STRONG_LOADER_LINK; 1085 bool vm_annotations = (flags & ACCESS_VM_ANNOTATIONS) == ACCESS_VM_ANNOTATIONS; 1086 1087 InstanceKlass* host_class = nullptr; 1088 if (is_nestmate) { 1089 host_class = lookup_k->nest_host(CHECK_NULL); 1090 } 1091 1092 log_info(class, nestmates)("LookupDefineClass: %s - %s%s, %s, %s, %s", 1093 name, 1094 is_nestmate ? "with dynamic nest-host " : "non-nestmate", 1095 is_nestmate ? host_class->external_name() : "", 1096 is_hidden ? "hidden" : "not hidden", 1097 is_strong ? "strong" : "weak", 1098 vm_annotations ? "with vm annotations" : "without vm annotation"); 1099 1100 if (!is_hidden) { 1101 // classData is only applicable for hidden classes 1102 if (classData != nullptr) { 1103 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "classData is only applicable for hidden classes"); 1104 } 1105 if (is_nestmate) { 1106 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "dynamic nestmate is only applicable for hidden classes"); 1107 } 1108 if (!is_strong) { 1109 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "an ordinary class must be strongly referenced by its defining loader"); 1110 } 1111 if (vm_annotations) { 1112 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "vm annotations only allowed for hidden classes"); 1113 } 1114 if (flags != STRONG_LOADER_LINK) { 1115 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), 1116 err_msg("invalid flag 0x%x", flags)); 1117 } 1118 } 1119 1120 // Class resolution will get the class name from the .class stream if the name is null. 1121 TempNewSymbol class_name = name == nullptr ? nullptr : 1122 SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_NoClassDefFoundError(), 1123 CHECK_NULL); 1124 1125 Handle protection_domain (THREAD, JNIHandles::resolve(pd)); 1126 const char* source = is_nestmate ? host_class->external_name() : "__JVM_LookupDefineClass__"; 1127 ClassFileStream st((u1*)buf, len, source); 1128 1129 InstanceKlass* ik = nullptr; 1130 if (!is_hidden) { 1131 ClassLoadInfo cl_info(protection_domain); 1132 ik = SystemDictionary::resolve_from_stream(&st, class_name, 1133 class_loader, 1134 cl_info, 1135 CHECK_NULL); 1136 1137 if (log_is_enabled(Debug, class, resolve)) { 1138 trace_class_resolution(ik); 1139 } 1140 } else { // hidden 1141 Handle classData_h(THREAD, JNIHandles::resolve(classData)); 1142 ClassLoadInfo cl_info(protection_domain, 1143 host_class, 1144 classData_h, 1145 is_hidden, 1146 is_strong, 1147 vm_annotations); 1148 ik = SystemDictionary::resolve_from_stream(&st, class_name, 1149 class_loader, 1150 cl_info, 1151 CHECK_NULL); 1152 1153 // The hidden class loader data has been artificially been kept alive to 1154 // this point. The mirror and any instances of this class have to keep 1155 // it alive afterwards. 1156 ik->class_loader_data()->dec_keep_alive_ref_count(); 1157 1158 if (is_nestmate && log_is_enabled(Debug, class, nestmates)) { 1159 ModuleEntry* module = ik->module(); 1160 const char * module_name = module->is_named() ? module->name()->as_C_string() : UNNAMED_MODULE; 1161 log_debug(class, nestmates)("Dynamic nestmate: %s/%s, nest_host %s, %s", 1162 module_name, 1163 ik->external_name(), 1164 host_class->external_name(), 1165 ik->is_hidden() ? "is hidden" : "is not hidden"); 1166 } 1167 } 1168 1169 if ((!is_hidden || is_nestmate) && !Reflection::is_same_class_package(lookup_k, ik)) { 1170 // non-hidden class or nestmate class must be in the same package as the Lookup class 1171 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Lookup class and defined class are in different packages"); 1172 } 1173 1174 if (init) { 1175 ik->initialize(CHECK_NULL); 1176 } else { 1177 ik->link_class(CHECK_NULL); 1178 } 1179 1180 return (jclass) JNIHandles::make_local(THREAD, ik->java_mirror()); 1181 } 1182 1183 JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)) 1184 return jvm_define_class_common(name, loader, buf, len, pd, nullptr, THREAD); 1185 JVM_END 1186 1187 /* 1188 * Define a class with the specified lookup class. 1189 * lookup: Lookup class 1190 * name: the name of the class 1191 * buf: class bytes 1192 * len: length of class bytes 1193 * pd: protection domain 1194 * init: initialize the class 1195 * flags: properties of the class 1196 * classData: private static pre-initialized field 1197 */ 1198 JVM_ENTRY(jclass, JVM_LookupDefineClass(JNIEnv *env, jclass lookup, const char *name, const jbyte *buf, 1199 jsize len, jobject pd, jboolean initialize, int flags, jobject classData)) 1200 1201 if (lookup == nullptr) { 1202 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Lookup class is null"); 1203 } 1204 1205 assert(buf != nullptr, "buf must not be null"); 1206 1207 return jvm_lookup_define_class(lookup, name, buf, len, pd, initialize, flags, classData, THREAD); 1208 JVM_END 1209 1210 JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)) 1211 1212 return jvm_define_class_common(name, loader, buf, len, pd, source, THREAD); 1213 JVM_END 1214 1215 JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)) 1216 ResourceMark rm(THREAD); 1217 1218 Handle h_name (THREAD, JNIHandles::resolve_non_null(name)); 1219 char* str = java_lang_String::as_utf8_string(h_name()); 1220 1221 // Sanity check, don't expect null 1222 if (str == nullptr) return nullptr; 1223 1224 // Internalize the string, converting '.' to '/' in string. 1225 char* p = (char*)str; 1226 while (*p != '\0') { 1227 if (*p == '.') { 1228 *p = '/'; 1229 } 1230 p++; 1231 } 1232 1233 const int str_len = (int)(p - str); 1234 if (str_len > Symbol::max_length()) { 1235 // It's impossible to create this class; the name cannot fit 1236 // into the constant pool. 1237 return nullptr; 1238 } 1239 TempNewSymbol klass_name = SymbolTable::new_symbol(str, str_len); 1240 1241 // Security Note: 1242 // The Java level wrapper will perform the necessary security check allowing 1243 // us to pass the null as the initiating class loader. 1244 Handle h_loader(THREAD, JNIHandles::resolve(loader)); 1245 Klass* k = SystemDictionary::find_instance_or_array_klass(THREAD, klass_name, h_loader); 1246 #if INCLUDE_CDS 1247 if (k == nullptr) { 1248 // If the class is not already loaded, try to see if it's in the shared 1249 // archive for the current classloader (h_loader). 1250 k = SystemDictionaryShared::find_or_load_shared_class(klass_name, h_loader, CHECK_NULL); 1251 } 1252 #endif 1253 return (k == nullptr) ? nullptr : 1254 (jclass) JNIHandles::make_local(THREAD, k->java_mirror()); 1255 JVM_END 1256 1257 // Module support ////////////////////////////////////////////////////////////////////////////// 1258 1259 JVM_ENTRY(void, JVM_DefineModule(JNIEnv *env, jobject module, jboolean is_open, jstring version, 1260 jstring location, jobjectArray packages)) 1261 Handle h_module (THREAD, JNIHandles::resolve(module)); 1262 Modules::define_module(h_module, is_open, version, location, packages, CHECK); 1263 JVM_END 1264 1265 JVM_ENTRY(void, JVM_SetBootLoaderUnnamedModule(JNIEnv *env, jobject module)) 1266 Handle h_module (THREAD, JNIHandles::resolve(module)); 1267 Modules::set_bootloader_unnamed_module(h_module, CHECK); 1268 JVM_END 1269 1270 JVM_ENTRY(void, JVM_AddModuleExports(JNIEnv *env, jobject from_module, jstring package, jobject to_module)) 1271 Handle h_from_module (THREAD, JNIHandles::resolve(from_module)); 1272 Handle h_to_module (THREAD, JNIHandles::resolve(to_module)); 1273 Modules::add_module_exports_qualified(h_from_module, package, h_to_module, CHECK); 1274 JVM_END 1275 1276 JVM_ENTRY(void, JVM_AddModuleExportsToAllUnnamed(JNIEnv *env, jobject from_module, jstring package)) 1277 Handle h_from_module (THREAD, JNIHandles::resolve(from_module)); 1278 Modules::add_module_exports_to_all_unnamed(h_from_module, package, CHECK); 1279 JVM_END 1280 1281 JVM_ENTRY(void, JVM_AddModuleExportsToAll(JNIEnv *env, jobject from_module, jstring package)) 1282 Handle h_from_module (THREAD, JNIHandles::resolve(from_module)); 1283 Modules::add_module_exports(h_from_module, package, Handle(), CHECK); 1284 JVM_END 1285 1286 JVM_ENTRY (void, JVM_AddReadsModule(JNIEnv *env, jobject from_module, jobject source_module)) 1287 Handle h_from_module (THREAD, JNIHandles::resolve(from_module)); 1288 Handle h_source_module (THREAD, JNIHandles::resolve(source_module)); 1289 Modules::add_reads_module(h_from_module, h_source_module, CHECK); 1290 JVM_END 1291 1292 JVM_ENTRY(void, JVM_DefineArchivedModules(JNIEnv *env, jobject platform_loader, jobject system_loader)) 1293 Handle h_platform_loader (THREAD, JNIHandles::resolve(platform_loader)); 1294 Handle h_system_loader (THREAD, JNIHandles::resolve(system_loader)); 1295 Modules::define_archived_modules(h_platform_loader, h_system_loader, CHECK); 1296 JVM_END 1297 1298 // Reflection support ////////////////////////////////////////////////////////////////////////////// 1299 1300 JVM_ENTRY(jstring, JVM_InitClassName(JNIEnv *env, jclass cls)) 1301 assert (cls != nullptr, "illegal class"); 1302 JvmtiVMObjectAllocEventCollector oam; 1303 ResourceMark rm(THREAD); 1304 HandleMark hm(THREAD); 1305 Handle java_class(THREAD, JNIHandles::resolve(cls)); 1306 oop result = java_lang_Class::name(java_class, CHECK_NULL); 1307 return (jstring) JNIHandles::make_local(THREAD, result); 1308 JVM_END 1309 1310 1311 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls)) 1312 JvmtiVMObjectAllocEventCollector oam; 1313 oop mirror = JNIHandles::resolve_non_null(cls); 1314 1315 // Special handling for primitive objects 1316 if (java_lang_Class::is_primitive(mirror)) { 1317 // Primitive objects does not have any interfaces 1318 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL); 1319 return (jobjectArray) JNIHandles::make_local(THREAD, r); 1320 } 1321 1322 Klass* klass = java_lang_Class::as_Klass(mirror); 1323 // Figure size of result array 1324 int size; 1325 if (klass->is_instance_klass()) { 1326 InstanceKlass* ik = InstanceKlass::cast(klass); 1327 size = ik->local_interfaces()->length(); 1328 } else { 1329 assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass"); 1330 size = 2; 1331 } 1332 1333 // Allocate result array 1334 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), size, CHECK_NULL); 1335 objArrayHandle result (THREAD, r); 1336 // Fill in result 1337 if (klass->is_instance_klass()) { 1338 // Regular instance klass, fill in all local interfaces 1339 for (int index = 0; index < size; index++) { 1340 InstanceKlass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index); 1341 result->obj_at_put(index, k->java_mirror()); 1342 } 1343 } else { 1344 // All arrays implement java.lang.Cloneable and java.io.Serializable 1345 result->obj_at_put(0, vmClasses::Cloneable_klass()->java_mirror()); 1346 result->obj_at_put(1, vmClasses::Serializable_klass()->java_mirror()); 1347 } 1348 return (jobjectArray) JNIHandles::make_local(THREAD, result()); 1349 JVM_END 1350 1351 1352 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls)) 1353 oop mirror = JNIHandles::resolve_non_null(cls); 1354 if (java_lang_Class::is_primitive(mirror)) { 1355 return JNI_FALSE; 1356 } 1357 Klass* k = java_lang_Class::as_Klass(mirror); 1358 return k->is_hidden(); 1359 JVM_END 1360 1361 class ScopedValueBindingsResolver { 1362 public: 1363 InstanceKlass* Carrier_klass; 1364 ScopedValueBindingsResolver(JavaThread* THREAD) { 1365 Klass *k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ScopedValue_Carrier(), true, THREAD); 1366 Carrier_klass = InstanceKlass::cast(k); 1367 } 1368 }; 1369 1370 JVM_ENTRY(jobject, JVM_FindScopedValueBindings(JNIEnv *env, jclass cls)) 1371 ResourceMark rm(THREAD); 1372 GrowableArray<Handle>* local_array = new GrowableArray<Handle>(12); 1373 JvmtiVMObjectAllocEventCollector oam; 1374 1375 static ScopedValueBindingsResolver resolver(THREAD); 1376 1377 // Iterate through Java frames 1378 vframeStream vfst(thread); 1379 for(; !vfst.at_end(); vfst.next()) { 1380 int loc = -1; 1381 // get method of frame 1382 Method* method = vfst.method(); 1383 1384 Symbol *name = method->name(); 1385 1386 InstanceKlass* holder = method->method_holder(); 1387 if (name == vmSymbols::runWith_method_name()) { 1388 if (holder == vmClasses::Thread_klass() 1389 || holder == resolver.Carrier_klass) { 1390 loc = 1; 1391 } 1392 } 1393 1394 if (loc != -1) { 1395 javaVFrame *frame = vfst.asJavaVFrame(); 1396 StackValueCollection* locals = frame->locals(); 1397 StackValue* head_sv = locals->at(loc); // java/lang/ScopedValue$Snapshot 1398 Handle result = head_sv->get_obj(); 1399 assert(!head_sv->obj_is_scalar_replaced(), "found scalar-replaced object"); 1400 if (result() != nullptr) { 1401 return JNIHandles::make_local(THREAD, result()); 1402 } 1403 } 1404 } 1405 1406 return nullptr; 1407 JVM_END 1408 1409 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)) 1410 JvmtiVMObjectAllocEventCollector oam; 1411 // ofClass is a reference to a java_lang_Class object. The mirror object 1412 // of an InstanceKlass 1413 oop ofMirror = JNIHandles::resolve_non_null(ofClass); 1414 if (java_lang_Class::is_primitive(ofMirror) || 1415 ! java_lang_Class::as_Klass(ofMirror)->is_instance_klass()) { 1416 oop result = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL); 1417 return (jobjectArray)JNIHandles::make_local(THREAD, result); 1418 } 1419 1420 InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror); 1421 InnerClassesIterator iter(k); 1422 1423 if (iter.length() == 0) { 1424 // Neither an inner nor outer class 1425 oop result = oopFactory::new_objArray(vmClasses::Class_klass(), 0, CHECK_NULL); 1426 return (jobjectArray)JNIHandles::make_local(THREAD, result); 1427 } 1428 1429 // find inner class info 1430 constantPoolHandle cp(thread, k->constants()); 1431 int length = iter.length(); 1432 1433 // Allocate temp. result array 1434 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), length/4, CHECK_NULL); 1435 objArrayHandle result (THREAD, r); 1436 int members = 0; 1437 1438 for (; !iter.done(); iter.next()) { 1439 int ioff = iter.inner_class_info_index(); 1440 int ooff = iter.outer_class_info_index(); 1441 1442 if (ioff != 0 && ooff != 0) { 1443 // Check to see if the name matches the class we're looking for 1444 // before attempting to find the class. 1445 if (cp->klass_name_at_matches(k, ooff)) { 1446 Klass* outer_klass = cp->klass_at(ooff, CHECK_NULL); 1447 if (outer_klass == k) { 1448 Klass* ik = cp->klass_at(ioff, CHECK_NULL); 1449 InstanceKlass* inner_klass = InstanceKlass::cast(ik); 1450 1451 // Throws an exception if outer klass has not declared k as 1452 // an inner klass 1453 Reflection::check_for_inner_class(k, inner_klass, true, CHECK_NULL); 1454 1455 result->obj_at_put(members, inner_klass->java_mirror()); 1456 members++; 1457 } 1458 } 1459 } 1460 } 1461 1462 if (members != length) { 1463 // Return array of right length 1464 objArrayOop res = oopFactory::new_objArray(vmClasses::Class_klass(), members, CHECK_NULL); 1465 for(int i = 0; i < members; i++) { 1466 res->obj_at_put(i, result->obj_at(i)); 1467 } 1468 return (jobjectArray)JNIHandles::make_local(THREAD, res); 1469 } 1470 1471 return (jobjectArray)JNIHandles::make_local(THREAD, result()); 1472 JVM_END 1473 1474 1475 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)) 1476 { 1477 // ofClass is a reference to a java_lang_Class object. 1478 oop ofMirror = JNIHandles::resolve_non_null(ofClass); 1479 if (java_lang_Class::is_primitive(ofMirror)) { 1480 return nullptr; 1481 } 1482 Klass* klass = java_lang_Class::as_Klass(ofMirror); 1483 if (!klass->is_instance_klass()) { 1484 return nullptr; 1485 } 1486 1487 bool inner_is_member = false; 1488 Klass* outer_klass 1489 = InstanceKlass::cast(klass)->compute_enclosing_class(&inner_is_member, CHECK_NULL); 1490 if (outer_klass == nullptr) return nullptr; // already a top-level class 1491 if (!inner_is_member) return nullptr; // a hidden class (inside a method) 1492 return (jclass) JNIHandles::make_local(THREAD, outer_klass->java_mirror()); 1493 } 1494 JVM_END 1495 1496 JVM_ENTRY(jstring, JVM_GetSimpleBinaryName(JNIEnv *env, jclass cls)) 1497 { 1498 oop mirror = JNIHandles::resolve_non_null(cls); 1499 if (java_lang_Class::is_primitive(mirror)) { 1500 return nullptr; 1501 } 1502 Klass* klass = java_lang_Class::as_Klass(mirror); 1503 if (!klass->is_instance_klass()) { 1504 return nullptr; 1505 } 1506 InstanceKlass* k = InstanceKlass::cast(klass); 1507 int ooff = 0, noff = 0; 1508 if (k->find_inner_classes_attr(&ooff, &noff, THREAD)) { 1509 if (noff != 0) { 1510 constantPoolHandle i_cp(thread, k->constants()); 1511 Symbol* name = i_cp->symbol_at(noff); 1512 Handle str = java_lang_String::create_from_symbol(name, CHECK_NULL); 1513 return (jstring) JNIHandles::make_local(THREAD, str()); 1514 } 1515 } 1516 return nullptr; 1517 } 1518 JVM_END 1519 1520 JVM_ENTRY(jstring, JVM_GetClassSignature(JNIEnv *env, jclass cls)) 1521 assert (cls != nullptr, "illegal class"); 1522 JvmtiVMObjectAllocEventCollector oam; 1523 ResourceMark rm(THREAD); 1524 oop mirror = JNIHandles::resolve_non_null(cls); 1525 // Return null for arrays and primitives 1526 if (!java_lang_Class::is_primitive(mirror)) { 1527 Klass* k = java_lang_Class::as_Klass(mirror); 1528 if (k->is_instance_klass()) { 1529 Symbol* sym = InstanceKlass::cast(k)->generic_signature(); 1530 if (sym == nullptr) return nullptr; 1531 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 1532 return (jstring) JNIHandles::make_local(THREAD, str()); 1533 } 1534 } 1535 return nullptr; 1536 JVM_END 1537 1538 1539 JVM_ENTRY(jbyteArray, JVM_GetClassAnnotations(JNIEnv *env, jclass cls)) 1540 assert (cls != nullptr, "illegal class"); 1541 oop mirror = JNIHandles::resolve_non_null(cls); 1542 // Return null for arrays and primitives 1543 if (!java_lang_Class::is_primitive(mirror)) { 1544 Klass* k = java_lang_Class::as_Klass(mirror); 1545 if (k->is_instance_klass()) { 1546 typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL); 1547 return (jbyteArray) JNIHandles::make_local(THREAD, a); 1548 } 1549 } 1550 return nullptr; 1551 JVM_END 1552 1553 1554 static bool jvm_get_field_common(jobject field, fieldDescriptor& fd) { 1555 // some of this code was adapted from from jni_FromReflectedField 1556 1557 oop reflected = JNIHandles::resolve_non_null(field); 1558 oop mirror = java_lang_reflect_Field::clazz(reflected); 1559 int slot = java_lang_reflect_Field::slot(reflected); 1560 int modifiers = java_lang_reflect_Field::modifiers(reflected); 1561 1562 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror); 1563 int offset = ik->field_offset(slot); 1564 1565 if (modifiers & JVM_ACC_STATIC) { 1566 // for static fields we only look in the current class 1567 if (!ik->find_local_field_from_offset(offset, true, &fd)) { 1568 assert(false, "cannot find static field"); 1569 return false; 1570 } 1571 } else { 1572 // for instance fields we start with the current class and work 1573 // our way up through the superclass chain 1574 if (!ik->find_field_from_offset(offset, false, &fd)) { 1575 assert(false, "cannot find instance field"); 1576 return false; 1577 } 1578 } 1579 return true; 1580 } 1581 1582 static Method* jvm_get_method_common(jobject method) { 1583 // some of this code was adapted from from jni_FromReflectedMethod 1584 1585 oop reflected = JNIHandles::resolve_non_null(method); 1586 oop mirror = nullptr; 1587 int slot = 0; 1588 1589 if (reflected->klass() == vmClasses::reflect_Constructor_klass()) { 1590 mirror = java_lang_reflect_Constructor::clazz(reflected); 1591 slot = java_lang_reflect_Constructor::slot(reflected); 1592 } else { 1593 assert(reflected->klass() == vmClasses::reflect_Method_klass(), 1594 "wrong type"); 1595 mirror = java_lang_reflect_Method::clazz(reflected); 1596 slot = java_lang_reflect_Method::slot(reflected); 1597 } 1598 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror); 1599 1600 Method* m = ik->method_with_idnum(slot); 1601 assert(m != nullptr, "cannot find method"); 1602 return m; // caller has to deal with null in product mode 1603 } 1604 1605 /* Type use annotations support (JDK 1.8) */ 1606 1607 JVM_ENTRY(jbyteArray, JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls)) 1608 assert (cls != nullptr, "illegal class"); 1609 ResourceMark rm(THREAD); 1610 // Return null for arrays and primitives 1611 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1612 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); 1613 if (k->is_instance_klass()) { 1614 AnnotationArray* type_annotations = InstanceKlass::cast(k)->class_type_annotations(); 1615 if (type_annotations != nullptr) { 1616 typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL); 1617 return (jbyteArray) JNIHandles::make_local(THREAD, a); 1618 } 1619 } 1620 } 1621 return nullptr; 1622 JVM_END 1623 1624 JVM_ENTRY(jbyteArray, JVM_GetMethodTypeAnnotations(JNIEnv *env, jobject method)) 1625 assert (method != nullptr, "illegal method"); 1626 // method is a handle to a java.lang.reflect.Method object 1627 Method* m = jvm_get_method_common(method); 1628 if (m == nullptr) { 1629 return nullptr; 1630 } 1631 1632 AnnotationArray* type_annotations = m->type_annotations(); 1633 if (type_annotations != nullptr) { 1634 typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL); 1635 return (jbyteArray) JNIHandles::make_local(THREAD, a); 1636 } 1637 1638 return nullptr; 1639 JVM_END 1640 1641 JVM_ENTRY(jbyteArray, JVM_GetFieldTypeAnnotations(JNIEnv *env, jobject field)) 1642 assert (field != nullptr, "illegal field"); 1643 fieldDescriptor fd; 1644 bool gotFd = jvm_get_field_common(field, fd); 1645 if (!gotFd) { 1646 return nullptr; 1647 } 1648 1649 return (jbyteArray) JNIHandles::make_local(THREAD, Annotations::make_java_array(fd.type_annotations(), THREAD)); 1650 JVM_END 1651 1652 static void bounds_check(const constantPoolHandle& cp, jint index, TRAPS) { 1653 if (!cp->is_within_bounds(index)) { 1654 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Constant pool index out of bounds"); 1655 } 1656 } 1657 1658 JVM_ENTRY(jobjectArray, JVM_GetMethodParameters(JNIEnv *env, jobject method)) 1659 { 1660 // method is a handle to a java.lang.reflect.Method object 1661 Method* method_ptr = jvm_get_method_common(method); 1662 methodHandle mh (THREAD, method_ptr); 1663 Handle reflected_method (THREAD, JNIHandles::resolve_non_null(method)); 1664 const int num_params = mh->method_parameters_length(); 1665 1666 if (num_params < 0) { 1667 // A -1 return value from method_parameters_length means there is no 1668 // parameter data. Return null to indicate this to the reflection 1669 // API. 1670 assert(num_params == -1, "num_params should be -1 if it is less than zero"); 1671 return (jobjectArray)nullptr; 1672 } else { 1673 // Otherwise, we return something up to reflection, even if it is 1674 // a zero-length array. Why? Because in some cases this can 1675 // trigger a MalformedParametersException. 1676 1677 // make sure all the symbols are properly formatted 1678 for (int i = 0; i < num_params; i++) { 1679 MethodParametersElement* params = mh->method_parameters_start(); 1680 int index = params[i].name_cp_index; 1681 constantPoolHandle cp(THREAD, mh->constants()); 1682 bounds_check(cp, index, CHECK_NULL); 1683 1684 if (0 != index && !mh->constants()->tag_at(index).is_utf8()) { 1685 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), 1686 "Wrong type at constant pool index"); 1687 } 1688 1689 } 1690 1691 objArrayOop result_oop = oopFactory::new_objArray(vmClasses::reflect_Parameter_klass(), num_params, CHECK_NULL); 1692 objArrayHandle result (THREAD, result_oop); 1693 1694 for (int i = 0; i < num_params; i++) { 1695 MethodParametersElement* params = mh->method_parameters_start(); 1696 // For a 0 index, give a null symbol 1697 Symbol* sym = 0 != params[i].name_cp_index ? 1698 mh->constants()->symbol_at(params[i].name_cp_index) : nullptr; 1699 int flags = params[i].flags; 1700 oop param = Reflection::new_parameter(reflected_method, i, sym, 1701 flags, CHECK_NULL); 1702 result->obj_at_put(i, param); 1703 } 1704 return (jobjectArray)JNIHandles::make_local(THREAD, result()); 1705 } 1706 } 1707 JVM_END 1708 1709 // New (JDK 1.4) reflection implementation ///////////////////////////////////// 1710 1711 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)) 1712 { 1713 JvmtiVMObjectAllocEventCollector oam; 1714 1715 oop ofMirror = JNIHandles::resolve_non_null(ofClass); 1716 // Exclude primitive types and array types 1717 if (java_lang_Class::is_primitive(ofMirror) || 1718 java_lang_Class::as_Klass(ofMirror)->is_array_klass()) { 1719 // Return empty array 1720 oop res = oopFactory::new_objArray(vmClasses::reflect_Field_klass(), 0, CHECK_NULL); 1721 return (jobjectArray) JNIHandles::make_local(THREAD, res); 1722 } 1723 1724 InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror); 1725 constantPoolHandle cp(THREAD, k->constants()); 1726 1727 // Ensure class is linked 1728 k->link_class(CHECK_NULL); 1729 1730 // Allocate result 1731 int num_fields; 1732 1733 if (publicOnly) { 1734 num_fields = 0; 1735 for (JavaFieldStream fs(k); !fs.done(); fs.next()) { 1736 if (fs.access_flags().is_public()) ++num_fields; 1737 } 1738 } else { 1739 num_fields = k->java_fields_count(); 1740 } 1741 1742 objArrayOop r = oopFactory::new_objArray(vmClasses::reflect_Field_klass(), num_fields, CHECK_NULL); 1743 objArrayHandle result (THREAD, r); 1744 1745 int out_idx = 0; 1746 fieldDescriptor fd; 1747 for (JavaFieldStream fs(k); !fs.done(); fs.next()) { 1748 if (!publicOnly || fs.access_flags().is_public()) { 1749 fd.reinitialize(k, fs.to_FieldInfo()); 1750 oop field = Reflection::new_field(&fd, CHECK_NULL); 1751 result->obj_at_put(out_idx, field); 1752 ++out_idx; 1753 } 1754 } 1755 assert(out_idx == num_fields, "just checking"); 1756 return (jobjectArray) JNIHandles::make_local(THREAD, result()); 1757 } 1758 JVM_END 1759 1760 // A class is a record if and only if it is final and a direct subclass of 1761 // java.lang.Record and has a Record attribute; otherwise, it is not a record. 1762 JVM_ENTRY(jboolean, JVM_IsRecord(JNIEnv *env, jclass cls)) 1763 { 1764 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1765 if (k != nullptr && k->is_instance_klass()) { 1766 InstanceKlass* ik = InstanceKlass::cast(k); 1767 return ik->is_record(); 1768 } else { 1769 return false; 1770 } 1771 } 1772 JVM_END 1773 1774 // Returns an array containing the components of the Record attribute, 1775 // or null if the attribute is not present. 1776 // 1777 // Note that this function returns the components of the Record attribute 1778 // even if the class is not a record. 1779 JVM_ENTRY(jobjectArray, JVM_GetRecordComponents(JNIEnv* env, jclass ofClass)) 1780 { 1781 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(ofClass)); 1782 1783 Array<RecordComponent*>* components = ik->record_components(); 1784 if (components != nullptr) { 1785 JvmtiVMObjectAllocEventCollector oam; 1786 constantPoolHandle cp(THREAD, ik->constants()); 1787 int length = components->length(); 1788 assert(length >= 0, "unexpected record_components length"); 1789 objArrayOop record_components = 1790 oopFactory::new_objArray(vmClasses::RecordComponent_klass(), length, CHECK_NULL); 1791 objArrayHandle components_h (THREAD, record_components); 1792 1793 for (int x = 0; x < length; x++) { 1794 RecordComponent* component = components->at(x); 1795 assert(component != nullptr, "unexpected null record component"); 1796 oop component_oop = java_lang_reflect_RecordComponent::create(ik, component, CHECK_NULL); 1797 components_h->obj_at_put(x, component_oop); 1798 } 1799 return (jobjectArray)JNIHandles::make_local(THREAD, components_h()); 1800 } 1801 1802 return nullptr; 1803 } 1804 JVM_END 1805 1806 static jobjectArray get_class_declared_methods_helper( 1807 JNIEnv *env, 1808 jclass ofClass, jboolean publicOnly, 1809 bool want_constructor, 1810 Klass* klass, TRAPS) { 1811 1812 JvmtiVMObjectAllocEventCollector oam; 1813 1814 oop ofMirror = JNIHandles::resolve_non_null(ofClass); 1815 // Exclude primitive types and array types 1816 if (java_lang_Class::is_primitive(ofMirror) 1817 || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) { 1818 // Return empty array 1819 oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL); 1820 return (jobjectArray) JNIHandles::make_local(THREAD, res); 1821 } 1822 1823 InstanceKlass* k = java_lang_Class::as_InstanceKlass(ofMirror); 1824 1825 // Ensure class is linked 1826 k->link_class(CHECK_NULL); 1827 1828 Array<Method*>* methods = k->methods(); 1829 int methods_length = methods->length(); 1830 1831 // Save original method_idnum in case of redefinition, which can change 1832 // the idnum of obsolete methods. The new method will have the same idnum 1833 // but if we refresh the methods array, the counts will be wrong. 1834 ResourceMark rm(THREAD); 1835 GrowableArray<int>* idnums = new GrowableArray<int>(methods_length); 1836 int num_methods = 0; 1837 1838 // Select methods matching the criteria. 1839 for (int i = 0; i < methods_length; i++) { 1840 Method* method = methods->at(i); 1841 if (want_constructor && !method->is_object_constructor()) { 1842 continue; 1843 } 1844 if (!want_constructor && 1845 (method->is_object_constructor() || method->is_class_initializer() || 1846 method->is_overpass())) { 1847 continue; 1848 } 1849 if (publicOnly && !method->is_public()) { 1850 continue; 1851 } 1852 idnums->push(method->method_idnum()); 1853 ++num_methods; 1854 } 1855 1856 // Allocate result 1857 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL); 1858 objArrayHandle result (THREAD, r); 1859 1860 // Now just put the methods that we selected above, but go by their idnum 1861 // in case of redefinition. The methods can be redefined at any safepoint, 1862 // so above when allocating the oop array and below when creating reflect 1863 // objects. 1864 for (int i = 0; i < num_methods; i++) { 1865 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i))); 1866 if (method.is_null()) { 1867 // Method may have been deleted and seems this API can handle null 1868 // Otherwise should probably put a method that throws NSME 1869 result->obj_at_put(i, nullptr); 1870 } else { 1871 oop m; 1872 if (want_constructor) { 1873 assert(method->is_object_constructor(), "must be"); 1874 m = Reflection::new_constructor(method, CHECK_NULL); 1875 } else { 1876 m = Reflection::new_method(method, false, CHECK_NULL); 1877 } 1878 result->obj_at_put(i, m); 1879 } 1880 } 1881 1882 return (jobjectArray) JNIHandles::make_local(THREAD, result()); 1883 } 1884 1885 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)) 1886 { 1887 return get_class_declared_methods_helper(env, ofClass, publicOnly, 1888 /*want_constructor*/ false, 1889 vmClasses::reflect_Method_klass(), THREAD); 1890 } 1891 JVM_END 1892 1893 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)) 1894 { 1895 return get_class_declared_methods_helper(env, ofClass, publicOnly, 1896 /*want_constructor*/ true, 1897 vmClasses::reflect_Constructor_klass(), THREAD); 1898 } 1899 JVM_END 1900 1901 JVM_ENTRY(jboolean, JVM_AreNestMates(JNIEnv *env, jclass current, jclass member)) 1902 { 1903 InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current)); 1904 InstanceKlass* m = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(member)); 1905 return c->has_nestmate_access_to(m, THREAD); 1906 } 1907 JVM_END 1908 1909 JVM_ENTRY(jclass, JVM_GetNestHost(JNIEnv* env, jclass current)) 1910 { 1911 // current is not a primitive or array class 1912 InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current)); 1913 InstanceKlass* host = c->nest_host(THREAD); 1914 return (jclass) (host == nullptr ? nullptr : 1915 JNIHandles::make_local(THREAD, host->java_mirror())); 1916 } 1917 JVM_END 1918 1919 JVM_ENTRY(jobjectArray, JVM_GetNestMembers(JNIEnv* env, jclass current)) 1920 { 1921 // current is not a primitive or array class 1922 ResourceMark rm(THREAD); 1923 InstanceKlass* c = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(current)); 1924 InstanceKlass* host = c->nest_host(THREAD); 1925 1926 log_trace(class, nestmates)("Calling GetNestMembers for type %s with nest-host %s", 1927 c->external_name(), host->external_name()); 1928 { 1929 JvmtiVMObjectAllocEventCollector oam; 1930 Array<u2>* members = host->nest_members(); 1931 int length = members == nullptr ? 0 : members->length(); 1932 1933 log_trace(class, nestmates)(" - host has %d listed nest members", length); 1934 1935 // nest host is first in the array so make it one bigger 1936 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 1937 length + 1, CHECK_NULL); 1938 objArrayHandle result(THREAD, r); 1939 result->obj_at_put(0, host->java_mirror()); 1940 if (length != 0) { 1941 int count = 0; 1942 for (int i = 0; i < length; i++) { 1943 int cp_index = members->at(i); 1944 Klass* k = host->constants()->klass_at(cp_index, THREAD); 1945 if (HAS_PENDING_EXCEPTION) { 1946 if (PENDING_EXCEPTION->is_a(vmClasses::VirtualMachineError_klass())) { 1947 return nullptr; // propagate VMEs 1948 } 1949 if (log_is_enabled(Trace, class, nestmates)) { 1950 stringStream ss; 1951 char* target_member_class = host->constants()->klass_name_at(cp_index)->as_C_string(); 1952 ss.print(" - resolution of nest member %s failed: ", target_member_class); 1953 java_lang_Throwable::print(PENDING_EXCEPTION, &ss); 1954 log_trace(class, nestmates)("%s", ss.as_string()); 1955 } 1956 CLEAR_PENDING_EXCEPTION; 1957 continue; 1958 } 1959 if (k->is_instance_klass()) { 1960 InstanceKlass* ik = InstanceKlass::cast(k); 1961 InstanceKlass* nest_host_k = ik->nest_host(CHECK_NULL); 1962 if (nest_host_k == host) { 1963 result->obj_at_put(count+1, k->java_mirror()); 1964 count++; 1965 log_trace(class, nestmates)(" - [%d] = %s", count, ik->external_name()); 1966 } else { 1967 log_trace(class, nestmates)(" - skipping member %s with different host %s", 1968 ik->external_name(), nest_host_k->external_name()); 1969 } 1970 } else { 1971 log_trace(class, nestmates)(" - skipping member %s that is not an instance class", 1972 k->external_name()); 1973 } 1974 } 1975 if (count < length) { 1976 // we had invalid entries so we need to compact the array 1977 log_trace(class, nestmates)(" - compacting array from length %d to %d", 1978 length + 1, count + 1); 1979 1980 objArrayOop r2 = oopFactory::new_objArray(vmClasses::Class_klass(), 1981 count + 1, CHECK_NULL); 1982 objArrayHandle result2(THREAD, r2); 1983 for (int i = 0; i < count + 1; i++) { 1984 result2->obj_at_put(i, result->obj_at(i)); 1985 } 1986 return (jobjectArray)JNIHandles::make_local(THREAD, result2()); 1987 } 1988 } 1989 else { 1990 assert(host == c || c->is_hidden(), "must be singleton nest or dynamic nestmate"); 1991 } 1992 return (jobjectArray)JNIHandles::make_local(THREAD, result()); 1993 } 1994 } 1995 JVM_END 1996 1997 JVM_ENTRY(jobjectArray, JVM_GetPermittedSubclasses(JNIEnv* env, jclass current)) 1998 { 1999 oop mirror = JNIHandles::resolve_non_null(current); 2000 assert(!java_lang_Class::is_primitive(mirror), "should not be"); 2001 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror); 2002 2003 ResourceMark rm(THREAD); 2004 log_trace(class, sealed)("Calling GetPermittedSubclasses for %s type %s", 2005 ik->is_sealed() ? "sealed" : "non-sealed", ik->external_name()); 2006 if (ik->is_sealed()) { 2007 JvmtiVMObjectAllocEventCollector oam; 2008 Array<u2>* subclasses = ik->permitted_subclasses(); 2009 int length = subclasses->length(); 2010 2011 log_trace(class, sealed)(" - sealed class has %d permitted subclasses", length); 2012 2013 objArrayOop r = oopFactory::new_objArray(vmClasses::Class_klass(), 2014 length, CHECK_NULL); 2015 objArrayHandle result(THREAD, r); 2016 int count = 0; 2017 for (int i = 0; i < length; i++) { 2018 int cp_index = subclasses->at(i); 2019 Klass* k = ik->constants()->klass_at(cp_index, THREAD); 2020 if (HAS_PENDING_EXCEPTION) { 2021 if (PENDING_EXCEPTION->is_a(vmClasses::VirtualMachineError_klass())) { 2022 return nullptr; // propagate VMEs 2023 } 2024 if (log_is_enabled(Trace, class, sealed)) { 2025 stringStream ss; 2026 char* permitted_subclass = ik->constants()->klass_name_at(cp_index)->as_C_string(); 2027 ss.print(" - resolution of permitted subclass %s failed: ", permitted_subclass); 2028 java_lang_Throwable::print(PENDING_EXCEPTION, &ss); 2029 log_trace(class, sealed)("%s", ss.as_string()); 2030 } 2031 2032 CLEAR_PENDING_EXCEPTION; 2033 continue; 2034 } 2035 if (k->is_instance_klass()) { 2036 result->obj_at_put(count++, k->java_mirror()); 2037 log_trace(class, sealed)(" - [%d] = %s", count, k->external_name()); 2038 } 2039 } 2040 if (count < length) { 2041 // we had invalid entries so we need to compact the array 2042 objArrayOop r2 = oopFactory::new_objArray(vmClasses::Class_klass(), 2043 count, CHECK_NULL); 2044 objArrayHandle result2(THREAD, r2); 2045 for (int i = 0; i < count; i++) { 2046 result2->obj_at_put(i, result->obj_at(i)); 2047 } 2048 return (jobjectArray)JNIHandles::make_local(THREAD, result2()); 2049 } 2050 return (jobjectArray)JNIHandles::make_local(THREAD, result()); 2051 } else { 2052 return nullptr; 2053 } 2054 } 2055 JVM_END 2056 2057 // Constant pool access ////////////////////////////////////////////////////////// 2058 2059 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv *env, jclass cls)) 2060 { 2061 JvmtiVMObjectAllocEventCollector oam; 2062 oop mirror = JNIHandles::resolve_non_null(cls); 2063 // Return null for primitives and arrays 2064 if (!java_lang_Class::is_primitive(mirror)) { 2065 Klass* k = java_lang_Class::as_Klass(mirror); 2066 if (k->is_instance_klass()) { 2067 InstanceKlass* k_h = InstanceKlass::cast(k); 2068 Handle jcp = reflect_ConstantPool::create(CHECK_NULL); 2069 reflect_ConstantPool::set_cp(jcp(), k_h->constants()); 2070 return JNIHandles::make_local(THREAD, jcp()); 2071 } 2072 } 2073 return nullptr; 2074 } 2075 JVM_END 2076 2077 2078 JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject obj)) 2079 { 2080 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2081 return cp->length(); 2082 } 2083 JVM_END 2084 2085 2086 JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject obj, jint index)) 2087 { 2088 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2089 bounds_check(cp, index, CHECK_NULL); 2090 constantTag tag = cp->tag_at(index); 2091 if (!tag.is_klass() && !tag.is_unresolved_klass()) { 2092 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2093 } 2094 Klass* k = cp->klass_at(index, CHECK_NULL); 2095 return (jclass) JNIHandles::make_local(THREAD, k->java_mirror()); 2096 } 2097 JVM_END 2098 2099 JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject obj, jint index)) 2100 { 2101 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2102 bounds_check(cp, index, CHECK_NULL); 2103 constantTag tag = cp->tag_at(index); 2104 if (!tag.is_klass() && !tag.is_unresolved_klass()) { 2105 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2106 } 2107 Klass* k = ConstantPool::klass_at_if_loaded(cp, index); 2108 if (k == nullptr) return nullptr; 2109 return (jclass) JNIHandles::make_local(THREAD, k->java_mirror()); 2110 } 2111 JVM_END 2112 2113 static jobject get_method_at_helper(const constantPoolHandle& cp, jint index, bool force_resolution, TRAPS) { 2114 constantTag tag = cp->tag_at(index); 2115 if (!tag.is_method() && !tag.is_interface_method()) { 2116 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2117 } 2118 int klass_ref = cp->uncached_klass_ref_index_at(index); 2119 Klass* k_o; 2120 if (force_resolution) { 2121 k_o = cp->klass_at(klass_ref, CHECK_NULL); 2122 } else { 2123 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref); 2124 if (k_o == nullptr) return nullptr; 2125 } 2126 InstanceKlass* k = InstanceKlass::cast(k_o); 2127 Symbol* name = cp->uncached_name_ref_at(index); 2128 Symbol* sig = cp->uncached_signature_ref_at(index); 2129 methodHandle m (THREAD, k->find_method(name, sig)); 2130 if (m.is_null()) { 2131 THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class"); 2132 } 2133 oop method; 2134 if (m->is_object_constructor()) { 2135 method = Reflection::new_constructor(m, CHECK_NULL); 2136 } else { 2137 method = Reflection::new_method(m, true, CHECK_NULL); 2138 } 2139 return JNIHandles::make_local(THREAD, method); 2140 } 2141 2142 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jint index)) 2143 { 2144 JvmtiVMObjectAllocEventCollector oam; 2145 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2146 bounds_check(cp, index, CHECK_NULL); 2147 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL); 2148 return res; 2149 } 2150 JVM_END 2151 2152 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jint index)) 2153 { 2154 JvmtiVMObjectAllocEventCollector oam; 2155 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2156 bounds_check(cp, index, CHECK_NULL); 2157 jobject res = get_method_at_helper(cp, index, false, CHECK_NULL); 2158 return res; 2159 } 2160 JVM_END 2161 2162 static jobject get_field_at_helper(constantPoolHandle cp, jint index, bool force_resolution, TRAPS) { 2163 constantTag tag = cp->tag_at(index); 2164 if (!tag.is_field()) { 2165 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2166 } 2167 int klass_ref = cp->uncached_klass_ref_index_at(index); 2168 Klass* k_o; 2169 if (force_resolution) { 2170 k_o = cp->klass_at(klass_ref, CHECK_NULL); 2171 } else { 2172 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref); 2173 if (k_o == nullptr) return nullptr; 2174 } 2175 InstanceKlass* k = InstanceKlass::cast(k_o); 2176 Symbol* name = cp->uncached_name_ref_at(index); 2177 Symbol* sig = cp->uncached_signature_ref_at(index); 2178 fieldDescriptor fd; 2179 Klass* target_klass = k->find_field(name, sig, &fd); 2180 if (target_klass == nullptr) { 2181 THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class"); 2182 } 2183 oop field = Reflection::new_field(&fd, CHECK_NULL); 2184 return JNIHandles::make_local(THREAD, field); 2185 } 2186 2187 JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject obj, jint index)) 2188 { 2189 JvmtiVMObjectAllocEventCollector oam; 2190 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2191 bounds_check(cp, index, CHECK_NULL); 2192 jobject res = get_field_at_helper(cp, index, true, CHECK_NULL); 2193 return res; 2194 } 2195 JVM_END 2196 2197 JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject obj, jint index)) 2198 { 2199 JvmtiVMObjectAllocEventCollector oam; 2200 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2201 bounds_check(cp, index, CHECK_NULL); 2202 jobject res = get_field_at_helper(cp, index, false, CHECK_NULL); 2203 return res; 2204 } 2205 JVM_END 2206 2207 JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject obj, jint index)) 2208 { 2209 JvmtiVMObjectAllocEventCollector oam; 2210 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2211 bounds_check(cp, index, CHECK_NULL); 2212 constantTag tag = cp->tag_at(index); 2213 if (!tag.is_field_or_method()) { 2214 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2215 } 2216 int klass_ref = cp->uncached_klass_ref_index_at(index); 2217 Symbol* klass_name = cp->klass_name_at(klass_ref); 2218 Symbol* member_name = cp->uncached_name_ref_at(index); 2219 Symbol* member_sig = cp->uncached_signature_ref_at(index); 2220 objArrayOop dest_o = oopFactory::new_objArray(vmClasses::String_klass(), 3, CHECK_NULL); 2221 objArrayHandle dest(THREAD, dest_o); 2222 Handle str = java_lang_String::create_from_symbol(klass_name, CHECK_NULL); 2223 dest->obj_at_put(0, str()); 2224 str = java_lang_String::create_from_symbol(member_name, CHECK_NULL); 2225 dest->obj_at_put(1, str()); 2226 str = java_lang_String::create_from_symbol(member_sig, CHECK_NULL); 2227 dest->obj_at_put(2, str()); 2228 return (jobjectArray) JNIHandles::make_local(THREAD, dest()); 2229 } 2230 JVM_END 2231 2232 JVM_ENTRY(jint, JVM_ConstantPoolGetClassRefIndexAt(JNIEnv *env, jobject obj, jint index)) 2233 { 2234 JvmtiVMObjectAllocEventCollector oam; 2235 constantPoolHandle cp(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2236 bounds_check(cp, index, CHECK_0); 2237 constantTag tag = cp->tag_at(index); 2238 if (!tag.is_field_or_method()) { 2239 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2240 } 2241 return (jint) cp->uncached_klass_ref_index_at(index); 2242 } 2243 JVM_END 2244 2245 JVM_ENTRY(jint, JVM_ConstantPoolGetNameAndTypeRefIndexAt(JNIEnv *env, jobject obj, jint index)) 2246 { 2247 JvmtiVMObjectAllocEventCollector oam; 2248 constantPoolHandle cp(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2249 bounds_check(cp, index, CHECK_0); 2250 constantTag tag = cp->tag_at(index); 2251 if (!tag.is_invoke_dynamic() && !tag.is_field_or_method()) { 2252 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2253 } 2254 return (jint) cp->uncached_name_and_type_ref_index_at(index); 2255 } 2256 JVM_END 2257 2258 JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetNameAndTypeRefInfoAt(JNIEnv *env, jobject obj, jint index)) 2259 { 2260 JvmtiVMObjectAllocEventCollector oam; 2261 constantPoolHandle cp(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_name_and_type()) { 2265 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2266 } 2267 Symbol* member_name = cp->symbol_at(cp->name_ref_index_at(index)); 2268 Symbol* member_sig = cp->symbol_at(cp->signature_ref_index_at(index)); 2269 objArrayOop dest_o = oopFactory::new_objArray(vmClasses::String_klass(), 2, CHECK_NULL); 2270 objArrayHandle dest(THREAD, dest_o); 2271 Handle str = java_lang_String::create_from_symbol(member_name, CHECK_NULL); 2272 dest->obj_at_put(0, str()); 2273 str = java_lang_String::create_from_symbol(member_sig, CHECK_NULL); 2274 dest->obj_at_put(1, str()); 2275 return (jobjectArray) JNIHandles::make_local(THREAD, dest()); 2276 } 2277 JVM_END 2278 2279 JVM_ENTRY(jint, JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject obj, jint index)) 2280 { 2281 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2282 bounds_check(cp, index, CHECK_0); 2283 constantTag tag = cp->tag_at(index); 2284 if (!tag.is_int()) { 2285 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2286 } 2287 return cp->int_at(index); 2288 } 2289 JVM_END 2290 2291 JVM_ENTRY(jlong, JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject obj, jint index)) 2292 { 2293 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2294 bounds_check(cp, index, CHECK_(0L)); 2295 constantTag tag = cp->tag_at(index); 2296 if (!tag.is_long()) { 2297 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2298 } 2299 return cp->long_at(index); 2300 } 2301 JVM_END 2302 2303 JVM_ENTRY(jfloat, JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject obj, jint index)) 2304 { 2305 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2306 bounds_check(cp, index, CHECK_(0.0f)); 2307 constantTag tag = cp->tag_at(index); 2308 if (!tag.is_float()) { 2309 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2310 } 2311 return cp->float_at(index); 2312 } 2313 JVM_END 2314 2315 JVM_ENTRY(jdouble, JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject obj, jint index)) 2316 { 2317 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2318 bounds_check(cp, index, CHECK_(0.0)); 2319 constantTag tag = cp->tag_at(index); 2320 if (!tag.is_double()) { 2321 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2322 } 2323 return cp->double_at(index); 2324 } 2325 JVM_END 2326 2327 JVM_ENTRY(jstring, JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject obj, jint index)) 2328 { 2329 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2330 bounds_check(cp, index, CHECK_NULL); 2331 constantTag tag = cp->tag_at(index); 2332 if (!tag.is_string()) { 2333 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2334 } 2335 oop str = cp->string_at(index, CHECK_NULL); 2336 return (jstring) JNIHandles::make_local(THREAD, str); 2337 } 2338 JVM_END 2339 2340 JVM_ENTRY(jstring, JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject obj, jint index)) 2341 { 2342 JvmtiVMObjectAllocEventCollector oam; 2343 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2344 bounds_check(cp, index, CHECK_NULL); 2345 constantTag tag = cp->tag_at(index); 2346 if (!tag.is_symbol()) { 2347 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2348 } 2349 Symbol* sym = cp->symbol_at(index); 2350 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 2351 return (jstring) JNIHandles::make_local(THREAD, str()); 2352 } 2353 JVM_END 2354 2355 JVM_ENTRY(jbyte, JVM_ConstantPoolGetTagAt(JNIEnv *env, jobject obj, jint index)) 2356 { 2357 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 2358 bounds_check(cp, index, CHECK_0); 2359 constantTag tag = cp->tag_at(index); 2360 jbyte result = tag.value(); 2361 // If returned tag values are not from the JVM spec, e.g. tags from 100 to 105, 2362 // they are changed to the corresponding tags from the JVM spec, so that java code in 2363 // sun.reflect.ConstantPool will return only tags from the JVM spec, not internal ones. 2364 if (tag.is_klass_or_reference()) { 2365 result = JVM_CONSTANT_Class; 2366 } else if (tag.is_string_index()) { 2367 result = JVM_CONSTANT_String; 2368 } else if (tag.is_method_type_in_error()) { 2369 result = JVM_CONSTANT_MethodType; 2370 } else if (tag.is_method_handle_in_error()) { 2371 result = JVM_CONSTANT_MethodHandle; 2372 } else if (tag.is_dynamic_constant_in_error()) { 2373 result = JVM_CONSTANT_Dynamic; 2374 } 2375 return result; 2376 } 2377 JVM_END 2378 2379 // Assertion support. ////////////////////////////////////////////////////////// 2380 2381 JVM_ENTRY(jboolean, JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)) 2382 assert(cls != nullptr, "bad class"); 2383 2384 oop r = JNIHandles::resolve(cls); 2385 assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed"); 2386 if (java_lang_Class::is_primitive(r)) return false; 2387 2388 Klass* k = java_lang_Class::as_Klass(r); 2389 assert(k->is_instance_klass(), "must be an instance klass"); 2390 if (!k->is_instance_klass()) return false; 2391 2392 ResourceMark rm(THREAD); 2393 const char* name = k->name()->as_C_string(); 2394 bool system_class = k->class_loader() == nullptr; 2395 return JavaAssertions::enabled(name, system_class); 2396 2397 JVM_END 2398 2399 2400 // Return a new AssertionStatusDirectives object with the fields filled in with 2401 // command-line assertion arguments (i.e., -ea, -da). 2402 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)) 2403 JvmtiVMObjectAllocEventCollector oam; 2404 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL); 2405 return JNIHandles::make_local(THREAD, asd); 2406 JVM_END 2407 2408 // Verification //////////////////////////////////////////////////////////////////////////////// 2409 2410 // Reflection for the verifier ///////////////////////////////////////////////////////////////// 2411 2412 // RedefineClasses support: bug 6214132 caused verification to fail. 2413 // All functions from this section, unless noted otherwise, should call the functions 2414 // get_klass_considering_redefinition(), or 2415 // get_instance_klass_considering_redefinition() 2416 // These functions return JvmtiThreadState::_scratch_class if the verifier 2417 // was invoked in the middle of the redefinition of cls. 2418 // See jvmtiThreadState.hpp for details. 2419 2420 inline Klass* get_klass_considering_redefinition(jclass cls, JavaThread* thread) { 2421 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2422 if (k->is_instance_klass()) { 2423 return JvmtiThreadState::class_to_verify_considering_redefinition(InstanceKlass::cast(k), thread); 2424 } else { 2425 return k; 2426 } 2427 } 2428 2429 inline InstanceKlass* get_instance_klass_considering_redefinition(jclass cls, JavaThread* thread) { 2430 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve_non_null(cls)); 2431 return JvmtiThreadState::class_to_verify_considering_redefinition(ik, thread); 2432 } 2433 2434 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls)) 2435 oop mirror = JNIHandles::resolve_non_null(cls); 2436 if (java_lang_Class::is_primitive(mirror)) { 2437 return JNI_FALSE; 2438 } 2439 Klass* k = java_lang_Class::as_Klass(mirror); 2440 // This isn't necessary since answer is the same because redefinition 2441 // has already checked this matches for the scratch class. 2442 // k = get_klass_considering_redefinition(cls, thread) 2443 jboolean result = k->is_interface(); 2444 assert(!result || k->is_instance_klass(), 2445 "all interfaces are instance types"); 2446 return result; 2447 JVM_END 2448 2449 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls)) 2450 // No need to call get_klass_considering_redefinition() as redefinition cannot change a class's name. 2451 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2452 return k->name()->as_utf8(); 2453 JVM_END 2454 2455 2456 JVM_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)) 2457 Klass* k = get_klass_considering_redefinition(cls, thread); 2458 // types will have length zero if this is not an InstanceKlass 2459 // (length is determined by call to JVM_GetClassCPEntriesCount) 2460 if (k->is_instance_klass()) { 2461 ConstantPool* cp = InstanceKlass::cast(k)->constants(); 2462 for (int index = cp->length() - 1; index >= 0; index--) { 2463 constantTag tag = cp->tag_at(index); 2464 types[index] = (tag.is_unresolved_klass()) ? (unsigned char) JVM_CONSTANT_Class : tag.value(); 2465 } 2466 } 2467 JVM_END 2468 2469 2470 JVM_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)) 2471 Klass* k = get_klass_considering_redefinition(cls, thread); 2472 return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->constants()->length(); 2473 JVM_END 2474 2475 2476 JVM_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)) 2477 Klass* k = get_klass_considering_redefinition(cls, thread); 2478 return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->java_fields_count(); 2479 JVM_END 2480 2481 2482 JVM_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)) 2483 Klass* k = get_klass_considering_redefinition(cls, thread); 2484 return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->methods()->length(); 2485 JVM_END 2486 2487 2488 // The following methods, used for the verifier, are never called with 2489 // array klasses, so a direct cast to InstanceKlass is safe. 2490 // Typically, these methods are called in a loop with bounds determined 2491 // by the results of JVM_GetClass{Fields,Methods}Count, which return 2492 // zero for arrays. 2493 JVM_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)) 2494 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2495 Method* method = ik->methods()->at(method_index); 2496 int length = method->checked_exceptions_length(); 2497 if (length > 0) { 2498 CheckedExceptionElement* table= method->checked_exceptions_start(); 2499 for (int i = 0; i < length; i++) { 2500 exceptions[i] = table[i].class_cp_index; 2501 } 2502 } 2503 JVM_END 2504 2505 2506 JVM_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)) 2507 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2508 Method* method = ik->methods()->at(method_index); 2509 return method->checked_exceptions_length(); 2510 JVM_END 2511 2512 2513 JVM_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)) 2514 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2515 Method* method = ik->methods()->at(method_index); 2516 memcpy(code, method->code_base(), method->code_size()); 2517 JVM_END 2518 2519 2520 JVM_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)) 2521 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2522 Method* method = ik->methods()->at(method_index); 2523 return method->code_size(); 2524 JVM_END 2525 2526 2527 JVM_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)) 2528 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2529 Method* method = ik->methods()->at(method_index); 2530 ExceptionTable extable(method); 2531 entry->start_pc = extable.start_pc(entry_index); 2532 entry->end_pc = extable.end_pc(entry_index); 2533 entry->handler_pc = extable.handler_pc(entry_index); 2534 entry->catchType = extable.catch_type_index(entry_index); 2535 JVM_END 2536 2537 2538 JVM_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)) 2539 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2540 Method* method = ik->methods()->at(method_index); 2541 return method->exception_table_length(); 2542 JVM_END 2543 2544 2545 JVM_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)) 2546 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2547 Method* method = ik->methods()->at(method_index); 2548 return method->access_flags().as_method_flags(); 2549 JVM_END 2550 2551 2552 JVM_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)) 2553 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2554 return ik->field_access_flags(field_index); 2555 JVM_END 2556 2557 2558 JVM_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)) 2559 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2560 Method* method = ik->methods()->at(method_index); 2561 return method->max_locals(); 2562 JVM_END 2563 2564 2565 JVM_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)) 2566 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2567 Method* method = ik->methods()->at(method_index); 2568 return method->size_of_parameters(); 2569 JVM_END 2570 2571 2572 JVM_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)) 2573 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2574 Method* method = ik->methods()->at(method_index); 2575 return method->verifier_max_stack(); 2576 JVM_END 2577 2578 2579 JVM_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)) 2580 ResourceMark rm(THREAD); 2581 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2582 Method* method = ik->methods()->at(method_index); 2583 return method->is_object_constructor(); 2584 JVM_END 2585 2586 2587 JVM_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index)) 2588 ResourceMark rm(THREAD); 2589 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2590 Method* method = ik->methods()->at(method_index); 2591 return method->is_overpass(); 2592 JVM_END 2593 2594 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)) 2595 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2596 Method* method = ik->methods()->at(method_index); 2597 return method->name()->as_utf8(); 2598 JVM_END 2599 2600 2601 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)) 2602 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2603 Method* method = ik->methods()->at(method_index); 2604 return method->signature()->as_utf8(); 2605 JVM_END 2606 2607 /** 2608 * All of these JVM_GetCP-xxx methods are used by the old verifier to 2609 * read entries in the constant pool. Since the old verifier always 2610 * works on a copy of the code, it will not see any rewriting that 2611 * may possibly occur in the middle of verification. So it is important 2612 * that nothing it calls tries to use the cpCache instead of the raw 2613 * constant pool, so we must use cp->uncached_x methods when appropriate. 2614 */ 2615 JVM_ENTRY(const char*, JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)) 2616 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2617 ConstantPool* cp = ik->constants(); 2618 switch (cp->tag_at(cp_index).value()) { 2619 case JVM_CONSTANT_Fieldref: 2620 return cp->uncached_name_ref_at(cp_index)->as_utf8(); 2621 default: 2622 fatal("JVM_GetCPFieldNameUTF: illegal constant"); 2623 } 2624 ShouldNotReachHere(); 2625 return nullptr; 2626 JVM_END 2627 2628 2629 JVM_ENTRY(const char*, JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)) 2630 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2631 ConstantPool* cp = ik->constants(); 2632 switch (cp->tag_at(cp_index).value()) { 2633 case JVM_CONSTANT_InterfaceMethodref: 2634 case JVM_CONSTANT_Methodref: 2635 return cp->uncached_name_ref_at(cp_index)->as_utf8(); 2636 default: 2637 fatal("JVM_GetCPMethodNameUTF: illegal constant"); 2638 } 2639 ShouldNotReachHere(); 2640 return nullptr; 2641 JVM_END 2642 2643 2644 JVM_ENTRY(const char*, JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)) 2645 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2646 ConstantPool* cp = ik->constants(); 2647 switch (cp->tag_at(cp_index).value()) { 2648 case JVM_CONSTANT_InterfaceMethodref: 2649 case JVM_CONSTANT_Methodref: 2650 return cp->uncached_signature_ref_at(cp_index)->as_utf8(); 2651 default: 2652 fatal("JVM_GetCPMethodSignatureUTF: illegal constant"); 2653 } 2654 ShouldNotReachHere(); 2655 return nullptr; 2656 JVM_END 2657 2658 2659 JVM_ENTRY(const char*, JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)) 2660 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2661 ConstantPool* cp = ik->constants(); 2662 switch (cp->tag_at(cp_index).value()) { 2663 case JVM_CONSTANT_Fieldref: 2664 return cp->uncached_signature_ref_at(cp_index)->as_utf8(); 2665 default: 2666 fatal("JVM_GetCPFieldSignatureUTF: illegal constant"); 2667 } 2668 ShouldNotReachHere(); 2669 return nullptr; 2670 JVM_END 2671 2672 2673 JVM_ENTRY(const char*, JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) 2674 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2675 ConstantPool* cp = ik->constants(); 2676 Symbol* classname = cp->klass_name_at(cp_index); 2677 return classname->as_utf8(); 2678 JVM_END 2679 2680 2681 JVM_ENTRY(const char*, JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) 2682 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2683 ConstantPool* cp = ik->constants(); 2684 switch (cp->tag_at(cp_index).value()) { 2685 case JVM_CONSTANT_Fieldref: { 2686 int class_index = cp->uncached_klass_ref_index_at(cp_index); 2687 Symbol* classname = cp->klass_name_at(class_index); 2688 return classname->as_utf8(); 2689 } 2690 default: 2691 fatal("JVM_GetCPFieldClassNameUTF: illegal constant"); 2692 } 2693 ShouldNotReachHere(); 2694 return nullptr; 2695 JVM_END 2696 2697 2698 JVM_ENTRY(const char*, JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) 2699 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2700 ConstantPool* cp = ik->constants(); 2701 switch (cp->tag_at(cp_index).value()) { 2702 case JVM_CONSTANT_Methodref: 2703 case JVM_CONSTANT_InterfaceMethodref: { 2704 int class_index = cp->uncached_klass_ref_index_at(cp_index); 2705 Symbol* classname = cp->klass_name_at(class_index); 2706 return classname->as_utf8(); 2707 } 2708 default: 2709 fatal("JVM_GetCPMethodClassNameUTF: illegal constant"); 2710 } 2711 ShouldNotReachHere(); 2712 return nullptr; 2713 JVM_END 2714 2715 2716 JVM_ENTRY(jint, JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)) 2717 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2718 InstanceKlass* ik_called = get_instance_klass_considering_redefinition(called_cls, thread); 2719 ConstantPool* cp = ik->constants(); 2720 ConstantPool* cp_called = ik_called->constants(); 2721 switch (cp->tag_at(cp_index).value()) { 2722 case JVM_CONSTANT_Fieldref: { 2723 Symbol* name = cp->uncached_name_ref_at(cp_index); 2724 Symbol* signature = cp->uncached_signature_ref_at(cp_index); 2725 for (JavaFieldStream fs(ik_called); !fs.done(); fs.next()) { 2726 if (fs.name() == name && fs.signature() == signature) { 2727 return fs.access_flags().as_field_flags(); 2728 } 2729 } 2730 return -1; 2731 } 2732 default: 2733 fatal("JVM_GetCPFieldModifiers: illegal constant"); 2734 } 2735 ShouldNotReachHere(); 2736 return 0; 2737 JVM_END 2738 2739 2740 JVM_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)) 2741 InstanceKlass* ik = get_instance_klass_considering_redefinition(cls, thread); 2742 InstanceKlass* ik_called = get_instance_klass_considering_redefinition(called_cls, thread); 2743 ConstantPool* cp = ik->constants(); 2744 switch (cp->tag_at(cp_index).value()) { 2745 case JVM_CONSTANT_Methodref: 2746 case JVM_CONSTANT_InterfaceMethodref: { 2747 Symbol* name = cp->uncached_name_ref_at(cp_index); 2748 Symbol* signature = cp->uncached_signature_ref_at(cp_index); 2749 Array<Method*>* methods = ik_called->methods(); 2750 int methods_count = methods->length(); 2751 for (int i = 0; i < methods_count; i++) { 2752 Method* method = methods->at(i); 2753 if (method->name() == name && method->signature() == signature) { 2754 return method->access_flags().as_method_flags(); 2755 } 2756 } 2757 return -1; 2758 } 2759 default: 2760 fatal("JVM_GetCPMethodModifiers: illegal constant"); 2761 } 2762 ShouldNotReachHere(); 2763 return 0; 2764 JVM_END 2765 2766 2767 // Misc ////////////////////////////////////////////////////////////////////////////////////////////// 2768 2769 JVM_LEAF(void, JVM_ReleaseUTF(const char *utf)) 2770 // So long as UTF8::convert_to_utf8 returns resource strings, we don't have to do anything 2771 JVM_END 2772 2773 2774 JVM_ENTRY(jboolean, JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)) 2775 oop class1_mirror = JNIHandles::resolve_non_null(class1); 2776 oop class2_mirror = JNIHandles::resolve_non_null(class2); 2777 Klass* klass1 = java_lang_Class::as_Klass(class1_mirror); 2778 Klass* klass2 = java_lang_Class::as_Klass(class2_mirror); 2779 return (jboolean) Reflection::is_same_class_package(klass1, klass2); 2780 JVM_END 2781 2782 // Printing support ////////////////////////////////////////////////// 2783 extern "C" { 2784 2785 ATTRIBUTE_PRINTF(3, 0) 2786 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args) { 2787 // Reject count values that are negative signed values converted to 2788 // unsigned; see bug 4399518, 4417214 2789 if ((intptr_t)count <= 0) return -1; 2790 2791 int result = os::vsnprintf(str, count, fmt, args); 2792 if (result > 0 && (size_t)result >= count) { 2793 result = -1; 2794 } 2795 2796 return result; 2797 } 2798 2799 ATTRIBUTE_PRINTF(3, 4) 2800 int jio_snprintf(char *str, size_t count, const char *fmt, ...) { 2801 va_list args; 2802 int len; 2803 va_start(args, fmt); 2804 len = jio_vsnprintf(str, count, fmt, args); 2805 va_end(args); 2806 return len; 2807 } 2808 2809 ATTRIBUTE_PRINTF(2, 3) 2810 int jio_fprintf(FILE* f, const char *fmt, ...) { 2811 int len; 2812 va_list args; 2813 va_start(args, fmt); 2814 len = jio_vfprintf(f, fmt, args); 2815 va_end(args); 2816 return len; 2817 } 2818 2819 ATTRIBUTE_PRINTF(2, 0) 2820 int jio_vfprintf(FILE* f, const char *fmt, va_list args) { 2821 if (Arguments::vfprintf_hook() != nullptr) { 2822 return Arguments::vfprintf_hook()(f, fmt, args); 2823 } else { 2824 return vfprintf(f, fmt, args); 2825 } 2826 } 2827 2828 ATTRIBUTE_PRINTF(1, 2) 2829 JNIEXPORT int jio_printf(const char *fmt, ...) { 2830 int len; 2831 va_list args; 2832 va_start(args, fmt); 2833 len = jio_vfprintf(defaultStream::output_stream(), fmt, args); 2834 va_end(args); 2835 return len; 2836 } 2837 2838 // HotSpot specific jio method 2839 void jio_print(const char* s, size_t len) { 2840 // Try to make this function as atomic as possible. 2841 if (Arguments::vfprintf_hook() != nullptr) { 2842 jio_fprintf(defaultStream::output_stream(), "%.*s", (int)len, s); 2843 } else { 2844 // Make an unused local variable to avoid warning from gcc compiler. 2845 bool dummy = os::write(defaultStream::output_fd(), s, len); 2846 } 2847 } 2848 2849 } // Extern C 2850 2851 // java.lang.Thread ////////////////////////////////////////////////////////////////////////////// 2852 2853 // In most of the JVM thread support functions we need to access the 2854 // thread through a ThreadsListHandle to prevent it from exiting and 2855 // being reclaimed while we try to operate on it. The exceptions to this 2856 // rule are when operating on the current thread, or if the monitor of 2857 // the target java.lang.Thread is locked at the Java level - in both 2858 // cases the target cannot exit. 2859 2860 static void thread_entry(JavaThread* thread, TRAPS) { 2861 HandleMark hm(THREAD); 2862 Handle obj(THREAD, thread->threadObj()); 2863 JavaValue result(T_VOID); 2864 JavaCalls::call_virtual(&result, 2865 obj, 2866 vmClasses::Thread_klass(), 2867 vmSymbols::run_method_name(), 2868 vmSymbols::void_method_signature(), 2869 THREAD); 2870 } 2871 2872 2873 JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread)) 2874 #if INCLUDE_CDS 2875 if (CDSConfig::allow_only_single_java_thread()) { 2876 // During java -Xshare:dump, if we allow multiple Java threads to 2877 // execute in parallel, symbols and classes may be loaded in 2878 // random orders which will make the resulting CDS archive 2879 // non-deterministic. 2880 // 2881 // Lucikly, during java -Xshare:dump, it's important to run only 2882 // the code in the main Java thread (which is NOT started here) that 2883 // creates the module graph, etc. It's safe to not start the other 2884 // threads which are launched by class static initializers 2885 // (ReferenceHandler, FinalizerThread and CleanerImpl). 2886 if (log_is_enabled(Info, aot)) { 2887 ResourceMark rm; 2888 oop t = JNIHandles::resolve_non_null(jthread); 2889 log_info(aot)("JVM_StartThread() ignored: %s", t->klass()->external_name()); 2890 } 2891 return; 2892 } 2893 #endif 2894 JavaThread *native_thread = nullptr; 2895 2896 // We cannot hold the Threads_lock when we throw an exception, 2897 // due to rank ordering issues. Example: we might need to grab the 2898 // Heap_lock while we construct the exception. 2899 bool throw_illegal_thread_state = false; 2900 2901 // We must release the Threads_lock before we can post a jvmti event 2902 // in Thread::start. 2903 { 2904 ConditionalMutexLocker throttle_ml(ThreadsLockThrottle_lock, UseThreadsLockThrottleLock); 2905 // Ensure that the C++ Thread and OSThread structures aren't freed before 2906 // we operate. 2907 MutexLocker ml(Threads_lock); 2908 2909 // Since JDK 5 the java.lang.Thread threadStatus is used to prevent 2910 // re-starting an already started thread, so we should usually find 2911 // that the JavaThread is null. However for a JNI attached thread 2912 // there is a small window between the Thread object being created 2913 // (with its JavaThread set) and the update to its threadStatus, so we 2914 // have to check for this 2915 if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != nullptr) { 2916 throw_illegal_thread_state = true; 2917 } else { 2918 jlong size = 2919 java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread)); 2920 // Allocate the C++ Thread structure and create the native thread. The 2921 // stack size retrieved from java is 64-bit signed, but the constructor takes 2922 // size_t (an unsigned type), which may be 32 or 64-bit depending on the platform. 2923 // - Avoid truncating on 32-bit platforms if size is greater than UINT_MAX. 2924 // - Avoid passing negative values which would result in really large stacks. 2925 NOT_LP64(if (size > SIZE_MAX) size = SIZE_MAX;) 2926 size_t sz = size > 0 ? (size_t) size : 0; 2927 native_thread = new JavaThread(&thread_entry, sz); 2928 2929 // At this point it may be possible that no osthread was created for the 2930 // JavaThread due to lack of memory. Check for this situation and throw 2931 // an exception if necessary. Eventually we may want to change this so 2932 // that we only grab the lock if the thread was created successfully - 2933 // then we can also do this check and throw the exception in the 2934 // JavaThread constructor. 2935 if (native_thread->osthread() != nullptr) { 2936 // Note: the current thread is not being used within "prepare". 2937 native_thread->prepare(jthread); 2938 } 2939 } 2940 } 2941 2942 if (throw_illegal_thread_state) { 2943 THROW(vmSymbols::java_lang_IllegalThreadStateException()); 2944 } 2945 2946 assert(native_thread != nullptr, "Starting null thread?"); 2947 2948 if (native_thread->osthread() == nullptr) { 2949 ResourceMark rm(thread); 2950 log_warning(os, thread)("Failed to start the native thread for java.lang.Thread \"%s\"", 2951 JavaThread::name_for(JNIHandles::resolve_non_null(jthread))); 2952 // No one should hold a reference to the 'native_thread'. 2953 native_thread->smr_delete(); 2954 if (JvmtiExport::should_post_resource_exhausted()) { 2955 JvmtiExport::post_resource_exhausted( 2956 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS, 2957 os::native_thread_creation_failed_msg()); 2958 } 2959 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), 2960 os::native_thread_creation_failed_msg()); 2961 } 2962 2963 JFR_ONLY(Jfr::on_java_thread_start(thread, native_thread);) 2964 2965 Thread::start(native_thread); 2966 2967 JVM_END 2968 2969 2970 JVM_ENTRY(void, JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)) 2971 ThreadsListHandle tlh(thread); 2972 oop java_thread = nullptr; 2973 JavaThread* receiver = nullptr; 2974 bool is_alive = tlh.cv_internal_thread_to_JavaThread(jthread, &receiver, &java_thread); 2975 java_lang_Thread::set_priority(java_thread, (ThreadPriority)prio); 2976 2977 if (is_alive) { 2978 // jthread refers to a live JavaThread. 2979 Thread::set_priority(receiver, (ThreadPriority)prio); 2980 } 2981 // Implied else: If the JavaThread hasn't started yet, then the 2982 // priority set in the java.lang.Thread object above will be pushed 2983 // down when it does start. 2984 JVM_END 2985 2986 2987 JVM_LEAF(void, JVM_Yield(JNIEnv *env, jclass threadClass)) 2988 HOTSPOT_THREAD_YIELD(); 2989 os::naked_yield(); 2990 JVM_END 2991 2992 JVM_ENTRY(void, JVM_SleepNanos(JNIEnv* env, jclass threadClass, jlong nanos)) 2993 if (nanos < 0) { 2994 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nanosecond timeout value out of range"); 2995 } 2996 2997 if (thread->is_interrupted(true) && !HAS_PENDING_EXCEPTION) { 2998 THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted"); 2999 } 3000 3001 // Save current thread state and restore it at the end of this block. 3002 // And set new thread state to SLEEPING. 3003 JavaThreadSleepState jtss(thread); 3004 3005 HOTSPOT_THREAD_SLEEP_BEGIN(nanos / NANOSECS_PER_MILLISEC); 3006 3007 if (nanos == 0) { 3008 os::naked_yield(); 3009 } else { 3010 ThreadState old_state = thread->osthread()->get_state(); 3011 thread->osthread()->set_state(SLEEPING); 3012 if (!thread->sleep_nanos(nanos)) { // interrupted or async exception was installed 3013 // An asynchronous exception could have been thrown on 3014 // us while we were sleeping. We do not overwrite those. 3015 if (!HAS_PENDING_EXCEPTION) { 3016 HOTSPOT_THREAD_SLEEP_END(1); 3017 if (!thread->has_async_exception_condition()) { 3018 // TODO-FIXME: THROW_MSG returns which means we will not call set_state() 3019 // to properly restore the thread state. That's likely wrong. 3020 THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted"); 3021 } 3022 } 3023 } 3024 thread->osthread()->set_state(old_state); 3025 } 3026 HOTSPOT_THREAD_SLEEP_END(0); 3027 JVM_END 3028 3029 JVM_ENTRY(jobject, JVM_CurrentCarrierThread(JNIEnv* env, jclass threadClass)) 3030 oop jthread = thread->threadObj(); 3031 assert(jthread != nullptr, "no current carrier thread!"); 3032 return JNIHandles::make_local(THREAD, jthread); 3033 JVM_END 3034 3035 JVM_ENTRY(jobject, JVM_CurrentThread(JNIEnv* env, jclass threadClass)) 3036 oop theThread = thread->vthread(); 3037 assert(theThread != (oop)nullptr, "no current thread!"); 3038 return JNIHandles::make_local(THREAD, theThread); 3039 JVM_END 3040 3041 JVM_ENTRY(void, JVM_SetCurrentThread(JNIEnv* env, jobject thisThread, 3042 jobject theThread)) 3043 oop threadObj = JNIHandles::resolve(theThread); 3044 thread->set_vthread(threadObj); 3045 3046 // Set _monitor_owner_id of new current Thread 3047 thread->set_monitor_owner_id(java_lang_Thread::thread_id(threadObj)); 3048 3049 JFR_ONLY(Jfr::on_set_current_thread(thread, threadObj);) 3050 JVM_END 3051 3052 JVM_ENTRY(jlong, JVM_GetNextThreadIdOffset(JNIEnv* env, jclass threadClass)) 3053 return ThreadIdentifier::unsafe_offset(); 3054 JVM_END 3055 3056 JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread)) 3057 ThreadsListHandle tlh(thread); 3058 JavaThread* receiver = nullptr; 3059 bool is_alive = tlh.cv_internal_thread_to_JavaThread(jthread, &receiver, nullptr); 3060 if (is_alive) { 3061 // jthread refers to a live JavaThread. 3062 receiver->interrupt(); 3063 } 3064 JVM_END 3065 3066 // Return true iff the current thread has locked the object passed in 3067 3068 JVM_ENTRY(jboolean, JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)) 3069 if (obj == nullptr) { 3070 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE); 3071 } 3072 Handle h_obj(THREAD, JNIHandles::resolve(obj)); 3073 return ObjectSynchronizer::current_thread_holds_lock(thread, h_obj); 3074 JVM_END 3075 3076 JVM_ENTRY(jobject, JVM_GetStackTrace(JNIEnv *env, jobject jthread)) 3077 oop trace = java_lang_Thread::async_get_stack_trace(jthread, THREAD); 3078 return JNIHandles::make_local(THREAD, trace); 3079 JVM_END 3080 3081 JVM_ENTRY(jobject, JVM_CreateThreadSnapshot(JNIEnv* env, jobject jthread)) 3082 #if INCLUDE_JVMTI 3083 oop snapshot = ThreadSnapshotFactory::get_thread_snapshot(jthread, THREAD); 3084 return JNIHandles::make_local(THREAD, snapshot); 3085 #else 3086 THROW_NULL(vmSymbols::java_lang_UnsupportedOperationException()); 3087 #endif 3088 JVM_END 3089 3090 JVM_ENTRY(void, JVM_SetNativeThreadName(JNIEnv* env, jobject jthread, jstring name)) 3091 // We don't use a ThreadsListHandle here because the current thread 3092 // must be alive. 3093 oop java_thread = JNIHandles::resolve_non_null(jthread); 3094 JavaThread* thr = java_lang_Thread::thread(java_thread); 3095 if (thread == thr && !thr->has_attached_via_jni()) { 3096 // Thread naming is only supported for the current thread and 3097 // we don't set the name of an attached thread to avoid stepping 3098 // on other programs. 3099 ResourceMark rm(thread); 3100 const char *thread_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name)); 3101 os::set_native_thread_name(thread_name); 3102 } 3103 JVM_END 3104 3105 JVM_ENTRY(jobject, JVM_ScopedValueCache(JNIEnv* env, jclass threadClass)) 3106 oop theCache = thread->scopedValueCache(); 3107 return JNIHandles::make_local(THREAD, theCache); 3108 JVM_END 3109 3110 JVM_ENTRY(void, JVM_SetScopedValueCache(JNIEnv* env, jclass threadClass, 3111 jobject theCache)) 3112 arrayOop objs = arrayOop(JNIHandles::resolve(theCache)); 3113 thread->set_scopedValueCache(objs); 3114 JVM_END 3115 3116 3117 // java.lang.Package //////////////////////////////////////////////////////////////// 3118 3119 3120 JVM_ENTRY(jstring, JVM_GetSystemPackage(JNIEnv *env, jstring name)) 3121 ResourceMark rm(THREAD); 3122 JvmtiVMObjectAllocEventCollector oam; 3123 char* str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name)); 3124 oop result = ClassLoader::get_system_package(str, CHECK_NULL); 3125 return (jstring) JNIHandles::make_local(THREAD, result); 3126 JVM_END 3127 3128 3129 JVM_ENTRY(jobjectArray, JVM_GetSystemPackages(JNIEnv *env)) 3130 JvmtiVMObjectAllocEventCollector oam; 3131 objArrayOop result = ClassLoader::get_system_packages(CHECK_NULL); 3132 return (jobjectArray) JNIHandles::make_local(THREAD, result); 3133 JVM_END 3134 3135 3136 // java.lang.ref.Reference /////////////////////////////////////////////////////////////// 3137 3138 3139 JVM_ENTRY(jobject, JVM_GetAndClearReferencePendingList(JNIEnv* env)) 3140 MonitorLocker ml(Heap_lock); 3141 oop ref = Universe::reference_pending_list(); 3142 if (ref != nullptr) { 3143 Universe::clear_reference_pending_list(); 3144 } 3145 return JNIHandles::make_local(THREAD, ref); 3146 JVM_END 3147 3148 JVM_ENTRY(jboolean, JVM_HasReferencePendingList(JNIEnv* env)) 3149 MonitorLocker ml(Heap_lock); 3150 return Universe::has_reference_pending_list(); 3151 JVM_END 3152 3153 JVM_ENTRY(void, JVM_WaitForReferencePendingList(JNIEnv* env)) 3154 MonitorLocker ml(Heap_lock); 3155 while (!Universe::has_reference_pending_list()) { 3156 ml.wait(); 3157 } 3158 JVM_END 3159 3160 JVM_ENTRY(jobject, JVM_ReferenceGet(JNIEnv* env, jobject ref)) 3161 oop ref_oop = JNIHandles::resolve_non_null(ref); 3162 // PhantomReference has its own implementation of get(). 3163 assert(!java_lang_ref_Reference::is_phantom(ref_oop), "precondition"); 3164 oop referent = java_lang_ref_Reference::weak_referent(ref_oop); 3165 return JNIHandles::make_local(THREAD, referent); 3166 JVM_END 3167 3168 JVM_ENTRY(jboolean, JVM_ReferenceRefersTo(JNIEnv* env, jobject ref, jobject o)) 3169 oop ref_oop = JNIHandles::resolve_non_null(ref); 3170 // PhantomReference has its own implementation of refersTo(). 3171 // See: JVM_PhantomReferenceRefersTo 3172 assert(!java_lang_ref_Reference::is_phantom(ref_oop), "precondition"); 3173 oop referent = java_lang_ref_Reference::weak_referent_no_keepalive(ref_oop); 3174 return referent == JNIHandles::resolve(o); 3175 JVM_END 3176 3177 JVM_ENTRY(void, JVM_ReferenceClear(JNIEnv* env, jobject ref)) 3178 oop ref_oop = JNIHandles::resolve_non_null(ref); 3179 // FinalReference has it's own implementation of clear(). 3180 assert(!java_lang_ref_Reference::is_final(ref_oop), "precondition"); 3181 if (java_lang_ref_Reference::unknown_referent_no_keepalive(ref_oop) == nullptr) { 3182 // If the referent has already been cleared then done. 3183 // However, if the referent is dead but has not yet been cleared by 3184 // concurrent reference processing, it should NOT be cleared here. 3185 // Instead, clearing should be left to the GC. Clearing it here could 3186 // detectably lose an expected notification, which is impossible with 3187 // STW reference processing. The clearing in enqueue() doesn't have 3188 // this problem, since the enqueue covers the notification, but it's not 3189 // worth the effort to handle that case specially. 3190 return; 3191 } 3192 java_lang_ref_Reference::clear_referent(ref_oop); 3193 JVM_END 3194 3195 3196 // java.lang.ref.PhantomReference ////////////////////////////////////////////////// 3197 3198 3199 JVM_ENTRY(jboolean, JVM_PhantomReferenceRefersTo(JNIEnv* env, jobject ref, jobject o)) 3200 oop ref_oop = JNIHandles::resolve_non_null(ref); 3201 oop referent = java_lang_ref_Reference::phantom_referent_no_keepalive(ref_oop); 3202 return referent == JNIHandles::resolve(o); 3203 JVM_END 3204 3205 3206 // ObjectInputStream /////////////////////////////////////////////////////////////// 3207 3208 // Return the first user-defined class loader up the execution stack, or null 3209 // if only code from the bootstrap or platform class loader is on the stack. 3210 3211 JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env)) 3212 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { 3213 InstanceKlass* ik = vfst.method()->method_holder(); 3214 oop loader = ik->class_loader(); 3215 if (loader != nullptr && !SystemDictionary::is_platform_class_loader(loader)) { 3216 return JNIHandles::make_local(THREAD, loader); 3217 } 3218 } 3219 return nullptr; 3220 JVM_END 3221 3222 3223 // Array /////////////////////////////////////////////////////////////////////////////////////////// 3224 3225 3226 // resolve array handle and check arguments 3227 static inline arrayOop check_array(JNIEnv *env, jobject arr, bool type_array_only, TRAPS) { 3228 if (arr == nullptr) { 3229 THROW_NULL(vmSymbols::java_lang_NullPointerException()); 3230 } 3231 oop a = JNIHandles::resolve_non_null(arr); 3232 if (!a->is_array()) { 3233 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array"); 3234 } else if (type_array_only && !a->is_typeArray()) { 3235 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array of primitive type"); 3236 } 3237 return arrayOop(a); 3238 } 3239 3240 3241 JVM_ENTRY(jint, JVM_GetArrayLength(JNIEnv *env, jobject arr)) 3242 arrayOop a = check_array(env, arr, false, CHECK_0); 3243 return a->length(); 3244 JVM_END 3245 3246 3247 JVM_ENTRY(jobject, JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)) 3248 JvmtiVMObjectAllocEventCollector oam; 3249 arrayOop a = check_array(env, arr, false, CHECK_NULL); 3250 jvalue value; 3251 BasicType type = Reflection::array_get(&value, a, index, CHECK_NULL); 3252 oop box = Reflection::box(&value, type, CHECK_NULL); 3253 return JNIHandles::make_local(THREAD, box); 3254 JVM_END 3255 3256 3257 JVM_ENTRY(jvalue, JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)) 3258 jvalue value; 3259 value.i = 0; // to initialize value before getting used in CHECK 3260 arrayOop a = check_array(env, arr, true, CHECK_(value)); 3261 assert(a->is_typeArray(), "just checking"); 3262 BasicType type = Reflection::array_get(&value, a, index, CHECK_(value)); 3263 BasicType wide_type = (BasicType) wCode; 3264 if (type != wide_type) { 3265 Reflection::widen(&value, type, wide_type, CHECK_(value)); 3266 } 3267 return value; 3268 JVM_END 3269 3270 3271 JVM_ENTRY(void, JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)) 3272 arrayOop a = check_array(env, arr, false, CHECK); 3273 oop box = JNIHandles::resolve(val); 3274 jvalue value; 3275 value.i = 0; // to initialize value before getting used in CHECK 3276 BasicType value_type; 3277 if (a->is_objArray()) { 3278 // Make sure we do no unbox e.g. java/lang/Integer instances when storing into an object array 3279 value_type = Reflection::unbox_for_regular_object(box, &value); 3280 } else { 3281 value_type = Reflection::unbox_for_primitive(box, &value, CHECK); 3282 } 3283 Reflection::array_set(&value, a, index, value_type, CHECK); 3284 JVM_END 3285 3286 3287 JVM_ENTRY(void, JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)) 3288 arrayOop a = check_array(env, arr, true, CHECK); 3289 assert(a->is_typeArray(), "just checking"); 3290 BasicType value_type = (BasicType) vCode; 3291 Reflection::array_set(&v, a, index, value_type, CHECK); 3292 JVM_END 3293 3294 3295 JVM_ENTRY(jobject, JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)) 3296 JvmtiVMObjectAllocEventCollector oam; 3297 oop element_mirror = JNIHandles::resolve(eltClass); 3298 oop result = Reflection::reflect_new_array(element_mirror, length, CHECK_NULL); 3299 return JNIHandles::make_local(THREAD, result); 3300 JVM_END 3301 3302 3303 JVM_ENTRY(jobject, JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)) 3304 JvmtiVMObjectAllocEventCollector oam; 3305 arrayOop dim_array = check_array(env, dim, true, CHECK_NULL); 3306 oop element_mirror = JNIHandles::resolve(eltClass); 3307 assert(dim_array->is_typeArray(), "just checking"); 3308 oop result = Reflection::reflect_new_multi_array(element_mirror, typeArrayOop(dim_array), CHECK_NULL); 3309 return JNIHandles::make_local(THREAD, result); 3310 JVM_END 3311 3312 3313 // Library support /////////////////////////////////////////////////////////////////////////// 3314 3315 JVM_LEAF(void*, JVM_LoadZipLibrary()) 3316 return ZipLibrary::handle(); 3317 JVM_END 3318 3319 JVM_ENTRY_NO_ENV(void*, JVM_LoadLibrary(const char* name, jboolean throwException)) 3320 //%note jvm_ct 3321 char ebuf[1024]; 3322 void *load_result; 3323 { 3324 ThreadToNativeFromVM ttnfvm(thread); 3325 load_result = os::dll_load(name, ebuf, sizeof ebuf); 3326 } 3327 if (load_result == nullptr) { 3328 if (throwException) { 3329 char msg[1024]; 3330 jio_snprintf(msg, sizeof msg, "%s: %s", name, ebuf); 3331 // Since 'ebuf' may contain a string encoded using 3332 // platform encoding scheme, we need to pass 3333 // Exceptions::unsafe_to_utf8 to the new_exception method 3334 // as the last argument. See bug 6367357. 3335 Handle h_exception = 3336 Exceptions::new_exception(thread, 3337 vmSymbols::java_lang_UnsatisfiedLinkError(), 3338 msg, Exceptions::unsafe_to_utf8); 3339 3340 THROW_HANDLE_NULL(h_exception); 3341 } else { 3342 log_info(library)("Failed to load library %s", name); 3343 return load_result; 3344 } 3345 } 3346 log_info(library)("Loaded library %s, handle " INTPTR_FORMAT, name, p2i(load_result)); 3347 return load_result; 3348 JVM_END 3349 3350 3351 JVM_LEAF(void, JVM_UnloadLibrary(void* handle)) 3352 os::dll_unload(handle); 3353 log_info(library)("Unloaded library with handle " INTPTR_FORMAT, p2i(handle)); 3354 JVM_END 3355 3356 3357 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name)) 3358 void* find_result = os::dll_lookup(handle, name); 3359 log_info(library)("%s %s in library with handle " INTPTR_FORMAT, 3360 find_result != nullptr ? "Found" : "Failed to find", 3361 name, p2i(handle)); 3362 return find_result; 3363 JVM_END 3364 3365 3366 // JNI version /////////////////////////////////////////////////////////////////////////////// 3367 3368 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version)) 3369 return Threads::is_supported_jni_version_including_1_1(version); 3370 JVM_END 3371 3372 3373 JVM_LEAF(jboolean, JVM_IsPreviewEnabled(void)) 3374 return Arguments::enable_preview() ? JNI_TRUE : JNI_FALSE; 3375 JVM_END 3376 3377 JVM_LEAF(jboolean, JVM_IsValhallaEnabled(void)) 3378 return EnableValhalla ? JNI_TRUE : JNI_FALSE; 3379 JVM_END 3380 3381 JVM_LEAF(jboolean, JVM_IsContinuationsSupported(void)) 3382 return VMContinuations ? JNI_TRUE : JNI_FALSE; 3383 JVM_END 3384 3385 JVM_LEAF(jboolean, JVM_IsForeignLinkerSupported(void)) 3386 return ForeignGlobals::is_foreign_linker_supported() ? JNI_TRUE : JNI_FALSE; 3387 JVM_END 3388 3389 JVM_LEAF(jboolean, JVM_IsStaticallyLinked(void)) 3390 return is_vm_statically_linked() ? JNI_TRUE : JNI_FALSE; 3391 JVM_END 3392 3393 // String support /////////////////////////////////////////////////////////////////////////// 3394 3395 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str)) 3396 JvmtiVMObjectAllocEventCollector oam; 3397 if (str == nullptr) return nullptr; 3398 oop string = JNIHandles::resolve_non_null(str); 3399 oop result = StringTable::intern(string, CHECK_NULL); 3400 return (jstring) JNIHandles::make_local(THREAD, result); 3401 JVM_END 3402 3403 3404 // VM Raw monitor support ////////////////////////////////////////////////////////////////////// 3405 3406 // VM Raw monitors (not to be confused with JvmtiRawMonitors) are a simple mutual exclusion 3407 // lock (not actually monitors: no wait/notify) that is exported by the VM for use by JDK 3408 // library code. They may be used by JavaThreads and non-JavaThreads and do not participate 3409 // in the safepoint protocol, thread suspension, thread interruption, or most things of that 3410 // nature, except JavaThreads will be blocked by VM_Exit::block_if_vm_exited if the VM has 3411 // shutdown. JavaThreads will be "in native" when using this API from JDK code. 3412 3413 3414 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void) { 3415 VM_Exit::block_if_vm_exited(); 3416 return new PlatformMutex(); 3417 } 3418 3419 3420 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon) { 3421 VM_Exit::block_if_vm_exited(); 3422 delete ((PlatformMutex*) mon); 3423 } 3424 3425 3426 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon) { 3427 VM_Exit::block_if_vm_exited(); 3428 ((PlatformMutex*) mon)->lock(); 3429 return 0; 3430 } 3431 3432 3433 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon) { 3434 VM_Exit::block_if_vm_exited(); 3435 ((PlatformMutex*) mon)->unlock(); 3436 } 3437 3438 3439 // Shared JNI/JVM entry points ////////////////////////////////////////////////////////////// 3440 3441 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init, 3442 Handle loader, jboolean throwError, TRAPS) { 3443 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, throwError != 0, CHECK_NULL); 3444 3445 // Check if we should initialize the class 3446 if (init && klass->is_instance_klass()) { 3447 klass->initialize(CHECK_NULL); 3448 } 3449 return (jclass) JNIHandles::make_local(THREAD, klass->java_mirror()); 3450 } 3451 3452 3453 // Method /////////////////////////////////////////////////////////////////////////////////////////// 3454 3455 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)) 3456 Handle method_handle; 3457 if (thread->stack_overflow_state()->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) { 3458 method_handle = Handle(THREAD, JNIHandles::resolve(method)); 3459 Handle receiver(THREAD, JNIHandles::resolve(obj)); 3460 objArrayHandle args(THREAD, (objArrayOop)JNIHandles::resolve(args0)); 3461 assert(args() == nullptr || !args->is_flatArray(), "args are never flat or are they???"); 3462 3463 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL); 3464 jobject res = JNIHandles::make_local(THREAD, result); 3465 if (JvmtiExport::should_post_vm_object_alloc()) { 3466 oop ret_type = java_lang_reflect_Method::return_type(method_handle()); 3467 assert(ret_type != nullptr, "sanity check: ret_type oop must not be null!"); 3468 if (java_lang_Class::is_primitive(ret_type)) { 3469 // Only for primitive type vm allocates memory for java object. 3470 // See box() method. 3471 JvmtiExport::post_vm_object_alloc(thread, result); 3472 } 3473 } 3474 return res; 3475 } else { 3476 THROW_NULL(vmSymbols::java_lang_StackOverflowError()); 3477 } 3478 JVM_END 3479 3480 3481 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0)) 3482 objArrayHandle args(THREAD, (objArrayOop)JNIHandles::resolve(args0)); 3483 assert(args() == nullptr || !args->is_flatArray(), "args are never flat or are they???"); 3484 oop constructor_mirror = JNIHandles::resolve(c); 3485 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL); 3486 jobject res = JNIHandles::make_local(THREAD, result); 3487 if (JvmtiExport::should_post_vm_object_alloc()) { 3488 JvmtiExport::post_vm_object_alloc(thread, result); 3489 } 3490 return res; 3491 JVM_END 3492 3493 JVM_ENTRY(void, JVM_InitializeFromArchive(JNIEnv* env, jclass cls)) 3494 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); 3495 HeapShared::initialize_from_archived_subgraph(THREAD, k); 3496 JVM_END 3497 3498 JVM_ENTRY(void, JVM_RegisterLambdaProxyClassForArchiving(JNIEnv* env, 3499 jclass caller, 3500 jstring interfaceMethodName, 3501 jobject factoryType, 3502 jobject interfaceMethodType, 3503 jobject implementationMember, 3504 jobject dynamicMethodType, 3505 jclass lambdaProxyClass)) 3506 #if INCLUDE_CDS 3507 if (!CDSConfig::is_dumping_archive() || !CDSConfig::is_dumping_lambdas_in_legacy_mode()) { 3508 return; 3509 } 3510 3511 InstanceKlass* caller_ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(caller)); 3512 if (caller_ik->is_hidden()) { 3513 // Hidden classes not of type lambda proxy classes are currently not being archived. 3514 // If the caller_ik is of one of the above types, the corresponding lambda proxy class won't be 3515 // registered for archiving. 3516 return; 3517 } 3518 InstanceKlass* lambda_ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(lambdaProxyClass)); 3519 assert(lambda_ik->is_hidden(), "must be a hidden class"); 3520 assert(!lambda_ik->is_non_strong_hidden(), "expected a strong hidden class"); 3521 3522 Symbol* interface_method_name = nullptr; 3523 if (interfaceMethodName != nullptr) { 3524 interface_method_name = java_lang_String::as_symbol(JNIHandles::resolve_non_null(interfaceMethodName)); 3525 } 3526 Handle factory_type_oop(THREAD, JNIHandles::resolve_non_null(factoryType)); 3527 Symbol* factory_type = java_lang_invoke_MethodType::as_signature(factory_type_oop(), true); 3528 3529 Handle interface_method_type_oop(THREAD, JNIHandles::resolve_non_null(interfaceMethodType)); 3530 Symbol* interface_method_type = java_lang_invoke_MethodType::as_signature(interface_method_type_oop(), true); 3531 3532 Handle implementation_member_oop(THREAD, JNIHandles::resolve_non_null(implementationMember)); 3533 assert(java_lang_invoke_MemberName::is_method(implementation_member_oop()), "must be"); 3534 Method* m = java_lang_invoke_MemberName::vmtarget(implementation_member_oop()); 3535 3536 Handle dynamic_method_type_oop(THREAD, JNIHandles::resolve_non_null(dynamicMethodType)); 3537 Symbol* dynamic_method_type = java_lang_invoke_MethodType::as_signature(dynamic_method_type_oop(), true); 3538 3539 LambdaProxyClassDictionary::add_lambda_proxy_class(caller_ik, lambda_ik, interface_method_name, factory_type, 3540 interface_method_type, m, dynamic_method_type, THREAD); 3541 #endif // INCLUDE_CDS 3542 JVM_END 3543 3544 JVM_ENTRY(jclass, JVM_LookupLambdaProxyClassFromArchive(JNIEnv* env, 3545 jclass caller, 3546 jstring interfaceMethodName, 3547 jobject factoryType, 3548 jobject interfaceMethodType, 3549 jobject implementationMember, 3550 jobject dynamicMethodType)) 3551 #if INCLUDE_CDS 3552 3553 if (interfaceMethodName == nullptr || factoryType == nullptr || interfaceMethodType == nullptr || 3554 implementationMember == nullptr || dynamicMethodType == nullptr) { 3555 THROW_(vmSymbols::java_lang_NullPointerException(), nullptr); 3556 } 3557 3558 InstanceKlass* caller_ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(caller)); 3559 if (!caller_ik->in_aot_cache()) { 3560 // there won't be a shared lambda class if the caller_ik is not in the shared archive. 3561 return nullptr; 3562 } 3563 3564 Symbol* interface_method_name = java_lang_String::as_symbol(JNIHandles::resolve_non_null(interfaceMethodName)); 3565 Handle factory_type_oop(THREAD, JNIHandles::resolve_non_null(factoryType)); 3566 Symbol* factory_type = java_lang_invoke_MethodType::as_signature(factory_type_oop(), true); 3567 3568 Handle interface_method_type_oop(THREAD, JNIHandles::resolve_non_null(interfaceMethodType)); 3569 Symbol* interface_method_type = java_lang_invoke_MethodType::as_signature(interface_method_type_oop(), true); 3570 3571 Handle implementation_member_oop(THREAD, JNIHandles::resolve_non_null(implementationMember)); 3572 assert(java_lang_invoke_MemberName::is_method(implementation_member_oop()), "must be"); 3573 Method* m = java_lang_invoke_MemberName::vmtarget(implementation_member_oop()); 3574 3575 Handle dynamic_method_type_oop(THREAD, JNIHandles::resolve_non_null(dynamicMethodType)); 3576 Symbol* dynamic_method_type = java_lang_invoke_MethodType::as_signature(dynamic_method_type_oop(), true); 3577 3578 InstanceKlass* loaded_lambda = 3579 LambdaProxyClassDictionary::load_shared_lambda_proxy_class(caller_ik, interface_method_name, factory_type, 3580 interface_method_type, m, dynamic_method_type, 3581 CHECK_(nullptr)); 3582 return loaded_lambda == nullptr ? nullptr : (jclass) JNIHandles::make_local(THREAD, loaded_lambda->java_mirror()); 3583 #else 3584 return nullptr; 3585 #endif // INCLUDE_CDS 3586 JVM_END 3587 3588 JVM_ENTRY_NO_ENV(jlong, JVM_GetRandomSeedForDumping()) 3589 if (CDSConfig::is_dumping_static_archive()) { 3590 // We do this so that the default CDS archive can be deterministic. 3591 const char* release = VM_Version::vm_release(); 3592 const char* dbg_level = VM_Version::jdk_debug_level(); 3593 const char* version = VM_Version::internal_vm_info_string(); 3594 jlong seed = (jlong)(java_lang_String::hash_code((const jbyte*)release, (int)strlen(release)) ^ 3595 java_lang_String::hash_code((const jbyte*)dbg_level, (int)strlen(dbg_level)) ^ 3596 java_lang_String::hash_code((const jbyte*)version, (int)strlen(version))); 3597 seed += (jlong)VM_Version::vm_major_version(); 3598 seed += (jlong)VM_Version::vm_minor_version(); 3599 seed += (jlong)VM_Version::vm_security_version(); 3600 seed += (jlong)VM_Version::vm_patch_version(); 3601 if (seed == 0) { // don't let this ever be zero. 3602 seed = 0x87654321; 3603 } 3604 log_debug(aot)("JVM_GetRandomSeedForDumping() = " JLONG_FORMAT, seed); 3605 return seed; 3606 } else { 3607 return 0; 3608 } 3609 JVM_END 3610 3611 JVM_ENTRY_NO_ENV(jint, JVM_GetCDSConfigStatus()) 3612 return CDSConfig::get_status(); 3613 JVM_END 3614 3615 JVM_ENTRY(void, JVM_LogLambdaFormInvoker(JNIEnv *env, jstring line)) 3616 #if INCLUDE_CDS 3617 assert(CDSConfig::is_logging_lambda_form_invokers(), "sanity"); 3618 if (line != nullptr) { 3619 ResourceMark rm(THREAD); 3620 Handle h_line (THREAD, JNIHandles::resolve_non_null(line)); 3621 char* c_line = java_lang_String::as_utf8_string(h_line()); 3622 if (CDSConfig::is_dumping_dynamic_archive()) { 3623 // Note: LambdaFormInvokers::append take same format which is not 3624 // same as below the print format. The line does not include LAMBDA_FORM_TAG. 3625 LambdaFormInvokers::append(os::strdup((const char*)c_line, mtInternal)); 3626 } 3627 if (ClassListWriter::is_enabled()) { 3628 ClassListWriter w; 3629 w.stream()->print_cr("%s %s", ClassListParser::lambda_form_tag(), c_line); 3630 } 3631 } 3632 #endif // INCLUDE_CDS 3633 JVM_END 3634 3635 JVM_ENTRY(void, JVM_DumpClassListToFile(JNIEnv *env, jstring listFileName)) 3636 #if INCLUDE_CDS 3637 ResourceMark rm(THREAD); 3638 Handle file_handle(THREAD, JNIHandles::resolve_non_null(listFileName)); 3639 char* file_name = java_lang_String::as_utf8_string(file_handle()); 3640 AOTMetaspace::dump_loaded_classes(file_name, THREAD); 3641 #endif // INCLUDE_CDS 3642 JVM_END 3643 3644 JVM_ENTRY(void, JVM_DumpDynamicArchive(JNIEnv *env, jstring archiveName)) 3645 #if INCLUDE_CDS 3646 ResourceMark rm(THREAD); 3647 Handle file_handle(THREAD, JNIHandles::resolve_non_null(archiveName)); 3648 char* archive_name = java_lang_String::as_utf8_string(file_handle()); 3649 DynamicArchive::dump_for_jcmd(archive_name, CHECK); 3650 #endif // INCLUDE_CDS 3651 JVM_END 3652 3653 JVM_ENTRY(jboolean, JVM_NeedsClassInitBarrierForCDS(JNIEnv* env, jclass cls)) 3654 #if INCLUDE_CDS 3655 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); 3656 if (!k->is_instance_klass()) { 3657 return false; 3658 } else { 3659 if (InstanceKlass::cast(k)->is_enum_subclass() || 3660 AOTClassInitializer::can_archive_initialized_mirror(InstanceKlass::cast(k))) { 3661 // This class will be cached in AOT-initialized state. No need for init barriers. 3662 return false; 3663 } else { 3664 // If we cannot cache the class in AOT-initialized state, java.lang.invoke handles 3665 // must emit barriers to ensure class initialization during production run. 3666 ResourceMark rm(THREAD); 3667 log_debug(aot)("NeedsClassInitBarrierForCDS: %s", k->external_name()); 3668 return true; 3669 } 3670 } 3671 #else 3672 return false; 3673 #endif // INCLUDE_CDS 3674 JVM_END 3675 3676 // Returns an array of all live Thread objects (VM internal JavaThreads, 3677 // jvmti agent threads, and JNI attaching threads are skipped) 3678 // See CR 6404306 regarding JNI attaching threads 3679 JVM_ENTRY(jobjectArray, JVM_GetAllThreads(JNIEnv *env, jclass dummy)) 3680 ResourceMark rm(THREAD); 3681 ThreadsListEnumerator tle(THREAD, false, false); 3682 JvmtiVMObjectAllocEventCollector oam; 3683 3684 int num_threads = tle.num_threads(); 3685 objArrayOop r = oopFactory::new_objArray(vmClasses::Thread_klass(), num_threads, CHECK_NULL); 3686 objArrayHandle threads_ah(THREAD, r); 3687 3688 for (int i = 0; i < num_threads; i++) { 3689 Handle h = tle.get_threadObj(i); 3690 threads_ah->obj_at_put(i, h()); 3691 } 3692 3693 return (jobjectArray) JNIHandles::make_local(THREAD, threads_ah()); 3694 JVM_END 3695 3696 3697 // Support for java.lang.Thread.getStackTrace() and getAllStackTraces() methods 3698 // Return StackTraceElement[][], each element is the stack trace of a thread in 3699 // the corresponding entry in the given threads array 3700 JVM_ENTRY(jobjectArray, JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)) 3701 JvmtiVMObjectAllocEventCollector oam; 3702 3703 // Check if threads is null 3704 if (threads == nullptr) { 3705 THROW_NULL(vmSymbols::java_lang_NullPointerException()); 3706 } 3707 3708 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(threads)); 3709 objArrayHandle ah(THREAD, a); 3710 int num_threads = ah->length(); 3711 // check if threads is non-empty array 3712 if (num_threads == 0) { 3713 THROW_NULL(vmSymbols::java_lang_IllegalArgumentException()); 3714 } 3715 3716 // check if threads is not an array of objects of Thread class 3717 Klass* k = ObjArrayKlass::cast(ah->klass())->element_klass(); 3718 if (k != vmClasses::Thread_klass()) { 3719 THROW_NULL(vmSymbols::java_lang_IllegalArgumentException()); 3720 } 3721 refArrayHandle rah(THREAD, (refArrayOop)ah()); // j.l.Thread is an identity class, arrays are always reference arrays 3722 3723 ResourceMark rm(THREAD); 3724 3725 GrowableArray<instanceHandle>* thread_handle_array = new GrowableArray<instanceHandle>(num_threads); 3726 for (int i = 0; i < num_threads; i++) { 3727 oop thread_obj = rah->obj_at(i); 3728 instanceHandle h(THREAD, (instanceOop) thread_obj); 3729 thread_handle_array->append(h); 3730 } 3731 3732 // The JavaThread references in thread_handle_array are validated 3733 // in VM_ThreadDump::doit(). 3734 Handle stacktraces = ThreadService::dump_stack_traces(thread_handle_array, num_threads, CHECK_NULL); 3735 return (jobjectArray)JNIHandles::make_local(THREAD, stacktraces()); 3736 3737 JVM_END 3738 3739 // JVM monitoring and management support 3740 JVM_LEAF(void*, JVM_GetManagement(jint version)) 3741 return Management::get_jmm_interface(version); 3742 JVM_END 3743 3744 // com.sun.tools.attach.VirtualMachine agent properties support 3745 // 3746 // Initialize the agent properties with the properties maintained in the VM 3747 JVM_ENTRY(jobject, JVM_InitAgentProperties(JNIEnv *env, jobject properties)) 3748 ResourceMark rm; 3749 3750 Handle props(THREAD, JNIHandles::resolve_non_null(properties)); 3751 3752 PUTPROP(props, "sun.java.command", Arguments::java_command()); 3753 PUTPROP(props, "sun.jvm.flags", Arguments::jvm_flags()); 3754 PUTPROP(props, "sun.jvm.args", Arguments::jvm_args()); 3755 return properties; 3756 JVM_END 3757 3758 JVM_ENTRY(jobjectArray, JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)) 3759 { 3760 JvmtiVMObjectAllocEventCollector oam; 3761 3762 if (ofClass == nullptr) { 3763 return nullptr; 3764 } 3765 Handle mirror(THREAD, JNIHandles::resolve_non_null(ofClass)); 3766 // Special handling for primitive objects 3767 if (java_lang_Class::is_primitive(mirror())) { 3768 return nullptr; 3769 } 3770 Klass* k = java_lang_Class::as_Klass(mirror()); 3771 if (!k->is_instance_klass()) { 3772 return nullptr; 3773 } 3774 InstanceKlass* ik = InstanceKlass::cast(k); 3775 int encl_method_class_idx = ik->enclosing_method_class_index(); 3776 if (encl_method_class_idx == 0) { 3777 return nullptr; 3778 } 3779 objArrayOop dest_o = oopFactory::new_objArray(vmClasses::Object_klass(), 3, CHECK_NULL); 3780 objArrayHandle dest(THREAD, dest_o); 3781 Klass* enc_k = ik->constants()->klass_at(encl_method_class_idx, CHECK_NULL); 3782 dest->obj_at_put(0, enc_k->java_mirror()); 3783 int encl_method_method_idx = ik->enclosing_method_method_index(); 3784 if (encl_method_method_idx != 0) { 3785 Symbol* sym = ik->constants()->symbol_at( 3786 extract_low_short_from_int( 3787 ik->constants()->name_and_type_at(encl_method_method_idx))); 3788 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 3789 dest->obj_at_put(1, str()); 3790 sym = ik->constants()->symbol_at( 3791 extract_high_short_from_int( 3792 ik->constants()->name_and_type_at(encl_method_method_idx))); 3793 str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 3794 dest->obj_at_put(2, str()); 3795 } 3796 return (jobjectArray) JNIHandles::make_local(THREAD, dest()); 3797 } 3798 JVM_END 3799 3800 // Returns an array of java.lang.String objects containing the input arguments to the VM. 3801 JVM_ENTRY(jobjectArray, JVM_GetVmArguments(JNIEnv *env)) 3802 ResourceMark rm(THREAD); 3803 3804 if (Arguments::num_jvm_args() == 0 && Arguments::num_jvm_flags() == 0) { 3805 return nullptr; 3806 } 3807 3808 char** vm_flags = Arguments::jvm_flags_array(); 3809 char** vm_args = Arguments::jvm_args_array(); 3810 int num_flags = Arguments::num_jvm_flags(); 3811 int num_args = Arguments::num_jvm_args(); 3812 3813 InstanceKlass* ik = vmClasses::String_klass(); 3814 objArrayOop r = oopFactory::new_objArray(ik, num_args + num_flags, CHECK_NULL); 3815 objArrayHandle result_h(THREAD, r); 3816 3817 int index = 0; 3818 for (int j = 0; j < num_flags; j++, index++) { 3819 Handle h = java_lang_String::create_from_platform_dependent_str(vm_flags[j], CHECK_NULL); 3820 result_h->obj_at_put(index, h()); 3821 } 3822 for (int i = 0; i < num_args; i++, index++) { 3823 Handle h = java_lang_String::create_from_platform_dependent_str(vm_args[i], CHECK_NULL); 3824 result_h->obj_at_put(index, h()); 3825 } 3826 return (jobjectArray) JNIHandles::make_local(THREAD, result_h()); 3827 JVM_END 3828 3829 JVM_LEAF(jint, JVM_FindSignal(const char *name)) 3830 return os::get_signal_number(name); 3831 JVM_END 3832 3833 JVM_ENTRY(void, JVM_VirtualThreadStart(JNIEnv* env, jobject vthread)) 3834 #if INCLUDE_JVMTI 3835 if (!DoJVMTIVirtualThreadTransitions) { 3836 assert(!JvmtiExport::can_support_virtual_threads(), "sanity check"); 3837 return; 3838 } 3839 if (JvmtiVTMSTransitionDisabler::VTMS_notify_jvmti_events()) { 3840 JvmtiVTMSTransitionDisabler::VTMS_vthread_start(vthread); 3841 } else { 3842 // set VTMS transition bit value in JavaThread and java.lang.VirtualThread object 3843 JvmtiVTMSTransitionDisabler::set_is_in_VTMS_transition(thread, vthread, false); 3844 } 3845 #endif 3846 JVM_END 3847 3848 JVM_ENTRY(void, JVM_VirtualThreadEnd(JNIEnv* env, jobject vthread)) 3849 #if INCLUDE_JVMTI 3850 if (!DoJVMTIVirtualThreadTransitions) { 3851 assert(!JvmtiExport::can_support_virtual_threads(), "sanity check"); 3852 return; 3853 } 3854 if (JvmtiVTMSTransitionDisabler::VTMS_notify_jvmti_events()) { 3855 JvmtiVTMSTransitionDisabler::VTMS_vthread_end(vthread); 3856 } else { 3857 // set VTMS transition bit value in JavaThread and java.lang.VirtualThread object 3858 JvmtiVTMSTransitionDisabler::set_is_in_VTMS_transition(thread, vthread, true); 3859 } 3860 #endif 3861 JVM_END 3862 3863 // If notifications are disabled then just update the VTMS transition bit and return. 3864 // Otherwise, the bit is updated in the given jvmtiVTMSTransitionDisabler function call. 3865 JVM_ENTRY(void, JVM_VirtualThreadMount(JNIEnv* env, jobject vthread, jboolean hide)) 3866 #if INCLUDE_JVMTI 3867 if (!DoJVMTIVirtualThreadTransitions) { 3868 assert(!JvmtiExport::can_support_virtual_threads(), "sanity check"); 3869 return; 3870 } 3871 if (JvmtiVTMSTransitionDisabler::VTMS_notify_jvmti_events()) { 3872 JvmtiVTMSTransitionDisabler::VTMS_vthread_mount(vthread, hide); 3873 } else { 3874 // set VTMS transition bit value in JavaThread and java.lang.VirtualThread object 3875 JvmtiVTMSTransitionDisabler::set_is_in_VTMS_transition(thread, vthread, hide); 3876 } 3877 #endif 3878 JVM_END 3879 3880 // If notifications are disabled then just update the VTMS transition bit and return. 3881 // Otherwise, the bit is updated in the given jvmtiVTMSTransitionDisabler function call below. 3882 JVM_ENTRY(void, JVM_VirtualThreadUnmount(JNIEnv* env, jobject vthread, jboolean hide)) 3883 #if INCLUDE_JVMTI 3884 if (!DoJVMTIVirtualThreadTransitions) { 3885 assert(!JvmtiExport::can_support_virtual_threads(), "sanity check"); 3886 return; 3887 } 3888 if (JvmtiVTMSTransitionDisabler::VTMS_notify_jvmti_events()) { 3889 JvmtiVTMSTransitionDisabler::VTMS_vthread_unmount(vthread, hide); 3890 } else { 3891 // set VTMS transition bit value in JavaThread and java.lang.VirtualThread object 3892 JvmtiVTMSTransitionDisabler::set_is_in_VTMS_transition(thread, vthread, hide); 3893 } 3894 #endif 3895 JVM_END 3896 3897 // Notification from VirtualThread about disabling JVMTI Suspend in a sync critical section. 3898 // Needed to avoid deadlocks with JVMTI suspend mechanism. 3899 JVM_ENTRY(void, JVM_VirtualThreadDisableSuspend(JNIEnv* env, jclass clazz, jboolean enter)) 3900 #if INCLUDE_JVMTI 3901 if (!DoJVMTIVirtualThreadTransitions) { 3902 assert(!JvmtiExport::can_support_virtual_threads(), "sanity check"); 3903 return; 3904 } 3905 assert(thread->is_disable_suspend() != (bool)enter, 3906 "nested or unbalanced monitor enter/exit is not allowed"); 3907 thread->toggle_is_disable_suspend(); 3908 #endif 3909 JVM_END 3910 3911 JVM_ENTRY(void, JVM_VirtualThreadPinnedEvent(JNIEnv* env, jclass ignored, jstring op)) 3912 #if INCLUDE_JFR 3913 freeze_result result = THREAD->last_freeze_fail_result(); 3914 assert(result != freeze_ok, "sanity check"); 3915 EventVirtualThreadPinned event(UNTIMED); 3916 event.set_starttime(THREAD->last_freeze_fail_time()); 3917 if (event.should_commit()) { 3918 ResourceMark rm(THREAD); 3919 const char *str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(op)); 3920 THREAD->post_vthread_pinned_event(&event, str, result); 3921 } 3922 #endif 3923 JVM_END 3924 3925 JVM_ENTRY(jobject, JVM_TakeVirtualThreadListToUnblock(JNIEnv* env, jclass ignored)) 3926 ParkEvent* parkEvent = ObjectMonitor::vthread_unparker_ParkEvent(); 3927 assert(parkEvent != nullptr, "not initialized"); 3928 3929 OopHandle& list_head = ObjectMonitor::vthread_list_head(); 3930 oop vthread_head = nullptr; 3931 while (true) { 3932 if (list_head.peek() != nullptr) { 3933 for (;;) { 3934 oop head = list_head.resolve(); 3935 if (list_head.cmpxchg(head, nullptr) == head) { 3936 return JNIHandles::make_local(THREAD, head); 3937 } 3938 } 3939 } 3940 ThreadBlockInVM tbivm(THREAD); 3941 parkEvent->park(); 3942 } 3943 JVM_END 3944 /* 3945 * Return the current class's class file version. The low order 16 bits of the 3946 * returned jint contain the class's major version. The high order 16 bits 3947 * contain the class's minor version. 3948 */ 3949 JVM_ENTRY(jint, JVM_GetClassFileVersion(JNIEnv* env, jclass current)) 3950 oop mirror = JNIHandles::resolve_non_null(current); 3951 if (java_lang_Class::is_primitive(mirror)) { 3952 // return latest major version and minor version of 0. 3953 return JVM_CLASSFILE_MAJOR_VERSION; 3954 } 3955 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror); 3956 return (ik->minor_version() << 16) | ik->major_version(); 3957 JVM_END 3958 3959 /* 3960 * Ensure that code doing a stackwalk and using javaVFrame::locals() to 3961 * get the value will see a materialized value and not a scalar-replaced 3962 * null value. 3963 */ 3964 JVM_ENTRY(void, JVM_EnsureMaterializedForStackWalk_func(JNIEnv* env, jobject vthread, jobject value)) 3965 JVM_EnsureMaterializedForStackWalk(env, value); 3966 JVM_END 3967 3968 /* 3969 * Return JNI_TRUE if warnings are printed when agents are dynamically loaded. 3970 */ 3971 JVM_LEAF(jboolean, JVM_PrintWarningAtDynamicAgentLoad(void)) 3972 return (EnableDynamicAgentLoading && !FLAG_IS_CMDLINE(EnableDynamicAgentLoading)) ? JNI_TRUE : JNI_FALSE; 3973 JVM_END --- EOF ---