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