1 /* 2 * Copyright (c) 2012, 2025, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "cds.h" 26 #include "cds/aotMetaspace.hpp" 27 #include "cds/archiveHeapLoader.hpp" 28 #include "cds/cdsConstants.hpp" 29 #include "cds/filemap.hpp" 30 #include "cds/heapShared.hpp" 31 #include "classfile/classLoader.hpp" 32 #include "classfile/classLoaderDataGraph.hpp" 33 #include "classfile/classLoaderStats.hpp" 34 #include "classfile/classPrinter.hpp" 35 #include "classfile/javaClasses.inline.hpp" 36 #include "classfile/modules.hpp" 37 #include "classfile/stringTable.hpp" 38 #include "classfile/symbolTable.hpp" 39 #include "classfile/systemDictionary.hpp" 40 #include "classfile/vmSymbols.hpp" 41 #include "code/codeCache.hpp" 42 #include "compiler/compilationPolicy.hpp" 43 #include "compiler/compilerOracle.hpp" 44 #include "compiler/directivesParser.hpp" 45 #include "compiler/methodMatcher.hpp" 46 #include "gc/shared/concurrentGCBreakpoints.hpp" 47 #include "gc/shared/gcConfig.hpp" 48 #include "gc/shared/genArguments.hpp" 49 #include "jfr/periodic/sampling/jfrCPUTimeThreadSampler.hpp" 50 #include "jvm.h" 51 #include "jvmtifiles/jvmtiEnv.hpp" 52 #include "logging/log.hpp" 53 #include "memory/iterator.hpp" 54 #include "memory/memoryReserver.hpp" 55 #include "memory/metadataFactory.hpp" 56 #include "memory/metaspace/testHelpers.hpp" 57 #include "memory/metaspaceUtils.hpp" 58 #include "memory/oopFactory.hpp" 59 #include "memory/resourceArea.hpp" 60 #include "memory/universe.hpp" 61 #include "nmt/mallocSiteTable.hpp" 62 #include "oops/array.hpp" 63 #include "oops/compressedOops.hpp" 64 #include "oops/constantPool.inline.hpp" 65 #include "oops/klass.inline.hpp" 66 #include "oops/method.inline.hpp" 67 #include "oops/methodData.inline.hpp" 68 #include "oops/objArrayKlass.hpp" 69 #include "oops/objArrayOop.inline.hpp" 70 #include "oops/oop.inline.hpp" 71 #include "oops/typeArrayOop.inline.hpp" 72 #include "prims/jvmtiEnvBase.hpp" 73 #include "prims/resolvedMethodTable.hpp" 74 #include "prims/wbtestmethods/parserTests.hpp" 75 #include "prims/whitebox.inline.hpp" 76 #include "runtime/arguments.hpp" 77 #include "runtime/atomicAccess.hpp" 78 #include "runtime/deoptimization.hpp" 79 #include "runtime/fieldDescriptor.inline.hpp" 80 #include "runtime/flags/jvmFlag.hpp" 81 #include "runtime/flags/jvmFlagAccess.hpp" 82 #include "runtime/frame.inline.hpp" 83 #include "runtime/handles.inline.hpp" 84 #include "runtime/handshake.hpp" 85 #include "runtime/interfaceSupport.inline.hpp" 86 #include "runtime/javaCalls.hpp" 87 #include "runtime/javaThread.inline.hpp" 88 #include "runtime/jniHandles.inline.hpp" 89 #include "runtime/lightweightSynchronizer.hpp" 90 #include "runtime/lockStack.hpp" 91 #include "runtime/os.hpp" 92 #include "runtime/stackFrameStream.inline.hpp" 93 #include "runtime/synchronizer.hpp" 94 #include "runtime/threadSMR.hpp" 95 #include "runtime/vframe.hpp" 96 #include "runtime/vm_version.hpp" 97 #include "services/memoryService.hpp" 98 #include "utilities/align.hpp" 99 #include "utilities/checkedCast.hpp" 100 #include "utilities/debug.hpp" 101 #include "utilities/elfFile.hpp" 102 #include "utilities/exceptions.hpp" 103 #include "utilities/macros.hpp" 104 #include "utilities/nativeCallStack.hpp" 105 #include "utilities/ostream.hpp" 106 #include "utilities/vmError.hpp" 107 #if INCLUDE_G1GC 108 #include "gc/g1/g1Arguments.hpp" 109 #include "gc/g1/g1CollectedHeap.inline.hpp" 110 #include "gc/g1/g1ConcurrentMark.hpp" 111 #include "gc/g1/g1ConcurrentMarkThread.inline.hpp" 112 #include "gc/g1/g1HeapRegionManager.hpp" 113 #include "gc/g1/g1HeapRegionRemSet.inline.hpp" 114 #endif // INCLUDE_G1GC 115 #if INCLUDE_PARALLELGC 116 #include "gc/parallel/parallelScavengeHeap.inline.hpp" 117 #endif // INCLUDE_PARALLELGC 118 #if INCLUDE_SERIALGC 119 #include "gc/serial/serialHeap.hpp" 120 #endif // INCLUDE_SERIALGC 121 #if INCLUDE_ZGC 122 #include "gc/z/zAddress.inline.hpp" 123 #endif // INCLUDE_ZGC 124 #if INCLUDE_JVMCI 125 #include "jvmci/jvmciEnv.hpp" 126 #include "jvmci/jvmciRuntime.hpp" 127 #endif 128 #ifdef LINUX 129 #include "cgroupSubsystem_linux.hpp" 130 #include "os_linux.hpp" 131 #include "osContainer_linux.hpp" 132 #endif 133 134 #define CHECK_JNI_EXCEPTION_(env, value) \ 135 do { \ 136 JavaThread* THREAD = JavaThread::thread_from_jni_environment(env); \ 137 THREAD->clear_pending_jni_exception_check(); \ 138 if (HAS_PENDING_EXCEPTION) { \ 139 return(value); \ 140 } \ 141 } while (0) 142 143 #define CHECK_JNI_EXCEPTION(env) \ 144 do { \ 145 JavaThread* THREAD = JavaThread::thread_from_jni_environment(env); \ 146 THREAD->clear_pending_jni_exception_check(); \ 147 if (HAS_PENDING_EXCEPTION) { \ 148 return; \ 149 } \ 150 } while (0) 151 152 bool WhiteBox::_used = false; 153 volatile bool WhiteBox::compilation_locked = false; 154 155 class VM_WhiteBoxOperation : public VM_Operation { 156 public: 157 VM_WhiteBoxOperation() { } 158 VMOp_Type type() const { return VMOp_WhiteBoxOperation; } 159 bool allow_nested_vm_operations() const { return true; } 160 }; 161 162 163 WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj)) 164 return (jlong)(void*)JNIHandles::resolve(obj); 165 WB_END 166 167 WB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o)) 168 return heapOopSize; 169 WB_END 170 171 WB_ENTRY(jint, WB_GetVMPageSize(JNIEnv* env, jobject o)) 172 return (jint)os::vm_page_size(); 173 WB_END 174 175 WB_ENTRY(jlong, WB_GetVMAllocationGranularity(JNIEnv* env, jobject o)) 176 return os::vm_allocation_granularity(); 177 WB_END 178 179 WB_ENTRY(jlong, WB_GetVMLargePageSize(JNIEnv* env, jobject o)) 180 return os::large_page_size(); 181 WB_END 182 183 WB_ENTRY(jstring, WB_PrintString(JNIEnv* env, jobject wb, jstring str, jint max_length)) 184 ResourceMark rm(THREAD); 185 stringStream sb; 186 java_lang_String::print(JNIHandles::resolve(str), &sb, max_length); 187 oop result = java_lang_String::create_oop_from_str(sb.as_string(), THREAD); 188 return (jstring) JNIHandles::make_local(THREAD, result); 189 WB_END 190 191 WB_ENTRY(jint, WB_TakeLockAndHangInSafepoint(JNIEnv* env, jobject wb)) 192 JavaThread* self = JavaThread::current(); 193 // VMStatistic_lock is used to minimize interference with VM locking 194 MutexLocker mu(VMStatistic_lock); 195 VM_HangInSafepoint force_safepoint_stuck_op; 196 VMThread::execute(&force_safepoint_stuck_op); 197 ShouldNotReachHere(); 198 return 0; 199 WB_END 200 201 class WBIsKlassAliveClosure : public LockedClassesDo { 202 Symbol* _name; 203 int _count; 204 public: 205 WBIsKlassAliveClosure(Symbol* name) : _name(name), _count(0) {} 206 207 void do_klass(Klass* k) { 208 Symbol* ksym = k->name(); 209 if (ksym->fast_compare(_name) == 0) { 210 _count++; 211 } else if (k->is_instance_klass()) { 212 // Need special handling for hidden classes because the JVM 213 // appends "+<hex-address>" to hidden class names. 214 InstanceKlass *ik = InstanceKlass::cast(k); 215 if (ik->is_hidden()) { 216 ResourceMark rm; 217 char* k_name = ksym->as_C_string(); 218 // Find the first '+' char and truncate the string at that point. 219 // NOTE: This will not work correctly if the original hidden class 220 // name contains a '+'. 221 char* plus_char = strchr(k_name, '+'); 222 if (plus_char != nullptr) { 223 *plus_char = 0; 224 char* c_name = _name->as_C_string(); 225 if (strcmp(c_name, k_name) == 0) { 226 _count++; 227 } 228 } 229 } 230 } 231 } 232 233 int count() const { 234 return _count; 235 } 236 }; 237 238 WB_ENTRY(jint, WB_CountAliveClasses(JNIEnv* env, jobject target, jstring name)) 239 oop h_name = JNIHandles::resolve(name); 240 if (h_name == nullptr) { 241 return 0; 242 } 243 Symbol* sym = java_lang_String::as_symbol(h_name); 244 TempNewSymbol tsym(sym); // Make sure to decrement reference count on sym on return 245 246 WBIsKlassAliveClosure closure(sym); 247 ClassLoaderDataGraph::classes_do(&closure); 248 249 // Return the count of alive classes with this name. 250 return closure.count(); 251 WB_END 252 253 WB_ENTRY(jint, WB_GetSymbolRefcount(JNIEnv* env, jobject unused, jstring name)) 254 oop h_name = JNIHandles::resolve(name); 255 if (h_name == nullptr) { 256 return 0; 257 } 258 Symbol* sym = java_lang_String::as_symbol(h_name); 259 TempNewSymbol tsym(sym); // Make sure to decrement reference count on sym on return 260 return (jint)sym->refcount(); 261 WB_END 262 263 264 WB_ENTRY(void, WB_AddToBootstrapClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) { 265 #if INCLUDE_JVMTI 266 ResourceMark rm; 267 const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment)); 268 JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION); 269 jvmtiError err = jvmti_env->AddToBootstrapClassLoaderSearch(seg); 270 assert(err == JVMTI_ERROR_NONE, "must not fail"); 271 #endif 272 } 273 WB_END 274 275 WB_ENTRY(void, WB_AddToSystemClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) { 276 #if INCLUDE_JVMTI 277 ResourceMark rm; 278 const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment)); 279 JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION); 280 jvmtiError err = jvmti_env->AddToSystemClassLoaderSearch(seg); 281 assert(err == JVMTI_ERROR_NONE, "must not fail"); 282 #endif 283 } 284 WB_END 285 286 287 WB_ENTRY(jlong, WB_GetCompressedOopsMaxHeapSize(JNIEnv* env, jobject o)) { 288 return (jlong)Arguments::max_heap_for_compressed_oops(); 289 } 290 WB_END 291 292 WB_ENTRY(void, WB_PrintHeapSizes(JNIEnv* env, jobject o)) { 293 tty->print_cr("Minimum heap %zu Initial heap %zu " 294 "Maximum heap %zu Space alignment %zu Heap alignment %zu", 295 MinHeapSize, 296 InitialHeapSize, 297 MaxHeapSize, 298 SpaceAlignment, 299 HeapAlignment); 300 } 301 WB_END 302 303 WB_ENTRY(void, WB_ReadFromNoaccessArea(JNIEnv* env, jobject o)) 304 size_t granularity = os::vm_allocation_granularity(); 305 ReservedHeapSpace rhs = HeapReserver::reserve(100 * granularity, granularity, os::vm_page_size(), nullptr); 306 307 // Check if constraints are complied 308 if (!( UseCompressedOops && rhs.is_reserved() && 309 CompressedOops::base() != nullptr && 310 CompressedOops::use_implicit_null_checks() )) { 311 tty->print_cr("WB_ReadFromNoaccessArea method is useless:\n " 312 "\tUseCompressedOops is %d\n" 313 "\trhs.base() is " PTR_FORMAT "\n" 314 "\tCompressedOops::base() is " PTR_FORMAT "\n" 315 "\tCompressedOops::use_implicit_null_checks() is %d", 316 UseCompressedOops, 317 p2i(rhs.base()), 318 p2i(CompressedOops::base()), 319 CompressedOops::use_implicit_null_checks()); 320 return; 321 } 322 323 VirtualSpace vs; 324 vs.initialize(rhs, 50 * granularity); 325 326 tty->print_cr("Reading from no access area... "); 327 tty->print_cr("*(vs.low_boundary() - rhs.noaccess_prefix() / 2 ) = %c", 328 *(vs.low_boundary() - rhs.noaccess_prefix() / 2 )); 329 WB_END 330 331 WB_ENTRY(void, WB_DecodeNKlassAndAccessKlass(JNIEnv* env, jobject o, jint nKlass)) 332 assert(UseCompressedClassPointers, "Should only call for UseCompressedClassPointers"); 333 const narrowKlass nk = (narrowKlass)nKlass; 334 const Klass* const k = CompressedKlassPointers::decode_not_null_without_asserts(nKlass); 335 printf("WB_DecodeNKlassAndAccessKlass: nk %u k " PTR_FORMAT "\n", nk, p2i(k)); 336 printf("Will attempt to crash now...\n"); 337 fflush(stdout); // flush now - we will crash below 338 // Access k by calling a virtual function - will result in loading the vtable from *k 339 k->print_on(tty); 340 WB_END 341 342 static jint wb_stress_virtual_space_resize(size_t reserved_space_size, 343 size_t magnitude, size_t iterations) { 344 size_t granularity = os::vm_allocation_granularity(); 345 ReservedHeapSpace rhs = HeapReserver::reserve(reserved_space_size * granularity, granularity, os::vm_page_size(), nullptr); 346 if (!rhs.is_reserved()) { 347 tty->print_cr("Failed to initialize ReservedSpace. Can't proceed."); 348 return 3; 349 } 350 351 VirtualSpace vs; 352 if (!vs.initialize(rhs, 0)) { 353 tty->print_cr("Failed to initialize VirtualSpace. Can't proceed."); 354 return 3; 355 } 356 357 int seed = os::random(); 358 tty->print_cr("Random seed is %d", seed); 359 360 for (size_t i = 0; i < iterations; i++) { 361 362 // Whether we will shrink or grow 363 bool shrink = os::random() % 2L == 0; 364 365 // Get random delta to resize virtual space 366 size_t delta = (size_t)os::random() % magnitude; 367 368 // If we are about to shrink virtual space below zero, then expand instead 369 if (shrink && vs.committed_size() < delta) { 370 shrink = false; 371 } 372 373 // Resizing by delta 374 if (shrink) { 375 vs.shrink_by(delta); 376 } else { 377 // If expanding fails expand_by will silently return false 378 vs.expand_by(delta, true); 379 } 380 } 381 return 0; 382 } 383 384 WB_ENTRY(jint, WB_StressVirtualSpaceResize(JNIEnv* env, jobject o, 385 jlong reserved_space_size, jlong magnitude, jlong iterations)) 386 tty->print_cr("reservedSpaceSize=" JLONG_FORMAT ", magnitude=" JLONG_FORMAT ", " 387 "iterations=" JLONG_FORMAT "\n", reserved_space_size, magnitude, 388 iterations); 389 if (reserved_space_size < 0 || magnitude < 0 || iterations < 0) { 390 tty->print_cr("One of variables printed above is negative. Can't proceed.\n"); 391 return 1; 392 } 393 394 // sizeof(size_t) depends on whether OS is 32bit or 64bit. sizeof(jlong) is 395 // always 8 byte. That's why we should avoid overflow in case of 32bit platform. 396 if (sizeof(size_t) < sizeof(jlong)) { 397 jlong size_t_max_value = (jlong)SIZE_MAX; 398 if (reserved_space_size > size_t_max_value || magnitude > size_t_max_value 399 || iterations > size_t_max_value) { 400 tty->print_cr("One of variables printed above overflows size_t. Can't proceed.\n"); 401 return 2; 402 } 403 } 404 405 return wb_stress_virtual_space_resize((size_t) reserved_space_size, 406 (size_t) magnitude, (size_t) iterations); 407 WB_END 408 409 WB_ENTRY(jboolean, WB_IsGCSupported(JNIEnv* env, jobject o, jint name)) 410 return GCConfig::is_gc_supported((CollectedHeap::Name)name); 411 WB_END 412 413 WB_ENTRY(jboolean, WB_HasLibgraal(JNIEnv* env, jobject o)) 414 #if INCLUDE_JVMCI 415 return JVMCI::shared_library_exists(); 416 #endif 417 return false; 418 WB_END 419 420 WB_ENTRY(jboolean, WB_IsGCSupportedByJVMCICompiler(JNIEnv* env, jobject o, jint name)) 421 #if INCLUDE_JVMCI 422 if (EnableJVMCI) { 423 // Enter the JVMCI env that will be used by the CompileBroker. 424 JVMCIEnv jvmciEnv(thread, __FILE__, __LINE__); 425 return jvmciEnv.init_error() == JNI_OK && jvmciEnv.runtime()->is_gc_supported(&jvmciEnv, (CollectedHeap::Name)name); 426 } 427 #endif 428 return false; 429 WB_END 430 431 WB_ENTRY(jboolean, WB_IsGCSelected(JNIEnv* env, jobject o, jint name)) 432 return GCConfig::is_gc_selected((CollectedHeap::Name)name); 433 WB_END 434 435 WB_ENTRY(jboolean, WB_IsGCSelectedErgonomically(JNIEnv* env, jobject o)) 436 return GCConfig::is_gc_selected_ergonomically(); 437 WB_END 438 439 WB_ENTRY(jboolean, WB_isObjectInOldGen(JNIEnv* env, jobject o, jobject obj)) 440 oop p = JNIHandles::resolve(obj); 441 #if INCLUDE_G1GC 442 if (UseG1GC) { 443 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 444 const G1HeapRegion* hr = g1h->heap_region_containing(p); 445 return hr->is_old_or_humongous(); 446 } 447 #endif 448 #if INCLUDE_PARALLELGC 449 if (UseParallelGC) { 450 ParallelScavengeHeap* psh = ParallelScavengeHeap::heap(); 451 return !psh->is_in_young(p); 452 } 453 #endif 454 #if INCLUDE_ZGC 455 if (UseZGC) { 456 return ZHeap::heap()->is_old(to_zaddress(p)); 457 } 458 #endif 459 #if INCLUDE_SHENANDOAHGC 460 if (UseShenandoahGC) { 461 ShenandoahHeap* sh = ShenandoahHeap::heap(); 462 return sh->mode()->is_generational() ? sh->is_in_old(p) : sh->is_in(p); 463 } 464 #endif 465 #if INCLUDE_SERIALGC 466 if (UseSerialGC) { 467 return !SerialHeap::heap()->is_in_young(p); 468 } 469 #endif 470 ShouldNotReachHere(); 471 return false; 472 WB_END 473 474 WB_ENTRY(jlong, WB_GetObjectSize(JNIEnv* env, jobject o, jobject obj)) 475 oop p = JNIHandles::resolve(obj); 476 return p->size() * HeapWordSize; 477 WB_END 478 479 WB_ENTRY(jlong, WB_GetHeapSpaceAlignment(JNIEnv* env, jobject o)) 480 return (jlong)SpaceAlignment; 481 WB_END 482 483 WB_ENTRY(jlong, WB_GetHeapAlignment(JNIEnv* env, jobject o)) 484 return (jlong)HeapAlignment; 485 WB_END 486 487 WB_ENTRY(jboolean, WB_SupportsConcurrentGCBreakpoints(JNIEnv* env, jobject o)) 488 return Universe::heap()->supports_concurrent_gc_breakpoints(); 489 WB_END 490 491 WB_ENTRY(void, WB_ConcurrentGCAcquireControl(JNIEnv* env, jobject o)) 492 ConcurrentGCBreakpoints::acquire_control(); 493 WB_END 494 495 WB_ENTRY(void, WB_ConcurrentGCReleaseControl(JNIEnv* env, jobject o)) 496 ConcurrentGCBreakpoints::release_control(); 497 WB_END 498 499 WB_ENTRY(void, WB_ConcurrentGCRunToIdle(JNIEnv* env, jobject o)) 500 ConcurrentGCBreakpoints::run_to_idle(); 501 WB_END 502 503 WB_ENTRY(jboolean, WB_ConcurrentGCRunTo(JNIEnv* env, jobject o, jobject at)) 504 Handle h_name(THREAD, JNIHandles::resolve(at)); 505 ResourceMark rm; 506 const char* c_name = java_lang_String::as_utf8_string(h_name()); 507 return ConcurrentGCBreakpoints::run_to(c_name); 508 WB_END 509 510 #if INCLUDE_G1GC 511 512 WB_ENTRY(jboolean, WB_G1IsHumongous(JNIEnv* env, jobject o, jobject obj)) 513 if (UseG1GC) { 514 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 515 oop result = JNIHandles::resolve(obj); 516 const G1HeapRegion* hr = g1h->heap_region_containing(result); 517 return hr->is_humongous(); 518 } 519 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1IsHumongous: G1 GC is not enabled"); 520 WB_END 521 522 WB_ENTRY(jboolean, WB_G1BelongsToHumongousRegion(JNIEnv* env, jobject o, jlong addr)) 523 if (UseG1GC) { 524 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 525 const G1HeapRegion* hr = g1h->heap_region_containing((void*) addr); 526 return hr->is_humongous(); 527 } 528 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1BelongsToHumongousRegion: G1 GC is not enabled"); 529 WB_END 530 531 WB_ENTRY(jboolean, WB_G1BelongsToFreeRegion(JNIEnv* env, jobject o, jlong addr)) 532 if (UseG1GC) { 533 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 534 const G1HeapRegion* hr = g1h->heap_region_containing((void*) addr); 535 return hr->is_free(); 536 } 537 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1BelongsToFreeRegion: G1 GC is not enabled"); 538 WB_END 539 540 WB_ENTRY(jlong, WB_G1NumMaxRegions(JNIEnv* env, jobject o)) 541 if (UseG1GC) { 542 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 543 size_t nr = g1h->max_num_regions(); 544 return (jlong)nr; 545 } 546 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1NumMaxRegions: G1 GC is not enabled"); 547 WB_END 548 549 WB_ENTRY(jlong, WB_G1NumFreeRegions(JNIEnv* env, jobject o)) 550 if (UseG1GC) { 551 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 552 size_t nr = g1h->num_free_regions(); 553 return (jlong)nr; 554 } 555 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1NumFreeRegions: G1 GC is not enabled"); 556 WB_END 557 558 WB_ENTRY(jboolean, WB_G1InConcurrentMark(JNIEnv* env, jobject o)) 559 if (UseG1GC) { 560 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 561 return g1h->concurrent_mark()->cm_thread()->in_progress(); 562 } 563 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1InConcurrentMark: G1 GC is not enabled"); 564 WB_END 565 566 WB_ENTRY(jint, WB_G1CompletedConcurrentMarkCycles(JNIEnv* env, jobject o)) 567 if (UseG1GC) { 568 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 569 G1ConcurrentMark* cm = g1h->concurrent_mark(); 570 return cm->completed_mark_cycles(); 571 } 572 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1CompletedConcurrentMarkCycles: G1 GC is not enabled"); 573 WB_END 574 575 WB_ENTRY(jint, WB_G1RegionSize(JNIEnv* env, jobject o)) 576 if (UseG1GC) { 577 return (jint)G1HeapRegion::GrainBytes; 578 } 579 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1RegionSize: G1 GC is not enabled"); 580 WB_END 581 582 WB_ENTRY(jboolean, WB_G1HasRegionsToUncommit(JNIEnv* env, jobject o)) 583 if (UseG1GC) { 584 return G1CollectedHeap::heap()->has_uncommittable_regions(); 585 } 586 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1HasRegionsToUncommit: G1 GC is not enabled"); 587 WB_END 588 589 WB_ENTRY(jobject, WB_G1AuxiliaryMemoryUsage(JNIEnv* env)) 590 if (UseG1GC) { 591 ResourceMark rm(THREAD); 592 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 593 MemoryUsage usage = g1h->get_auxiliary_data_memory_usage(); 594 Handle h = MemoryService::create_MemoryUsage_obj(usage, CHECK_NULL); 595 return JNIHandles::make_local(THREAD, h()); 596 } 597 THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1AuxiliaryMemoryUsage: G1 GC is not enabled"); 598 WB_END 599 600 WB_ENTRY(jint, WB_G1ActiveMemoryNodeCount(JNIEnv* env, jobject o)) 601 if (UseG1GC) { 602 G1NUMA* numa = G1NUMA::numa(); 603 return (jint)numa->num_active_nodes(); 604 } 605 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1ActiveMemoryNodeCount: G1 GC is not enabled"); 606 WB_END 607 608 WB_ENTRY(jintArray, WB_G1MemoryNodeIds(JNIEnv* env, jobject o)) 609 if (UseG1GC) { 610 G1NUMA* numa = G1NUMA::numa(); 611 int num_node_ids = checked_cast<int>(numa->num_active_nodes()); 612 const uint* node_ids = numa->node_ids(); 613 614 typeArrayOop result = oopFactory::new_intArray(num_node_ids, CHECK_NULL); 615 for (int i = 0; i < num_node_ids; i++) { 616 result->int_at_put(i, checked_cast<jint>(node_ids[i])); 617 } 618 return (jintArray) JNIHandles::make_local(THREAD, result); 619 } 620 THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1MemoryNodeIds: G1 GC is not enabled"); 621 WB_END 622 623 class OldRegionsLivenessClosure: public G1HeapRegionClosure { 624 625 private: 626 const int _liveness; 627 size_t _total_count; 628 size_t _total_memory; 629 size_t _total_memory_to_free; 630 631 public: 632 OldRegionsLivenessClosure(int liveness) : 633 _liveness(liveness), 634 _total_count(0), 635 _total_memory(0), 636 _total_memory_to_free(0) { } 637 638 size_t total_count() { return _total_count; } 639 size_t total_memory() { return _total_memory; } 640 size_t total_memory_to_free() { return _total_memory_to_free; } 641 642 bool do_heap_region(G1HeapRegion* r) { 643 if (r->is_old()) { 644 size_t live = r->live_bytes(); 645 size_t size = r->used(); 646 size_t reg_size = G1HeapRegion::GrainBytes; 647 if (size > 0 && ((int)(live * 100 / size) < _liveness)) { 648 _total_memory += size; 649 ++_total_count; 650 if (size == reg_size) { 651 // We don't include non-full regions since they are unlikely included in mixed gc 652 // for testing purposes it's enough to have lowest estimation of total memory that is expected to be freed 653 _total_memory_to_free += size - live; 654 } 655 } 656 } 657 return false; 658 } 659 }; 660 661 662 WB_ENTRY(jlongArray, WB_G1GetMixedGCInfo(JNIEnv* env, jobject o, jint liveness)) 663 if (!UseG1GC) { 664 THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1GetMixedGCInfo: G1 GC is not enabled"); 665 } 666 if (liveness < 0) { 667 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "liveness value should be non-negative"); 668 } 669 670 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 671 OldRegionsLivenessClosure rli(liveness); 672 g1h->heap_region_iterate(&rli); 673 674 typeArrayOop result = oopFactory::new_longArray(3, CHECK_NULL); 675 result->long_at_put(0, rli.total_count()); 676 result->long_at_put(1, rli.total_memory()); 677 result->long_at_put(2, rli.total_memory_to_free()); 678 return (jlongArray) JNIHandles::make_local(THREAD, result); 679 WB_END 680 681 #endif // INCLUDE_G1GC 682 683 // Alloc memory using the test memory tag so that we can use that to see if 684 // NMT picks it up correctly 685 WB_ENTRY(jlong, WB_NMTMalloc(JNIEnv* env, jobject o, jlong size)) 686 jlong addr = 0; 687 addr = (jlong)(uintptr_t)os::malloc(size, mtTest); 688 return addr; 689 WB_END 690 691 // Alloc memory with pseudo call stack. The test can create pseudo malloc 692 // allocation site to stress the malloc tracking. 693 WB_ENTRY(jlong, WB_NMTMallocWithPseudoStack(JNIEnv* env, jobject o, jlong size, jint pseudo_stack)) 694 address pc = (address)(size_t)pseudo_stack; 695 NativeCallStack stack(&pc, 1); 696 return (jlong)(uintptr_t)os::malloc(size, mtTest, stack); 697 WB_END 698 699 // Alloc memory with pseudo call stack and specific memory tag. 700 WB_ENTRY(jlong, WB_NMTMallocWithPseudoStackAndType(JNIEnv* env, jobject o, jlong size, jint pseudo_stack, jint mem_tag)) 701 address pc = (address)(size_t)pseudo_stack; 702 NativeCallStack stack(&pc, 1); 703 return (jlong)(uintptr_t)os::malloc(size, (MemTag)mem_tag, stack); 704 WB_END 705 706 // Free the memory allocated by NMTAllocTest 707 WB_ENTRY(void, WB_NMTFree(JNIEnv* env, jobject o, jlong mem)) 708 os::free((void*)(uintptr_t)mem); 709 WB_END 710 711 WB_ENTRY(jlong, WB_NMTReserveMemory(JNIEnv* env, jobject o, jlong size)) 712 return (jlong)(uintptr_t)os::reserve_memory(size, mtTest); 713 WB_END 714 715 WB_ENTRY(jlong, WB_NMTAttemptReserveMemoryAt(JNIEnv* env, jobject o, jlong addr, jlong size)) 716 return (jlong)(uintptr_t)os::attempt_reserve_memory_at((char*)(uintptr_t)addr, (size_t)size, mtTest); 717 WB_END 718 719 WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size)) 720 os::commit_memory((char *)(uintptr_t)addr, size, !ExecMem); 721 WB_END 722 723 WB_ENTRY(void, WB_NMTUncommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size)) 724 os::uncommit_memory((char *)(uintptr_t)addr, size); 725 WB_END 726 727 WB_ENTRY(void, WB_NMTReleaseMemory(JNIEnv* env, jobject o, jlong addr, jlong size)) 728 os::release_memory((char *)(uintptr_t)addr, size); 729 WB_END 730 731 WB_ENTRY(jint, WB_NMTGetHashSize(JNIEnv* env, jobject o)) 732 int hash_size = MallocSiteTable::hash_buckets(); 733 assert(hash_size > 0, "NMT hash_size should be > 0"); 734 return (jint)hash_size; 735 WB_END 736 737 WB_ENTRY(jlong, WB_NMTNewArena(JNIEnv* env, jobject o, jlong init_size)) 738 Arena* arena = new (mtTest) Arena(mtTest, Arena::Tag::tag_other, size_t(init_size)); 739 return (jlong)arena; 740 WB_END 741 742 WB_ENTRY(void, WB_NMTFreeArena(JNIEnv* env, jobject o, jlong arena)) 743 Arena* a = (Arena*)arena; 744 delete a; 745 WB_END 746 747 WB_ENTRY(void, WB_NMTArenaMalloc(JNIEnv* env, jobject o, jlong arena, jlong size)) 748 Arena* a = (Arena*)arena; 749 a->Amalloc(size_t(size)); 750 WB_END 751 752 static jmethodID reflected_method_to_jmid(JavaThread* thread, JNIEnv* env, jobject method) { 753 assert(method != nullptr, "method should not be null"); 754 ThreadToNativeFromVM ttn(thread); 755 return env->FromReflectedMethod(method); 756 } 757 758 // Deoptimizes all compiled frames and makes nmethods not entrant if it's requested 759 class VM_WhiteBoxDeoptimizeFrames : public VM_WhiteBoxOperation { 760 private: 761 int _result; 762 const bool _make_not_entrant; 763 public: 764 VM_WhiteBoxDeoptimizeFrames(bool make_not_entrant) : 765 _result(0), _make_not_entrant(make_not_entrant) { } 766 int result() const { return _result; } 767 768 void doit() { 769 for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) { 770 if (t->has_last_Java_frame()) { 771 for (StackFrameStream fst(t, false /* update */, true /* process_frames */); !fst.is_done(); fst.next()) { 772 frame* f = fst.current(); 773 if (f->can_be_deoptimized() && !f->is_deoptimized_frame()) { 774 Deoptimization::deoptimize(t, *f); 775 if (_make_not_entrant) { 776 nmethod* nm = CodeCache::find_nmethod(f->pc()); 777 assert(nm != nullptr, "did not find nmethod"); 778 nm->make_not_entrant(nmethod::InvalidationReason::WHITEBOX_DEOPTIMIZATION); 779 } 780 ++_result; 781 } 782 } 783 } 784 } 785 } 786 }; 787 788 WB_ENTRY(jint, WB_DeoptimizeFrames(JNIEnv* env, jobject o, jboolean make_not_entrant)) 789 VM_WhiteBoxDeoptimizeFrames op(make_not_entrant == JNI_TRUE); 790 VMThread::execute(&op); 791 return op.result(); 792 WB_END 793 794 WB_ENTRY(jboolean, WB_IsFrameDeoptimized(JNIEnv* env, jobject o, jint depth)) 795 bool result = false; 796 if (thread->has_last_Java_frame()) { 797 ResourceMark rm(THREAD); 798 RegisterMap reg_map(thread, 799 RegisterMap::UpdateMap::include, 800 RegisterMap::ProcessFrames::include, 801 RegisterMap::WalkContinuation::skip); 802 javaVFrame *jvf = thread->last_java_vframe(®_map); 803 for (jint d = 0; d < depth && jvf != nullptr; d++) { 804 jvf = jvf->java_sender(); 805 } 806 result = jvf != nullptr && jvf->fr().is_deoptimized_frame(); 807 } 808 return result; 809 WB_END 810 811 WB_ENTRY(void, WB_DeoptimizeAll(JNIEnv* env, jobject o)) 812 DeoptimizationScope deopt_scope; 813 CodeCache::mark_all_nmethods_for_deoptimization(&deopt_scope); 814 deopt_scope.deoptimize_marked(); 815 WB_END 816 817 WB_ENTRY(jint, WB_DeoptimizeMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr)) 818 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 819 int result = 0; 820 CHECK_JNI_EXCEPTION_(env, result); 821 822 DeoptimizationScope deopt_scope; 823 { 824 MutexLocker mu(Compile_lock); 825 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 826 if (is_osr) { 827 result += mh->method_holder()->mark_osr_nmethods(&deopt_scope, mh()); 828 } else { 829 MutexLocker ml(NMethodState_lock, Mutex::_no_safepoint_check_flag); 830 if (mh->code() != nullptr) { 831 deopt_scope.mark(mh->code()); 832 ++result; 833 } 834 } 835 CodeCache::mark_for_deoptimization(&deopt_scope, mh()); 836 } 837 838 deopt_scope.deoptimize_marked(); 839 840 return result; 841 WB_END 842 843 WB_ENTRY(jboolean, WB_IsMethodCompiled(JNIEnv* env, jobject o, jobject method, jboolean is_osr)) 844 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 845 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 846 MutexLocker mu(Compile_lock); 847 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 848 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code(); 849 if (code == nullptr) { 850 return JNI_FALSE; 851 } 852 return !code->is_marked_for_deoptimization(); 853 WB_END 854 855 static bool is_excluded_for_compiler(AbstractCompiler* comp, methodHandle& mh) { 856 if (comp == nullptr) { 857 return true; 858 } 859 DirectiveSet* directive = DirectivesStack::getMatchingDirective(mh, comp); 860 bool exclude = directive->ExcludeOption; 861 DirectivesStack::release(directive); 862 return exclude; 863 } 864 865 static bool can_be_compiled_at_level(methodHandle& mh, jboolean is_osr, int level) { 866 if (is_osr) { 867 return CompilationPolicy::can_be_osr_compiled(mh, level); 868 } else { 869 return CompilationPolicy::can_be_compiled(mh, level); 870 } 871 } 872 873 WB_ENTRY(jboolean, WB_IsMethodCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr)) 874 if (method == nullptr || comp_level > CompilationPolicy::highest_compile_level()) { 875 return false; 876 } 877 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 878 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 879 MutexLocker mu(Compile_lock); 880 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 881 882 // The ExcludeOption directive is evaluated lazily upon compilation attempt. If a method was not tried to be compiled by 883 // a compiler, yet, the method object is not set to be not compilable by that compiler. Thus, evaluate the compiler directive 884 // to exclude a compilation of 'method'. 885 if (comp_level == CompLevel_any) { 886 // Both compilers could have ExcludeOption set. Check all combinations. 887 bool excluded_c1 = is_excluded_for_compiler(CompileBroker::compiler1(), mh); 888 bool excluded_c2 = is_excluded_for_compiler(CompileBroker::compiler2(), mh); 889 if (excluded_c1 && excluded_c2) { 890 // Compilation of 'method' excluded by both compilers. 891 return false; 892 } 893 894 if (excluded_c1) { 895 // C1 only has ExcludeOption set: Check if compilable with C2. 896 return can_be_compiled_at_level(mh, is_osr, CompLevel_full_optimization); 897 } else if (excluded_c2) { 898 // C2 only has ExcludeOption set: Check if compilable with C1. 899 return can_be_compiled_at_level(mh, is_osr, CompLevel_simple); 900 } 901 } else if (comp_level > CompLevel_none && is_excluded_for_compiler(CompileBroker::compiler((int)comp_level), mh)) { 902 // Compilation of 'method' excluded by compiler used for 'comp_level'. 903 return false; 904 } 905 906 return can_be_compiled_at_level(mh, is_osr, (int)comp_level); 907 WB_END 908 909 WB_ENTRY(jboolean, WB_IsMethodQueuedForCompilation(JNIEnv* env, jobject o, jobject method)) 910 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 911 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 912 MutexLocker mu(Compile_lock); 913 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 914 return mh->queued_for_compilation(); 915 WB_END 916 917 WB_ENTRY(jboolean, WB_IsIntrinsicAvailable(JNIEnv* env, jobject o, jobject method, jobject compilation_context, jint compLevel)) 918 if (compLevel < CompLevel_none || compLevel > CompilationPolicy::highest_compile_level()) { 919 return false; // Intrinsic is not available on a non-existent compilation level. 920 } 921 AbstractCompiler* comp = CompileBroker::compiler((int)compLevel); 922 if (comp == nullptr) { 923 // Could have compLevel == 0, or !TieredCompilation and incompatible values of TieredStopAtLevel and compLevel. 924 tty->print_cr("WB error: no compiler for requested compilation level %d", compLevel); 925 return false; 926 } 927 928 jmethodID method_id, compilation_context_id; 929 method_id = reflected_method_to_jmid(thread, env, method); 930 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 931 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(method_id)); 932 933 DirectiveSet* directive; 934 if (compilation_context != nullptr) { 935 compilation_context_id = reflected_method_to_jmid(thread, env, compilation_context); 936 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 937 methodHandle cch(THREAD, Method::checked_resolve_jmethod_id(compilation_context_id)); 938 directive = DirectivesStack::getMatchingDirective(cch, comp); 939 } else { 940 // Calling with null matches default directive 941 directive = DirectivesStack::getDefaultDirective(comp); 942 } 943 bool result = comp->is_intrinsic_available(mh, directive); 944 DirectivesStack::release(directive); 945 return result; 946 WB_END 947 948 WB_ENTRY(jint, WB_GetMethodCompilationLevel(JNIEnv* env, jobject o, jobject method, jboolean is_osr)) 949 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 950 CHECK_JNI_EXCEPTION_(env, CompLevel_none); 951 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 952 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code(); 953 return (code != nullptr ? code->comp_level() : CompLevel_none); 954 WB_END 955 956 WB_ENTRY(void, WB_MakeMethodNotCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr)) 957 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 958 CHECK_JNI_EXCEPTION(env); 959 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 960 if (is_osr) { 961 mh->set_not_osr_compilable("WhiteBox", comp_level); 962 } else { 963 mh->set_not_compilable("WhiteBox", comp_level); 964 } 965 WB_END 966 967 WB_ENTRY(jint, WB_GetMethodDecompileCount(JNIEnv* env, jobject o, jobject method)) 968 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 969 CHECK_JNI_EXCEPTION_(env, 0); 970 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 971 uint cnt = 0; 972 MethodData* mdo = mh->method_data(); 973 if (mdo != nullptr) { 974 cnt = mdo->decompile_count(); 975 } 976 return cnt; 977 WB_END 978 979 // Get the trap count of a method for a specific reason. If the trap count for 980 // that reason did overflow, this includes the overflow trap count of the method. 981 // If 'reason' is null, the sum of the traps for all reasons will be returned. 982 // This number includes the overflow trap count if the trap count for any reason 983 // did overflow. 984 WB_ENTRY(jint, WB_GetMethodTrapCount(JNIEnv* env, jobject o, jobject method, jstring reason_obj)) 985 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 986 CHECK_JNI_EXCEPTION_(env, 0); 987 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 988 uint cnt = 0; 989 MethodData* mdo = mh->method_data(); 990 if (mdo != nullptr) { 991 ResourceMark rm(THREAD); 992 char* reason_str = (reason_obj == nullptr) ? 993 nullptr : java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(reason_obj)); 994 bool overflow = false; 995 for (uint reason = 0; reason < mdo->trap_reason_limit(); reason++) { 996 if (reason_str != nullptr && !strcmp(reason_str, Deoptimization::trap_reason_name(reason))) { 997 cnt = mdo->trap_count(reason); 998 // Count in the overflow trap count on overflow 999 if (cnt == (uint)-1) { 1000 cnt = mdo->trap_count_limit() + mdo->overflow_trap_count(); 1001 } 1002 break; 1003 } else if (reason_str == nullptr) { 1004 uint c = mdo->trap_count(reason); 1005 if (c == (uint)-1) { 1006 c = mdo->trap_count_limit(); 1007 if (!overflow) { 1008 // Count overflow trap count just once 1009 overflow = true; 1010 c += mdo->overflow_trap_count(); 1011 } 1012 } 1013 cnt += c; 1014 } 1015 } 1016 } 1017 return cnt; 1018 WB_END 1019 1020 WB_ENTRY(jint, WB_GetDeoptCount(JNIEnv* env, jobject o, jstring reason_obj, jstring action_obj)) 1021 if (reason_obj == nullptr && action_obj == nullptr) { 1022 return Deoptimization::total_deoptimization_count(); 1023 } 1024 ResourceMark rm(THREAD); 1025 const char *reason_str = (reason_obj == nullptr) ? 1026 nullptr : java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(reason_obj)); 1027 const char *action_str = (action_obj == nullptr) ? 1028 nullptr : java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(action_obj)); 1029 1030 return Deoptimization::deoptimization_count(reason_str, action_str); 1031 WB_END 1032 1033 WB_ENTRY(jint, WB_GetMethodEntryBci(JNIEnv* env, jobject o, jobject method)) 1034 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1035 CHECK_JNI_EXCEPTION_(env, InvocationEntryBci); 1036 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 1037 nmethod* code = mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false); 1038 return (code != nullptr && code->is_osr_method() ? code->osr_entry_bci() : InvocationEntryBci); 1039 WB_END 1040 1041 WB_ENTRY(jboolean, WB_TestSetDontInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value)) 1042 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1043 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 1044 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 1045 bool result = mh->dont_inline(); 1046 mh->set_dont_inline(value == JNI_TRUE); 1047 return result; 1048 WB_END 1049 1050 WB_ENTRY(jint, WB_GetCompileQueueSize(JNIEnv* env, jobject o, jint comp_level)) 1051 if (comp_level == CompLevel_any) { 1052 return CompileBroker::queue_size(CompLevel_full_optimization) /* C2 */ + 1053 CompileBroker::queue_size(CompLevel_full_profile) /* C1 */; 1054 } else { 1055 return CompileBroker::queue_size(comp_level); 1056 } 1057 WB_END 1058 1059 WB_ENTRY(jboolean, WB_TestSetForceInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value)) 1060 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1061 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 1062 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 1063 bool result = mh->force_inline(); 1064 mh->set_force_inline(value == JNI_TRUE); 1065 return result; 1066 WB_END 1067 1068 #ifdef LINUX 1069 bool WhiteBox::validate_cgroup(bool cgroups_v2_enabled, 1070 const char* controllers_file, 1071 const char* proc_self_cgroup, 1072 const char* proc_self_mountinfo, 1073 u1* cg_flags) { 1074 CgroupInfo cg_infos[CG_INFO_LENGTH]; 1075 return CgroupSubsystemFactory::determine_type(cg_infos, cgroups_v2_enabled, controllers_file, 1076 proc_self_cgroup, 1077 proc_self_mountinfo, cg_flags); 1078 } 1079 #endif 1080 1081 bool WhiteBox::is_asan_enabled() { 1082 #ifdef ADDRESS_SANITIZER 1083 return true; 1084 #else 1085 return false; 1086 #endif 1087 } 1088 1089 bool WhiteBox::is_ubsan_enabled() { 1090 #ifdef UNDEFINED_BEHAVIOR_SANITIZER 1091 return true; 1092 #else 1093 return false; 1094 #endif 1095 } 1096 1097 bool WhiteBox::compile_method(Method* method, int comp_level, int bci, JavaThread* THREAD) { 1098 // Screen for unavailable/bad comp level or null method 1099 AbstractCompiler* comp = CompileBroker::compiler(comp_level); 1100 if (method == nullptr) { 1101 tty->print_cr("WB error: request to compile null method"); 1102 return false; 1103 } 1104 if (method->is_abstract()) { 1105 tty->print_cr("WB error: request to compile abstract method"); 1106 return false; 1107 } 1108 if (comp_level > CompilationPolicy::highest_compile_level()) { 1109 tty->print_cr("WB error: invalid compilation level %d", comp_level); 1110 return false; 1111 } 1112 if (comp == nullptr) { 1113 tty->print_cr("WB error: no compiler for requested compilation level %d", comp_level); 1114 return false; 1115 } 1116 1117 // Check if compilation is blocking 1118 methodHandle mh(THREAD, method); 1119 DirectiveSet* directive = DirectivesStack::getMatchingDirective(mh, comp); 1120 bool is_blocking = !directive->BackgroundCompilationOption; 1121 DirectivesStack::release(directive); 1122 1123 // Compile method and check result 1124 nmethod* nm = CompileBroker::compile_method(mh, bci, comp_level, mh->invocation_count(), CompileTask::Reason_Whitebox, CHECK_false); 1125 MutexLocker mu(THREAD, Compile_lock); 1126 bool is_queued = mh->queued_for_compilation(); 1127 if ((!is_blocking && is_queued) || nm != nullptr) { 1128 return true; 1129 } 1130 // Check code again because compilation may be finished before Compile_lock is acquired. 1131 if (bci == InvocationEntryBci) { 1132 nmethod* code = mh->code(); 1133 if (code != nullptr) { 1134 return true; 1135 } 1136 } else if (mh->lookup_osr_nmethod_for(bci, comp_level, false) != nullptr) { 1137 return true; 1138 } 1139 tty->print("WB error: failed to %s compile at level %d method ", is_blocking ? "blocking" : "", comp_level); 1140 mh->print_short_name(tty); 1141 tty->cr(); 1142 if (is_blocking && is_queued) { 1143 tty->print_cr("WB error: blocking compilation is still in queue!"); 1144 } 1145 return false; 1146 } 1147 1148 size_t WhiteBox::get_in_use_monitor_count() { 1149 return ObjectSynchronizer::_in_use_list.count(); 1150 } 1151 1152 WB_ENTRY(jboolean, WB_EnqueueMethodForCompilation(JNIEnv* env, jobject o, jobject method, jint comp_level, jint bci)) 1153 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1154 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 1155 return WhiteBox::compile_method(Method::checked_resolve_jmethod_id(jmid), comp_level, bci, THREAD); 1156 WB_END 1157 1158 WB_ENTRY(jboolean, WB_EnqueueInitializerForCompilation(JNIEnv* env, jobject o, jclass klass, jint comp_level)) 1159 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass)); 1160 Method* clinit = ik->class_initializer(); 1161 if (clinit == nullptr || clinit->method_holder()->is_not_initialized()) { 1162 return false; 1163 } 1164 return WhiteBox::compile_method(clinit, comp_level, InvocationEntryBci, THREAD); 1165 WB_END 1166 1167 WB_ENTRY(jboolean, WB_ShouldPrintAssembly(JNIEnv* env, jobject o, jobject method, jint comp_level)) 1168 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1169 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 1170 1171 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 1172 DirectiveSet* directive = DirectivesStack::getMatchingDirective(mh, CompileBroker::compiler(comp_level)); 1173 bool result = directive->PrintAssemblyOption; 1174 DirectivesStack::release(directive); 1175 1176 return result; 1177 WB_END 1178 1179 WB_ENTRY(jint, WB_MatchesInline(JNIEnv* env, jobject o, jobject method, jstring pattern)) 1180 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1181 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 1182 1183 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 1184 1185 ResourceMark rm(THREAD); 1186 const char* error_msg = nullptr; 1187 char* method_str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(pattern)); 1188 InlineMatcher* m = InlineMatcher::parse_inline_pattern(method_str, error_msg); 1189 1190 if (m == nullptr) { 1191 assert(error_msg != nullptr, "Always have an error message"); 1192 tty->print_cr("Got error: %s", error_msg); 1193 return -1; // Pattern failed 1194 } 1195 1196 // Pattern works - now check if it matches 1197 int result; 1198 if (m->match(mh, InlineMatcher::force_inline)) { 1199 result = 2; // Force inline match 1200 } else if (m->match(mh, InlineMatcher::dont_inline)) { 1201 result = 1; // Dont inline match 1202 } else { 1203 result = 0; // No match 1204 } 1205 delete m; 1206 return result; 1207 WB_END 1208 1209 WB_ENTRY(jint, WB_MatchesMethod(JNIEnv* env, jobject o, jobject method, jstring pattern)) 1210 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1211 CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 1212 1213 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 1214 1215 ResourceMark rm; 1216 char* method_str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(pattern)); 1217 1218 const char* error_msg = nullptr; 1219 1220 BasicMatcher* m = BasicMatcher::parse_method_pattern(method_str, error_msg, false); 1221 if (m == nullptr) { 1222 assert(error_msg != nullptr, "Must have error_msg"); 1223 tty->print_cr("Got error: %s", error_msg); 1224 return -1; 1225 } 1226 1227 // Pattern works - now check if it matches 1228 int result = m->matches(mh); 1229 delete m; 1230 assert(result == 0 || result == 1, "Result out of range"); 1231 return result; 1232 WB_END 1233 1234 WB_ENTRY(void, WB_MarkMethodProfiled(JNIEnv* env, jobject o, jobject method)) 1235 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1236 CHECK_JNI_EXCEPTION(env); 1237 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 1238 1239 MethodData* mdo = mh->method_data(); 1240 if (mdo == nullptr) { 1241 Method::build_profiling_method_data(mh, CHECK_AND_CLEAR); 1242 mdo = mh->method_data(); 1243 } 1244 mdo->init(); 1245 InvocationCounter* icnt = mdo->invocation_counter(); 1246 InvocationCounter* bcnt = mdo->backedge_counter(); 1247 // set i-counter according to CompilationPolicy::is_method_profiled 1248 icnt->set(Tier4MinInvocationThreshold); 1249 bcnt->set(Tier4CompileThreshold); 1250 WB_END 1251 1252 WB_ENTRY(void, WB_ClearMethodState(JNIEnv* env, jobject o, jobject method)) 1253 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1254 CHECK_JNI_EXCEPTION(env); 1255 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 1256 MutexLocker mu(THREAD, Compile_lock); 1257 MethodData* mdo = mh->method_data(); 1258 MethodCounters* mcs = mh->method_counters(); 1259 1260 if (mdo != nullptr) { 1261 mdo->init(); 1262 ResourceMark rm(THREAD); 1263 int arg_count = mdo->method()->size_of_parameters(); 1264 for (int i = 0; i < arg_count; i++) { 1265 mdo->set_arg_modified(i, 0); 1266 } 1267 mdo->clean_method_data(/*always_clean*/true); 1268 } 1269 1270 mh->clear_is_not_c1_compilable(); 1271 mh->clear_is_not_c2_compilable(); 1272 mh->clear_is_not_c2_osr_compilable(); 1273 NOT_PRODUCT(mh->set_compiled_invocation_count(0)); 1274 if (mcs != nullptr) { 1275 mcs->clear_counters(); 1276 } 1277 WB_END 1278 1279 template <typename T, int type_enum> 1280 static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value) { 1281 if (name == nullptr) { 1282 return false; 1283 } 1284 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 1285 const char* flag_name = env->GetStringUTFChars(name, nullptr); 1286 CHECK_JNI_EXCEPTION_(env, false); 1287 const JVMFlag* flag = JVMFlag::find_declared_flag(flag_name); 1288 JVMFlag::Error result = JVMFlagAccess::get<T, type_enum>(flag, value); 1289 env->ReleaseStringUTFChars(name, flag_name); 1290 return (result == JVMFlag::SUCCESS); 1291 } 1292 1293 template <typename T, int type_enum> 1294 static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value) { 1295 if (name == nullptr) { 1296 return false; 1297 } 1298 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 1299 const char* flag_name = env->GetStringUTFChars(name, nullptr); 1300 CHECK_JNI_EXCEPTION_(env, false); 1301 JVMFlag* flag = JVMFlag::find_flag(flag_name); 1302 JVMFlag::Error result = JVMFlagAccess::set<T, type_enum>(flag, value, JVMFlagOrigin::INTERNAL); 1303 env->ReleaseStringUTFChars(name, flag_name); 1304 return (result == JVMFlag::SUCCESS); 1305 } 1306 1307 template <typename T> 1308 static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) { 1309 ResourceMark rm(thread); 1310 jclass clazz = env->FindClass(name->as_C_string()); 1311 CHECK_JNI_EXCEPTION_(env, nullptr); 1312 jmethodID methodID = env->GetStaticMethodID(clazz, 1313 vmSymbols::valueOf_name()->as_C_string(), 1314 sig->as_C_string()); 1315 CHECK_JNI_EXCEPTION_(env, nullptr); 1316 jobject result = env->CallStaticObjectMethod(clazz, methodID, value); 1317 CHECK_JNI_EXCEPTION_(env, nullptr); 1318 return result; 1319 } 1320 1321 static jobject booleanBox(JavaThread* thread, JNIEnv* env, jboolean value) { 1322 return box(thread, env, vmSymbols::java_lang_Boolean(), vmSymbols::Boolean_valueOf_signature(), value); 1323 } 1324 static jobject integerBox(JavaThread* thread, JNIEnv* env, jint value) { 1325 return box(thread, env, vmSymbols::java_lang_Integer(), vmSymbols::Integer_valueOf_signature(), value); 1326 } 1327 static jobject longBox(JavaThread* thread, JNIEnv* env, jlong value) { 1328 return box(thread, env, vmSymbols::java_lang_Long(), vmSymbols::Long_valueOf_signature(), value); 1329 } 1330 /* static jobject floatBox(JavaThread* thread, JNIEnv* env, jfloat value) { 1331 return box(thread, env, vmSymbols::java_lang_Float(), vmSymbols::Float_valueOf_signature(), value); 1332 }*/ 1333 static jobject doubleBox(JavaThread* thread, JNIEnv* env, jdouble value) { 1334 return box(thread, env, vmSymbols::java_lang_Double(), vmSymbols::Double_valueOf_signature(), value); 1335 } 1336 1337 static const JVMFlag* getVMFlag(JavaThread* thread, JNIEnv* env, jstring name) { 1338 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 1339 const char* flag_name = env->GetStringUTFChars(name, nullptr); 1340 CHECK_JNI_EXCEPTION_(env, nullptr); 1341 const JVMFlag* result = JVMFlag::find_declared_flag(flag_name); 1342 env->ReleaseStringUTFChars(name, flag_name); 1343 return result; 1344 } 1345 1346 WB_ENTRY(jboolean, WB_IsConstantVMFlag(JNIEnv* env, jobject o, jstring name)) 1347 const JVMFlag* flag = getVMFlag(thread, env, name); 1348 return (flag != nullptr) && flag->is_constant_in_binary(); 1349 WB_END 1350 1351 WB_ENTRY(jboolean, WB_IsDefaultVMFlag(JNIEnv* env, jobject o, jstring name)) 1352 const JVMFlag* flag = getVMFlag(thread, env, name); 1353 return (flag != nullptr) && flag->is_default(); 1354 WB_END 1355 1356 WB_ENTRY(jboolean, WB_IsLockedVMFlag(JNIEnv* env, jobject o, jstring name)) 1357 const JVMFlag* flag = getVMFlag(thread, env, name); 1358 return (flag != nullptr) && !(flag->is_unlocked() || flag->is_unlocker()); 1359 WB_END 1360 1361 WB_ENTRY(jobject, WB_GetBooleanVMFlag(JNIEnv* env, jobject o, jstring name)) 1362 bool result; 1363 if (GetVMFlag <JVM_FLAG_TYPE(bool)> (thread, env, name, &result)) { 1364 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 1365 return booleanBox(thread, env, result); 1366 } 1367 return nullptr; 1368 WB_END 1369 1370 template <typename T, int type_enum> 1371 jobject GetVMFlag_longBox(JNIEnv* env, JavaThread* thread, jstring name) { 1372 T result; 1373 if (GetVMFlag <T, type_enum> (thread, env, name, &result)) { 1374 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 1375 return longBox(thread, env, result); 1376 } 1377 return nullptr; 1378 } 1379 1380 WB_ENTRY(jobject, WB_GetIntVMFlag(JNIEnv* env, jobject o, jstring name)) 1381 return GetVMFlag_longBox<JVM_FLAG_TYPE(int)>(env, thread, name); 1382 WB_END 1383 1384 WB_ENTRY(jobject, WB_GetUintVMFlag(JNIEnv* env, jobject o, jstring name)) 1385 return GetVMFlag_longBox<JVM_FLAG_TYPE(uint)>(env, thread, name); 1386 WB_END 1387 1388 WB_ENTRY(jobject, WB_GetIntxVMFlag(JNIEnv* env, jobject o, jstring name)) 1389 return GetVMFlag_longBox<JVM_FLAG_TYPE(intx)>(env, thread, name); 1390 WB_END 1391 1392 WB_ENTRY(jobject, WB_GetUintxVMFlag(JNIEnv* env, jobject o, jstring name)) 1393 return GetVMFlag_longBox<JVM_FLAG_TYPE(uintx)>(env, thread, name); 1394 WB_END 1395 1396 WB_ENTRY(jobject, WB_GetUint64VMFlag(JNIEnv* env, jobject o, jstring name)) 1397 return GetVMFlag_longBox<JVM_FLAG_TYPE(uint64_t)>(env, thread, name); 1398 WB_END 1399 1400 WB_ENTRY(jobject, WB_GetSizeTVMFlag(JNIEnv* env, jobject o, jstring name)) 1401 return GetVMFlag_longBox<JVM_FLAG_TYPE(size_t)>(env, thread, name); 1402 WB_END 1403 1404 WB_ENTRY(jobject, WB_GetDoubleVMFlag(JNIEnv* env, jobject o, jstring name)) 1405 double result; 1406 if (GetVMFlag <JVM_FLAG_TYPE(double)> (thread, env, name, &result)) { 1407 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 1408 return doubleBox(thread, env, result); 1409 } 1410 return nullptr; 1411 WB_END 1412 1413 WB_ENTRY(jstring, WB_GetStringVMFlag(JNIEnv* env, jobject o, jstring name)) 1414 ccstr ccstrResult; 1415 if (GetVMFlag <JVM_FLAG_TYPE(ccstr)> (thread, env, name, &ccstrResult)) { 1416 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 1417 jstring result = env->NewStringUTF(ccstrResult); 1418 CHECK_JNI_EXCEPTION_(env, nullptr); 1419 return result; 1420 } 1421 return nullptr; 1422 WB_END 1423 1424 WB_ENTRY(void, WB_SetBooleanVMFlag(JNIEnv* env, jobject o, jstring name, jboolean value)) 1425 bool result = value == JNI_TRUE ? true : false; 1426 SetVMFlag <JVM_FLAG_TYPE(bool)> (thread, env, name, &result); 1427 WB_END 1428 1429 WB_ENTRY(void, WB_SetIntVMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 1430 int result = checked_cast<int>(value); 1431 SetVMFlag <JVM_FLAG_TYPE(int)> (thread, env, name, &result); 1432 WB_END 1433 1434 WB_ENTRY(void, WB_SetUintVMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 1435 uint result = checked_cast<uint>(value); 1436 SetVMFlag <JVM_FLAG_TYPE(uint)> (thread, env, name, &result); 1437 WB_END 1438 1439 WB_ENTRY(void, WB_SetIntxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 1440 intx result = value; 1441 SetVMFlag <JVM_FLAG_TYPE(intx)> (thread, env, name, &result); 1442 WB_END 1443 1444 WB_ENTRY(void, WB_SetUintxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 1445 uintx result = value; 1446 SetVMFlag <JVM_FLAG_TYPE(uintx)> (thread, env, name, &result); 1447 WB_END 1448 1449 WB_ENTRY(void, WB_SetUint64VMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 1450 uint64_t result = value; 1451 SetVMFlag <JVM_FLAG_TYPE(uint64_t)> (thread, env, name, &result); 1452 WB_END 1453 1454 WB_ENTRY(void, WB_SetSizeTVMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 1455 size_t result = value; 1456 SetVMFlag <JVM_FLAG_TYPE(size_t)> (thread, env, name, &result); 1457 WB_END 1458 1459 WB_ENTRY(void, WB_SetDoubleVMFlag(JNIEnv* env, jobject o, jstring name, jdouble value)) 1460 double result = value; 1461 SetVMFlag <JVM_FLAG_TYPE(double)> (thread, env, name, &result); 1462 WB_END 1463 1464 WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value)) 1465 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 1466 const char* ccstrValue; 1467 if (value == nullptr) { 1468 ccstrValue = nullptr; 1469 } 1470 else { 1471 ccstrValue = env->GetStringUTFChars(value, nullptr); 1472 CHECK_JNI_EXCEPTION(env); 1473 } 1474 { 1475 ccstr param = ccstrValue; 1476 ThreadInVMfromNative ttvfn(thread); // back to VM 1477 if (SetVMFlag <JVM_FLAG_TYPE(ccstr)> (thread, env, name, ¶m)) { 1478 assert(param == nullptr, "old value is freed automatically and not returned"); 1479 } 1480 } 1481 if (value != nullptr) { 1482 env->ReleaseStringUTFChars(value, ccstrValue); 1483 } 1484 WB_END 1485 1486 WB_ENTRY(void, WB_LockCompilation(JNIEnv* env, jobject o, jlong timeout)) 1487 WhiteBox::compilation_locked = true; 1488 WB_END 1489 1490 WB_ENTRY(void, WB_UnlockCompilation(JNIEnv* env, jobject o)) 1491 MonitorLocker mo(Compilation_lock, Mutex::_no_safepoint_check_flag); 1492 WhiteBox::compilation_locked = false; 1493 mo.notify_all(); 1494 WB_END 1495 1496 WB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString)) 1497 ResourceMark rm(THREAD); 1498 int len; 1499 jchar* name = java_lang_String::as_unicode_string(JNIHandles::resolve(javaString), len, CHECK_false); 1500 return (StringTable::lookup(name, len) != nullptr); 1501 WB_END 1502 1503 WB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o)) 1504 Universe::heap()->collect(GCCause::_wb_full_gc); 1505 WB_END 1506 1507 WB_ENTRY(void, WB_YoungGC(JNIEnv* env, jobject o)) 1508 Universe::heap()->collect(GCCause::_wb_young_gc); 1509 WB_END 1510 1511 WB_ENTRY(void, WB_ReadReservedMemory(JNIEnv* env, jobject o)) 1512 // static+volatile in order to force the read to happen 1513 // (not be eliminated by the compiler) 1514 static char c; 1515 static volatile char* p; 1516 1517 p = os::reserve_memory(os::vm_allocation_granularity(), mtTest); 1518 if (p == nullptr) { 1519 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory"); 1520 } 1521 1522 c = *p; 1523 WB_END 1524 1525 WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o)) 1526 const char* features = VM_Version::cpu_info_string(); 1527 ThreadToNativeFromVM ttn(thread); 1528 jstring features_string = env->NewStringUTF(features); 1529 1530 CHECK_JNI_EXCEPTION_(env, nullptr); 1531 1532 return features_string; 1533 WB_END 1534 1535 CodeBlobType WhiteBox::get_blob_type(const CodeBlob* code) { 1536 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled"); 1537 return CodeCache::get_code_heap(code)->code_blob_type(); 1538 } 1539 1540 CodeHeap* WhiteBox::get_code_heap(CodeBlobType blob_type) { 1541 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled"); 1542 return CodeCache::get_code_heap(blob_type); 1543 } 1544 1545 struct CodeBlobStub { 1546 CodeBlobStub(const CodeBlob* blob) : 1547 name(os::strdup(blob->name())), 1548 size(blob->size()), 1549 blob_type(static_cast<jint>(WhiteBox::get_blob_type(blob))), 1550 address((jlong) blob) { } 1551 ~CodeBlobStub() { os::free((void*) name); } 1552 const char* const name; 1553 const jint size; 1554 const jint blob_type; 1555 const jlong address; 1556 }; 1557 1558 static jobjectArray codeBlob2objectArray(JavaThread* thread, JNIEnv* env, CodeBlobStub* cb) { 1559 ResourceMark rm; 1560 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string()); 1561 CHECK_JNI_EXCEPTION_(env, nullptr); 1562 jobjectArray result = env->NewObjectArray(4, clazz, nullptr); 1563 1564 jstring name = env->NewStringUTF(cb->name); 1565 CHECK_JNI_EXCEPTION_(env, nullptr); 1566 env->SetObjectArrayElement(result, 0, name); 1567 1568 jobject obj = integerBox(thread, env, cb->size); 1569 CHECK_JNI_EXCEPTION_(env, nullptr); 1570 env->SetObjectArrayElement(result, 1, obj); 1571 1572 obj = integerBox(thread, env, cb->blob_type); 1573 CHECK_JNI_EXCEPTION_(env, nullptr); 1574 env->SetObjectArrayElement(result, 2, obj); 1575 1576 obj = longBox(thread, env, cb->address); 1577 CHECK_JNI_EXCEPTION_(env, nullptr); 1578 env->SetObjectArrayElement(result, 3, obj); 1579 1580 return result; 1581 } 1582 1583 WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr)) 1584 ResourceMark rm(THREAD); 1585 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1586 CHECK_JNI_EXCEPTION_(env, nullptr); 1587 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 1588 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code(); 1589 jobjectArray result = nullptr; 1590 if (code == nullptr) { 1591 return result; 1592 } 1593 int comp_level = code->comp_level(); 1594 int insts_size = code->insts_size(); 1595 1596 ThreadToNativeFromVM ttn(thread); 1597 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string()); 1598 CHECK_JNI_EXCEPTION_(env, nullptr); 1599 result = env->NewObjectArray(5, clazz, nullptr); 1600 if (result == nullptr) { 1601 return result; 1602 } 1603 1604 CodeBlobStub stub(code); 1605 jobjectArray codeBlob = codeBlob2objectArray(thread, env, &stub); 1606 CHECK_JNI_EXCEPTION_(env, nullptr); 1607 env->SetObjectArrayElement(result, 0, codeBlob); 1608 1609 jobject level = integerBox(thread, env, comp_level); 1610 CHECK_JNI_EXCEPTION_(env, nullptr); 1611 env->SetObjectArrayElement(result, 1, level); 1612 1613 jbyteArray insts = env->NewByteArray(insts_size); 1614 CHECK_JNI_EXCEPTION_(env, nullptr); 1615 env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin()); 1616 env->SetObjectArrayElement(result, 2, insts); 1617 1618 jobject id = integerBox(thread, env, code->compile_id()); 1619 CHECK_JNI_EXCEPTION_(env, nullptr); 1620 env->SetObjectArrayElement(result, 3, id); 1621 1622 jobject entry_point = longBox(thread, env, (jlong) code->entry_point()); 1623 CHECK_JNI_EXCEPTION_(env, nullptr); 1624 env->SetObjectArrayElement(result, 4, entry_point); 1625 1626 return result; 1627 WB_END 1628 1629 CodeBlob* WhiteBox::allocate_code_blob(int size, CodeBlobType blob_type) { 1630 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled"); 1631 BufferBlob* blob; 1632 int full_size = CodeBlob::align_code_offset(sizeof(BufferBlob)); 1633 if (full_size < size) { 1634 full_size += align_up(size - full_size, oopSize); 1635 } 1636 { 1637 MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 1638 blob = (BufferBlob*) CodeCache::allocate(full_size, blob_type); 1639 if (blob != nullptr) { 1640 ::new (blob) BufferBlob("WB::DummyBlob", CodeBlobKind::Buffer, full_size); 1641 } 1642 } 1643 // Track memory usage statistic after releasing CodeCache_lock 1644 MemoryService::track_code_cache_memory_usage(); 1645 return blob; 1646 } 1647 1648 WB_ENTRY(jlong, WB_AllocateCodeBlob(JNIEnv* env, jobject o, jint size, jint blob_type)) 1649 if (size < 0) { 1650 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 1651 err_msg("WB_AllocateCodeBlob: size is negative: " INT32_FORMAT, size)); 1652 } 1653 return (jlong) WhiteBox::allocate_code_blob(size, static_cast<CodeBlobType>(blob_type)); 1654 WB_END 1655 1656 WB_ENTRY(void, WB_FreeCodeBlob(JNIEnv* env, jobject o, jlong addr)) 1657 if (addr == 0) { 1658 return; 1659 } 1660 BufferBlob::free((BufferBlob*) addr); 1661 WB_END 1662 1663 WB_ENTRY(jobjectArray, WB_GetCodeHeapEntries(JNIEnv* env, jobject o, jint blob_type)) 1664 ResourceMark rm; 1665 GrowableArray<CodeBlobStub*> blobs; 1666 { 1667 MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 1668 CodeHeap* heap = WhiteBox::get_code_heap(static_cast<CodeBlobType>(blob_type)); 1669 if (heap == nullptr) { 1670 return nullptr; 1671 } 1672 for (CodeBlob* cb = (CodeBlob*) heap->first(); 1673 cb != nullptr; cb = (CodeBlob*) heap->next(cb)) { 1674 CodeBlobStub* stub = NEW_RESOURCE_OBJ(CodeBlobStub); 1675 new (stub) CodeBlobStub(cb); 1676 blobs.append(stub); 1677 } 1678 } 1679 ThreadToNativeFromVM ttn(thread); 1680 jobjectArray result = nullptr; 1681 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string()); 1682 CHECK_JNI_EXCEPTION_(env, nullptr); 1683 result = env->NewObjectArray(blobs.length(), clazz, nullptr); 1684 CHECK_JNI_EXCEPTION_(env, nullptr); 1685 if (result == nullptr) { 1686 return result; 1687 } 1688 int i = 0; 1689 for (GrowableArrayIterator<CodeBlobStub*> it = blobs.begin(); 1690 it != blobs.end(); ++it) { 1691 jobjectArray obj = codeBlob2objectArray(thread, env, *it); 1692 CHECK_JNI_EXCEPTION_(env, nullptr); 1693 env->SetObjectArrayElement(result, i, obj); 1694 CHECK_JNI_EXCEPTION_(env, nullptr); 1695 ++i; 1696 } 1697 return result; 1698 WB_END 1699 1700 WB_ENTRY(jint, WB_GetCompilationActivityMode(JNIEnv* env, jobject o)) 1701 return CompileBroker::get_compilation_activity_mode(); 1702 WB_END 1703 1704 WB_ENTRY(jobjectArray, WB_GetCodeBlob(JNIEnv* env, jobject o, jlong addr)) 1705 if (addr == 0) { 1706 THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(), 1707 "WB_GetCodeBlob: addr is null"); 1708 } 1709 ThreadToNativeFromVM ttn(thread); 1710 CodeBlobStub stub((CodeBlob*) addr); 1711 return codeBlob2objectArray(thread, env, &stub); 1712 WB_END 1713 1714 WB_ENTRY(jlong, WB_GetMethodData(JNIEnv* env, jobject wv, jobject method)) 1715 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1716 CHECK_JNI_EXCEPTION_(env, 0); 1717 methodHandle mh(thread, Method::checked_resolve_jmethod_id(jmid)); 1718 return (jlong) mh->method_data(); 1719 WB_END 1720 1721 WB_ENTRY(jlong, WB_GetThreadStackSize(JNIEnv* env, jobject o)) 1722 return (jlong) thread->stack_size(); 1723 WB_END 1724 1725 WB_ENTRY(jlong, WB_GetThreadRemainingStackSize(JNIEnv* env, jobject o)) 1726 return (jlong) thread->stack_overflow_state()->stack_available( 1727 os::current_stack_pointer()) - (jlong)StackOverflow::stack_shadow_zone_size(); 1728 WB_END 1729 1730 1731 int WhiteBox::array_bytes_to_length(size_t bytes) { 1732 return Array<u1>::bytes_to_length(bytes); 1733 } 1734 1735 /////////////// 1736 // MetaspaceTestContext and MetaspaceTestArena 1737 WB_ENTRY(jlong, WB_CreateMetaspaceTestContext(JNIEnv* env, jobject wb, jlong commit_limit, jlong reserve_limit)) 1738 assert(is_aligned(commit_limit, BytesPerWord), 1739 "WB_CreateMetaspaceTestContext: commit_limit is not a multiple of the system word byte size"); 1740 assert(is_aligned(reserve_limit, BytesPerWord), 1741 "WB_CreateMetaspaceTestContext: reserve_limit is not a multiple of the system word byte size"); 1742 metaspace::MetaspaceTestContext* context = 1743 new metaspace::MetaspaceTestContext("whitebox-metaspace-context", (size_t) commit_limit / BytesPerWord, 1744 (size_t) reserve_limit / BytesPerWord); 1745 return (jlong)p2i(context); 1746 WB_END 1747 1748 WB_ENTRY(void, WB_DestroyMetaspaceTestContext(JNIEnv* env, jobject wb, jlong context)) 1749 delete (metaspace::MetaspaceTestContext*) context; 1750 WB_END 1751 1752 WB_ENTRY(void, WB_PurgeMetaspaceTestContext(JNIEnv* env, jobject wb, jlong context)) 1753 metaspace::MetaspaceTestContext* context0 = (metaspace::MetaspaceTestContext*) context; 1754 context0->purge_area(); 1755 WB_END 1756 1757 WB_ENTRY(void, WB_PrintMetaspaceTestContext(JNIEnv* env, jobject wb, jlong context)) 1758 metaspace::MetaspaceTestContext* context0 = (metaspace::MetaspaceTestContext*) context; 1759 context0->print_on(tty); 1760 WB_END 1761 1762 WB_ENTRY(jlong, WB_GetTotalCommittedBytesInMetaspaceTestContext(JNIEnv* env, jobject wb, jlong context)) 1763 metaspace::MetaspaceTestContext* context0 = (metaspace::MetaspaceTestContext*) context; 1764 return (jlong)context0->committed_words() * BytesPerWord; 1765 WB_END 1766 1767 WB_ENTRY(jlong, WB_GetTotalUsedBytesInMetaspaceTestContext(JNIEnv* env, jobject wb, jlong context)) 1768 metaspace::MetaspaceTestContext* context0 = (metaspace::MetaspaceTestContext*) context; 1769 return (jlong)context0->used_words() * BytesPerWord; 1770 WB_END 1771 1772 WB_ENTRY(jlong, WB_CreateArenaInTestContext(JNIEnv* env, jobject wb, jlong context, jboolean is_micro)) 1773 const Metaspace::MetaspaceType type = is_micro ? Metaspace::ClassMirrorHolderMetaspaceType : Metaspace::StandardMetaspaceType; 1774 metaspace::MetaspaceTestContext* context0 = (metaspace::MetaspaceTestContext*) context; 1775 return (jlong)p2i(context0->create_arena(type)); 1776 WB_END 1777 1778 WB_ENTRY(void, WB_DestroyMetaspaceTestArena(JNIEnv* env, jobject wb, jlong arena)) 1779 delete (metaspace::MetaspaceTestArena*) arena; 1780 WB_END 1781 1782 WB_ENTRY(jlong, WB_AllocateFromMetaspaceTestArena(JNIEnv* env, jobject wb, jlong arena, jlong size)) 1783 assert(is_aligned(size, BytesPerWord), 1784 "WB_AllocateFromMetaspaceTestArena: size is not a multiple of the system word byte size"); 1785 metaspace::MetaspaceTestArena *arena0 = (metaspace::MetaspaceTestArena *)arena; 1786 MetaWord *p = arena0->allocate((size_t) size / BytesPerWord); 1787 return (jlong)p2i(p); 1788 WB_END 1789 1790 WB_ENTRY(void, WB_DeallocateToMetaspaceTestArena(JNIEnv* env, jobject wb, jlong arena, jlong p, jlong size)) 1791 assert(is_aligned(size, BytesPerWord), 1792 "WB_DeallocateToMetaspaceTestArena: size is not a multiple of the system word byte size"); 1793 metaspace::MetaspaceTestArena* arena0 = (metaspace::MetaspaceTestArena*) arena; 1794 arena0->deallocate((MetaWord*)p, (size_t) size / BytesPerWord); 1795 WB_END 1796 1797 WB_ENTRY(jlong, WB_GetMaxMetaspaceAllocationSize(JNIEnv* env, jobject wb)) 1798 return (jlong) Metaspace::max_allocation_word_size() * BytesPerWord; 1799 WB_END 1800 1801 WB_ENTRY(jlong, WB_WordSize(JNIEnv* env)) 1802 return (jlong)BytesPerWord; 1803 WB_END 1804 1805 WB_ENTRY(jlong, WB_RootChunkWordSize(JNIEnv* env)) 1806 return (jlong)Metaspace::reserve_alignment_words(); 1807 WB_END 1808 1809 WB_ENTRY(jboolean, WB_IsStaticallyLinked(JNIEnv* env, jobject wb)) 1810 return JVM_IsStaticallyLinked(); 1811 WB_END 1812 1813 ////////////// 1814 1815 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size)) 1816 if (size < 0) { 1817 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 1818 err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size)); 1819 } 1820 1821 oop class_loader_oop = JNIHandles::resolve(class_loader); 1822 ClassLoaderData* cld = class_loader_oop != nullptr 1823 ? java_lang_ClassLoader::loader_data_acquire(class_loader_oop) 1824 : ClassLoaderData::the_null_class_loader_data(); 1825 1826 void* metadata = MetadataFactory::new_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread); 1827 1828 return (jlong)(uintptr_t)metadata; 1829 WB_END 1830 1831 WB_ENTRY(void, WB_DefineModule(JNIEnv* env, jobject o, jobject module, jboolean is_open, 1832 jstring version, jstring location, jobjectArray packages)) 1833 Handle h_module (THREAD, JNIHandles::resolve(module)); 1834 Modules::define_module(h_module, is_open, version, location, packages, CHECK); 1835 WB_END 1836 1837 WB_ENTRY(void, WB_AddModuleExports(JNIEnv* env, jobject o, jobject from_module, jstring package, jobject to_module)) 1838 Handle h_from_module (THREAD, JNIHandles::resolve(from_module)); 1839 Handle h_to_module (THREAD, JNIHandles::resolve(to_module)); 1840 Modules::add_module_exports_qualified(h_from_module, package, h_to_module, CHECK); 1841 WB_END 1842 1843 WB_ENTRY(void, WB_AddModuleExportsToAllUnnamed(JNIEnv* env, jobject o, jclass module, jstring package)) 1844 Handle h_module (THREAD, JNIHandles::resolve(module)); 1845 Modules::add_module_exports_to_all_unnamed(h_module, package, CHECK); 1846 WB_END 1847 1848 WB_ENTRY(void, WB_AddModuleExportsToAll(JNIEnv* env, jobject o, jclass module, jstring package)) 1849 Handle h_module (THREAD, JNIHandles::resolve(module)); 1850 Modules::add_module_exports(h_module, package, Handle(), CHECK); 1851 WB_END 1852 1853 WB_ENTRY(void, WB_AddReadsModule(JNIEnv* env, jobject o, jobject from_module, jobject source_module)) 1854 Handle h_from_module (THREAD, JNIHandles::resolve(from_module)); 1855 Handle h_source_module (THREAD, JNIHandles::resolve(source_module)); 1856 Modules::add_reads_module(h_from_module, h_source_module, CHECK); 1857 WB_END 1858 1859 WB_ENTRY(jlong, WB_IncMetaspaceCapacityUntilGC(JNIEnv* env, jobject wb, jlong inc)) 1860 if (inc < 0) { 1861 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 1862 err_msg("WB_IncMetaspaceCapacityUntilGC: inc is negative: " JLONG_FORMAT, inc)); 1863 } 1864 1865 jlong max_size_t = (jlong) ((size_t) -1); 1866 if (inc > max_size_t) { 1867 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 1868 err_msg("WB_IncMetaspaceCapacityUntilGC: inc does not fit in size_t: " JLONG_FORMAT, inc)); 1869 } 1870 1871 size_t new_cap_until_GC = 0; 1872 size_t aligned_inc = align_down((size_t) inc, Metaspace::commit_alignment()); 1873 bool success = MetaspaceGC::inc_capacity_until_GC(aligned_inc, &new_cap_until_GC); 1874 if (!success) { 1875 THROW_MSG_0(vmSymbols::java_lang_IllegalStateException(), 1876 "WB_IncMetaspaceCapacityUntilGC: could not increase capacity until GC " 1877 "due to contention with another thread"); 1878 } 1879 return (jlong) new_cap_until_GC; 1880 WB_END 1881 1882 WB_ENTRY(jlong, WB_MetaspaceCapacityUntilGC(JNIEnv* env, jobject wb)) 1883 return (jlong) MetaspaceGC::capacity_until_GC(); 1884 WB_END 1885 1886 // The function is only valid when CDS is available. 1887 WB_ENTRY(jlong, WB_AOTMetaspaceRegionAlignment(JNIEnv* env, jobject wb)) 1888 #if INCLUDE_CDS 1889 return (jlong)AOTMetaspace::core_region_alignment(); 1890 #else 1891 ShouldNotReachHere(); 1892 return 0L; 1893 #endif 1894 WB_END 1895 1896 WB_ENTRY(jboolean, WB_IsMonitorInflated(JNIEnv* env, jobject wb, jobject obj)) 1897 oop obj_oop = JNIHandles::resolve(obj); 1898 return (jboolean) obj_oop->mark().has_monitor(); 1899 WB_END 1900 1901 WB_ENTRY(jboolean, WB_IsAsanEnabled(JNIEnv* env)) 1902 return (jboolean) WhiteBox::is_asan_enabled(); 1903 WB_END 1904 1905 WB_ENTRY(jboolean, WB_IsUbsanEnabled(JNIEnv* env)) 1906 return (jboolean) WhiteBox::is_ubsan_enabled(); 1907 WB_END 1908 1909 WB_ENTRY(jlong, WB_getInUseMonitorCount(JNIEnv* env, jobject wb)) 1910 return (jlong) WhiteBox::get_in_use_monitor_count(); 1911 WB_END 1912 1913 WB_ENTRY(jint, WB_getLockStackCapacity(JNIEnv* env)) 1914 return (jint) LockStack::CAPACITY; 1915 WB_END 1916 1917 WB_ENTRY(jboolean, WB_supportsRecursiveLightweightLocking(JNIEnv* env)) 1918 return (jboolean) VM_Version::supports_recursive_lightweight_locking(); 1919 WB_END 1920 1921 WB_ENTRY(jboolean, WB_DeflateIdleMonitors(JNIEnv* env, jobject wb)) 1922 log_info(monitorinflation)("WhiteBox initiated DeflateIdleMonitors"); 1923 return ObjectSynchronizer::request_deflate_idle_monitors_from_wb(); 1924 WB_END 1925 1926 WB_ENTRY(void, WB_ForceSafepoint(JNIEnv* env, jobject wb)) 1927 VM_ForceSafepoint force_safepoint_op; 1928 VMThread::execute(&force_safepoint_op); 1929 WB_END 1930 1931 WB_ENTRY(void, WB_ForceClassLoaderStatsSafepoint(JNIEnv* env, jobject wb)) 1932 nullStream dev_null; 1933 ClassLoaderStatsVMOperation force_op(&dev_null); 1934 VMThread::execute(&force_op); 1935 WB_END 1936 1937 WB_ENTRY(jlong, WB_GetConstantPool(JNIEnv* env, jobject wb, jclass klass)) 1938 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass)); 1939 return (jlong) ik->constants(); 1940 WB_END 1941 1942 WB_ENTRY(jobjectArray, WB_GetResolvedReferences(JNIEnv* env, jobject wb, jclass klass)) 1943 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass)); 1944 objArrayOop resolved_refs= ik->constants()->resolved_references(); 1945 return (jobjectArray)JNIHandles::make_local(THREAD, resolved_refs); 1946 WB_END 1947 1948 WB_ENTRY(jint, WB_getFieldEntriesLength(JNIEnv* env, jobject wb, jclass klass)) 1949 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass)); 1950 ConstantPool* cp = ik->constants(); 1951 if (cp->cache() == nullptr) { 1952 return -1; 1953 } 1954 return cp->resolved_field_entries_length(); 1955 WB_END 1956 1957 WB_ENTRY(jint, WB_getFieldCPIndex(JNIEnv* env, jobject wb, jclass klass, jint index)) 1958 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass)); 1959 ConstantPool* cp = ik->constants(); 1960 if (cp->cache() == nullptr) { 1961 return -1; 1962 } 1963 return cp->resolved_field_entry_at(index)->constant_pool_index(); 1964 WB_END 1965 1966 WB_ENTRY(jint, WB_getMethodEntriesLength(JNIEnv* env, jobject wb, jclass klass)) 1967 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass)); 1968 ConstantPool* cp = ik->constants(); 1969 if (cp->cache() == nullptr) { 1970 return -1; 1971 } 1972 return cp->resolved_method_entries_length(); 1973 WB_END 1974 1975 WB_ENTRY(jint, WB_getMethodCPIndex(JNIEnv* env, jobject wb, jclass klass, jint index)) 1976 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass)); 1977 ConstantPool* cp = ik->constants(); 1978 if (cp->cache() == nullptr) { 1979 return -1; 1980 } 1981 return cp->resolved_method_entry_at(index)->constant_pool_index(); 1982 WB_END 1983 1984 WB_ENTRY(jint, WB_getIndyInfoLength(JNIEnv* env, jobject wb, jclass klass)) 1985 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass)); 1986 ConstantPool* cp = ik->constants(); 1987 if (cp->cache() == nullptr) { 1988 return -1; 1989 } 1990 return cp->resolved_indy_entries_length(); 1991 WB_END 1992 1993 WB_ENTRY(jint, WB_getIndyCPIndex(JNIEnv* env, jobject wb, jclass klass, jint index)) 1994 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(klass)); 1995 ConstantPool* cp = ik->constants(); 1996 if (cp->cache() == nullptr) { 1997 return -1; 1998 } 1999 return cp->resolved_indy_entry_at(index)->constant_pool_index(); 2000 WB_END 2001 2002 WB_ENTRY(jobject, WB_printClasses(JNIEnv* env, jobject wb, jstring class_name_pattern, jint flags)) 2003 ThreadToNativeFromVM ttnfv(thread); 2004 const char* c = env->GetStringUTFChars(class_name_pattern, nullptr); 2005 ResourceMark rm; 2006 stringStream st; 2007 { 2008 ThreadInVMfromNative ttvfn(thread); // back to VM 2009 ClassPrinter::print_classes(c, flags, &st); 2010 } 2011 jstring result = env->NewStringUTF(st.freeze()); 2012 CHECK_JNI_EXCEPTION_(env, nullptr); 2013 return result; 2014 WB_END 2015 2016 WB_ENTRY(jobject, WB_printMethods(JNIEnv* env, jobject wb, jstring class_name_pattern, jstring method_pattern, jint flags)) 2017 ThreadToNativeFromVM ttnfv(thread); 2018 const char* c = env->GetStringUTFChars(class_name_pattern, nullptr); 2019 const char* m = env->GetStringUTFChars(method_pattern, nullptr); 2020 ResourceMark rm; 2021 stringStream st; 2022 { 2023 ThreadInVMfromNative ttvfn(thread); // back to VM 2024 ClassPrinter::print_methods(c, m, flags, &st); 2025 } 2026 jstring result = env->NewStringUTF(st.freeze()); 2027 CHECK_JNI_EXCEPTION_(env, nullptr); 2028 return result; 2029 WB_END 2030 2031 WB_ENTRY(void, WB_ClearInlineCaches(JNIEnv* env, jobject wb, jboolean preserve_static_stubs)) 2032 VM_ClearICs clear_ics(preserve_static_stubs == JNI_TRUE); 2033 VMThread::execute(&clear_ics); 2034 WB_END 2035 2036 template <typename T> 2037 static bool GetMethodOption(JavaThread* thread, JNIEnv* env, jobject method, jstring name, T* value) { 2038 assert(value != nullptr, "sanity"); 2039 if (method == nullptr || name == nullptr) { 2040 return false; 2041 } 2042 jmethodID jmid = reflected_method_to_jmid(thread, env, method); 2043 CHECK_JNI_EXCEPTION_(env, false); 2044 methodHandle mh(thread, Method::checked_resolve_jmethod_id(jmid)); 2045 // can't be in VM when we call JNI 2046 ThreadToNativeFromVM ttnfv(thread); 2047 const char* flag_name = env->GetStringUTFChars(name, nullptr); 2048 CHECK_JNI_EXCEPTION_(env, false); 2049 CompileCommandEnum option = CompilerOracle::string_to_option(flag_name); 2050 env->ReleaseStringUTFChars(name, flag_name); 2051 if (option == CompileCommandEnum::Unknown) { 2052 return false; 2053 } 2054 if (!CompilerOracle::option_matches_type(option, *value)) { 2055 return false; 2056 } 2057 return CompilerOracle::has_option_value(mh, option, *value); 2058 } 2059 2060 WB_ENTRY(jobject, WB_GetMethodBooleaneOption(JNIEnv* env, jobject wb, jobject method, jstring name)) 2061 bool result; 2062 if (GetMethodOption<bool> (thread, env, method, name, &result)) { 2063 // can't be in VM when we call JNI 2064 ThreadToNativeFromVM ttnfv(thread); 2065 return booleanBox(thread, env, result); 2066 } 2067 return nullptr; 2068 WB_END 2069 2070 WB_ENTRY(jobject, WB_GetMethodIntxOption(JNIEnv* env, jobject wb, jobject method, jstring name)) 2071 intx result; 2072 if (GetMethodOption <intx> (thread, env, method, name, &result)) { 2073 // can't be in VM when we call JNI 2074 ThreadToNativeFromVM ttnfv(thread); 2075 return longBox(thread, env, result); 2076 } 2077 return nullptr; 2078 WB_END 2079 2080 WB_ENTRY(jobject, WB_GetMethodUintxOption(JNIEnv* env, jobject wb, jobject method, jstring name)) 2081 uintx result; 2082 if (GetMethodOption <uintx> (thread, env, method, name, &result)) { 2083 // can't be in VM when we call JNI 2084 ThreadToNativeFromVM ttnfv(thread); 2085 return longBox(thread, env, result); 2086 } 2087 return nullptr; 2088 WB_END 2089 2090 WB_ENTRY(jobject, WB_GetMethodDoubleOption(JNIEnv* env, jobject wb, jobject method, jstring name)) 2091 double result; 2092 if (GetMethodOption <double> (thread, env, method, name, &result)) { 2093 // can't be in VM when we call JNI 2094 ThreadToNativeFromVM ttnfv(thread); 2095 return doubleBox(thread, env, result); 2096 } 2097 return nullptr; 2098 WB_END 2099 2100 WB_ENTRY(jobject, WB_GetMethodStringOption(JNIEnv* env, jobject wb, jobject method, jstring name)) 2101 ccstr ccstrResult; 2102 if (GetMethodOption <ccstr> (thread, env, method, name, &ccstrResult)) { 2103 // can't be in VM when we call JNI 2104 ThreadToNativeFromVM ttnfv(thread); 2105 jstring result = env->NewStringUTF(ccstrResult); 2106 CHECK_JNI_EXCEPTION_(env, nullptr); 2107 return result; 2108 } 2109 return nullptr; 2110 WB_END 2111 2112 WB_ENTRY(jobject, WB_GetDefaultArchivePath(JNIEnv* env, jobject wb)) 2113 const char* p = CDSConfig::default_archive_path(); 2114 ThreadToNativeFromVM ttn(thread); 2115 jstring path_string = env->NewStringUTF(p); 2116 2117 CHECK_JNI_EXCEPTION_(env, nullptr); 2118 2119 return path_string; 2120 WB_END 2121 2122 WB_ENTRY(jboolean, WB_IsSharingEnabled(JNIEnv* env, jobject wb)) 2123 return CDSConfig::is_using_archive(); 2124 WB_END 2125 2126 WB_ENTRY(jint, WB_GetCDSGenericHeaderMinVersion(JNIEnv* env, jobject wb)) 2127 #if INCLUDE_CDS 2128 return (jint)CDS_GENERIC_HEADER_SUPPORTED_MIN_VERSION; 2129 #else 2130 ShouldNotReachHere(); 2131 return (jint)-1; 2132 #endif 2133 WB_END 2134 2135 WB_ENTRY(jint, WB_GetCDSCurrentVersion(JNIEnv* env, jobject wb)) 2136 #if INCLUDE_CDS 2137 return (jint)CURRENT_CDS_ARCHIVE_VERSION; 2138 #else 2139 ShouldNotReachHere(); 2140 return (jint)-1; 2141 #endif 2142 WB_END 2143 2144 WB_ENTRY(jboolean, WB_CDSMemoryMappingFailed(JNIEnv* env, jobject wb)) 2145 return FileMapInfo::memory_mapping_failed(); 2146 WB_END 2147 2148 WB_ENTRY(jboolean, WB_IsSharedInternedString(JNIEnv* env, jobject wb, jobject str)) 2149 ResourceMark rm(THREAD); 2150 oop str_oop = JNIHandles::resolve(str); 2151 int length; 2152 jchar* chars = java_lang_String::as_unicode_string(str_oop, length, CHECK_(false)); 2153 return StringTable::lookup_shared(chars, length) == str_oop; 2154 WB_END 2155 2156 WB_ENTRY(jboolean, WB_IsSharedClass(JNIEnv* env, jobject wb, jclass clazz)) 2157 return (jboolean)AOTMetaspace::in_aot_cache(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); 2158 WB_END 2159 2160 WB_ENTRY(jboolean, WB_AreSharedStringsMapped(JNIEnv* env)) 2161 return ArchiveHeapLoader::is_mapped(); 2162 WB_END 2163 2164 WB_ENTRY(void, WB_LinkClass(JNIEnv* env, jobject wb, jclass clazz)) 2165 Klass *k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)); 2166 if (!k->is_instance_klass()) { 2167 return; 2168 } 2169 InstanceKlass *ik = InstanceKlass::cast(k); 2170 ik->link_class(THREAD); // may throw verification error 2171 WB_END 2172 2173 WB_ENTRY(jboolean, WB_AreOpenArchiveHeapObjectsMapped(JNIEnv* env)) 2174 return ArchiveHeapLoader::is_mapped(); 2175 WB_END 2176 2177 WB_ENTRY(jboolean, WB_IsCDSIncluded(JNIEnv* env)) 2178 #if INCLUDE_CDS 2179 // An exploded build inhibits use of CDS. Therefore, for the 2180 // purpose of testing, the JVM can be treated as not having CDS 2181 // built in at all. 2182 return ClassLoader::has_jrt_entry(); 2183 #else 2184 return false; 2185 #endif // INCLUDE_CDS 2186 WB_END 2187 2188 WB_ENTRY(jboolean, WB_isC2OrJVMCIIncluded(JNIEnv* env)) 2189 #if COMPILER2_OR_JVMCI 2190 return true; 2191 #else 2192 return false; 2193 #endif 2194 WB_END 2195 2196 WB_ENTRY(jboolean, WB_IsJVMCISupportedByGC(JNIEnv* env)) 2197 #if INCLUDE_JVMCI 2198 return JVMCIGlobals::gc_supports_jvmci(); 2199 #else 2200 return false; 2201 #endif 2202 WB_END 2203 2204 WB_ENTRY(jboolean, WB_CanWriteJavaHeapArchive(JNIEnv* env)) 2205 return !CDSConfig::are_vm_options_incompatible_with_dumping_heap(); 2206 WB_END 2207 2208 2209 WB_ENTRY(jboolean, WB_IsJFRIncluded(JNIEnv* env)) 2210 #if INCLUDE_JFR 2211 return true; 2212 #else 2213 return false; 2214 #endif // INCLUDE_JFR 2215 WB_END 2216 2217 WB_ENTRY(jboolean, WB_IsDTraceIncluded(JNIEnv* env)) 2218 #if defined(DTRACE_ENABLED) 2219 return true; 2220 #else 2221 return false; 2222 #endif // DTRACE_ENABLED 2223 WB_END 2224 2225 #if INCLUDE_CDS 2226 2227 WB_ENTRY(jint, WB_GetCDSOffsetForName(JNIEnv* env, jobject o, jstring name)) 2228 ResourceMark rm; 2229 char* c_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name)); 2230 jint result = (jint)CDSConstants::get_cds_offset(c_name); 2231 return result; 2232 WB_END 2233 2234 WB_ENTRY(jint, WB_GetCDSConstantForName(JNIEnv* env, jobject o, jstring name)) 2235 ResourceMark rm; 2236 char* c_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name)); 2237 jint result = (jint)CDSConstants::get_cds_constant(c_name); 2238 return result; 2239 WB_END 2240 2241 #endif // INCLUDE_CDS 2242 2243 WB_ENTRY(jboolean, WB_HandshakeReadMonitors(JNIEnv* env, jobject wb, jobject thread_handle)) 2244 class ReadMonitorsHandshakeClosure : public HandshakeClosure { 2245 jboolean _executed; 2246 2247 void do_thread(Thread* th) { 2248 JavaThread* jt = JavaThread::cast(th); 2249 ResourceMark rm; 2250 2251 GrowableArray<MonitorInfo*>* info = new GrowableArray<MonitorInfo*>(); 2252 2253 if (!jt->has_last_Java_frame()) { 2254 return; 2255 } 2256 RegisterMap rmap(jt, 2257 RegisterMap::UpdateMap::include, 2258 RegisterMap::ProcessFrames::include, 2259 RegisterMap::WalkContinuation::skip); 2260 for (javaVFrame* vf = jt->last_java_vframe(&rmap); vf != nullptr; vf = vf->java_sender()) { 2261 GrowableArray<MonitorInfo*> *monitors = vf->monitors(); 2262 if (monitors != nullptr) { 2263 int len = monitors->length(); 2264 // Walk monitors youngest to oldest 2265 for (int i = len - 1; i >= 0; i--) { 2266 MonitorInfo* mon_info = monitors->at(i); 2267 if (mon_info->eliminated()) continue; 2268 oop owner = mon_info->owner(); 2269 if (owner != nullptr) { 2270 info->append(mon_info); 2271 } 2272 } 2273 } 2274 } 2275 _executed = true; 2276 } 2277 2278 public: 2279 ReadMonitorsHandshakeClosure() : HandshakeClosure("WB_HandshakeReadMonitors"), _executed(false) {} 2280 jboolean executed() const { return _executed; } 2281 }; 2282 2283 ReadMonitorsHandshakeClosure rmhc; 2284 if (thread_handle != nullptr) { 2285 ThreadsListHandle tlh; 2286 JavaThread* target = nullptr; 2287 bool is_alive = tlh.cv_internal_thread_to_JavaThread(thread_handle, &target, nullptr); 2288 if (is_alive) { 2289 Handshake::execute(&rmhc, &tlh, target); 2290 } 2291 } 2292 return rmhc.executed(); 2293 WB_END 2294 2295 WB_ENTRY(jint, WB_HandshakeWalkStack(JNIEnv* env, jobject wb, jobject thread_handle, jboolean all_threads)) 2296 class TraceSelfHandshakeClosure : public HandshakeClosure { 2297 jint _num_threads_completed; 2298 2299 void do_thread(Thread* th) { 2300 JavaThread* jt = JavaThread::cast(th); 2301 ResourceMark rm; 2302 2303 jt->print_on(tty); 2304 jt->print_stack_on(tty); 2305 tty->cr(); 2306 AtomicAccess::inc(&_num_threads_completed); 2307 } 2308 2309 public: 2310 TraceSelfHandshakeClosure(Thread* thread) : HandshakeClosure("WB_TraceSelf"), _num_threads_completed(0) {} 2311 2312 jint num_threads_completed() const { return _num_threads_completed; } 2313 }; 2314 TraceSelfHandshakeClosure tshc(Thread::current()); 2315 2316 if (all_threads) { 2317 Handshake::execute(&tshc); 2318 } else if (thread_handle != nullptr) { 2319 ThreadsListHandle tlh; 2320 JavaThread* target = nullptr; 2321 bool is_alive = tlh.cv_internal_thread_to_JavaThread(thread_handle, &target, nullptr); 2322 if (is_alive) { 2323 Handshake::execute(&tshc, &tlh, target); 2324 } 2325 } 2326 return tshc.num_threads_completed(); 2327 WB_END 2328 2329 WB_ENTRY(void, WB_AsyncHandshakeWalkStack(JNIEnv* env, jobject wb, jobject thread_handle)) 2330 class TraceSelfHandshakeClosure : public AsyncHandshakeClosure { 2331 JavaThread* _self; 2332 void do_thread(Thread* th) { 2333 assert(th->is_Java_thread(), "sanity"); 2334 // AsynchHandshake handshakes are only executed by target. 2335 assert(_self == th, "Must be"); 2336 assert(Thread::current() == th, "Must be"); 2337 JavaThread* jt = JavaThread::cast(th); 2338 ResourceMark rm; 2339 jt->print_on(tty); 2340 jt->print_stack_on(tty); 2341 tty->cr(); 2342 } 2343 2344 public: 2345 TraceSelfHandshakeClosure(JavaThread* self_target) : AsyncHandshakeClosure("WB_TraceSelf"), _self(self_target) {} 2346 }; 2347 if (thread_handle != nullptr) { 2348 ThreadsListHandle tlh; 2349 JavaThread* target = nullptr; 2350 bool is_alive = tlh.cv_internal_thread_to_JavaThread(thread_handle, &target, nullptr); 2351 if (is_alive) { 2352 TraceSelfHandshakeClosure* tshc = new TraceSelfHandshakeClosure(target); 2353 Handshake::execute(tshc, target); 2354 } 2355 } 2356 WB_END 2357 2358 static volatile int _emulated_lock = 0; 2359 2360 WB_ENTRY(void, WB_LockAndBlock(JNIEnv* env, jobject wb, jboolean suspender)) 2361 JavaThread* self = JavaThread::current(); 2362 2363 { 2364 // Before trying to acquire the lock transition into a safepoint safe state. 2365 // Otherwise if either suspender or suspendee blocks for a safepoint 2366 // in ~ThreadBlockInVM the other one could loop forever trying to acquire 2367 // the lock without allowing the safepoint to progress. 2368 ThreadBlockInVM tbivm(self); 2369 2370 // We will deadlock here if we are 'suspender' and 'suspendee' 2371 // suspended in ~ThreadBlockInVM. This verifies we only suspend 2372 // at the right place. 2373 while (AtomicAccess::cmpxchg(&_emulated_lock, 0, 1) != 0) {} 2374 assert(_emulated_lock == 1, "Must be locked"); 2375 2376 // Sleep much longer in suspendee to force situation where 2377 // 'suspender' is waiting above to acquire lock. 2378 os::naked_short_sleep(suspender ? 1 : 10); 2379 } 2380 AtomicAccess::store(&_emulated_lock, 0); 2381 WB_END 2382 2383 // Some convenience methods to deal with objects from java 2384 int WhiteBox::offset_for_field(const char* field_name, oop object, 2385 Symbol* signature_symbol) { 2386 assert(field_name != nullptr && strlen(field_name) > 0, "Field name not valid"); 2387 2388 //Only non-array oops have fields. Don't call this function on arrays! 2389 InstanceKlass* ik = InstanceKlass::cast(object->klass()); 2390 2391 //Create symbols to look for in the class 2392 TempNewSymbol name_symbol = SymbolTable::new_symbol(field_name); 2393 2394 //To be filled in with an offset of the field we're looking for 2395 fieldDescriptor fd; 2396 2397 Klass* res = ik->find_field(name_symbol, signature_symbol, &fd); 2398 if (res == nullptr) { 2399 tty->print_cr("Invalid layout of %s at %s", ik->external_name(), 2400 name_symbol->as_C_string()); 2401 vm_exit_during_initialization("Invalid layout of preloaded class: use -Xlog:class+load=info to see the origin of the problem class"); 2402 } 2403 2404 //fetch the field at the offset we've found 2405 int dest_offset = fd.offset(); 2406 2407 return dest_offset; 2408 } 2409 2410 2411 const char* WhiteBox::lookup_jstring(const char* field_name, oop object) { 2412 int offset = offset_for_field(field_name, object, 2413 vmSymbols::string_signature()); 2414 oop string = object->obj_field(offset); 2415 if (string == nullptr) { 2416 return nullptr; 2417 } 2418 const char* ret = java_lang_String::as_utf8_string(string); 2419 return ret; 2420 } 2421 2422 bool WhiteBox::lookup_bool(const char* field_name, oop object) { 2423 int offset = 2424 offset_for_field(field_name, object, vmSymbols::bool_signature()); 2425 bool ret = (object->bool_field(offset) == JNI_TRUE); 2426 return ret; 2427 } 2428 2429 void WhiteBox::register_methods(JNIEnv* env, jclass wbclass, JavaThread* thread, JNINativeMethod* method_array, int method_count) { 2430 ResourceMark rm; 2431 Klass* klass = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(wbclass)); 2432 const char* klass_name = klass->external_name(); 2433 2434 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 2435 2436 // one by one registration natives for exception catching 2437 jclass no_such_method_error_klass = env->FindClass(vmSymbols::java_lang_NoSuchMethodError()->as_C_string()); 2438 CHECK_JNI_EXCEPTION(env); 2439 for (int i = 0, n = method_count; i < n; ++i) { 2440 // Skip dummy entries 2441 if (method_array[i].fnPtr == nullptr) continue; 2442 if (env->RegisterNatives(wbclass, &method_array[i], 1) != 0) { 2443 jthrowable throwable_obj = env->ExceptionOccurred(); 2444 if (throwable_obj != nullptr) { 2445 env->ExceptionClear(); 2446 if (env->IsInstanceOf(throwable_obj, no_such_method_error_klass)) { 2447 // NoSuchMethodError is thrown when a method can't be found or a method is not native. 2448 // Ignoring the exception since it is not preventing use of other WhiteBox methods. 2449 tty->print_cr("Warning: 'NoSuchMethodError' on register of %s::%s%s", 2450 klass_name, method_array[i].name, method_array[i].signature); 2451 } 2452 } else { 2453 // Registration failed unexpectedly. 2454 tty->print_cr("Warning: unexpected error on register of %s::%s%s. All methods will be unregistered", 2455 klass_name, method_array[i].name, method_array[i].signature); 2456 env->UnregisterNatives(wbclass); 2457 break; 2458 } 2459 } 2460 } 2461 } 2462 2463 WB_ENTRY(jint, WB_AddCompilerDirective(JNIEnv* env, jobject o, jstring compDirect)) 2464 // can't be in VM when we call JNI 2465 ThreadToNativeFromVM ttnfv(thread); 2466 const char* dir = env->GetStringUTFChars(compDirect, nullptr); 2467 CHECK_JNI_EXCEPTION_(env, 0); 2468 int ret; 2469 { 2470 ThreadInVMfromNative ttvfn(thread); // back to VM 2471 ret = DirectivesParser::parse_string(dir, tty); 2472 } 2473 env->ReleaseStringUTFChars(compDirect, dir); 2474 // -1 for error parsing directive. Return 0 as number of directives added. 2475 if (ret == -1) { 2476 ret = 0; 2477 } 2478 return (jint) ret; 2479 WB_END 2480 2481 WB_ENTRY(void, WB_RemoveCompilerDirective(JNIEnv* env, jobject o, jint count)) 2482 DirectivesStack::pop(count); 2483 WB_END 2484 2485 // Checks that the library libfile has the noexecstack bit set. 2486 WB_ENTRY(jboolean, WB_CheckLibSpecifiesNoexecstack(JNIEnv* env, jobject o, jstring libfile)) 2487 jboolean ret = false; 2488 #ifdef LINUX 2489 // Can't be in VM when we call JNI. 2490 ThreadToNativeFromVM ttnfv(thread); 2491 const char* lf = env->GetStringUTFChars(libfile, nullptr); 2492 CHECK_JNI_EXCEPTION_(env, 0); 2493 ret = (jboolean) ElfFile::specifies_noexecstack(lf); 2494 env->ReleaseStringUTFChars(libfile, lf); 2495 #endif 2496 return ret; 2497 WB_END 2498 2499 WB_ENTRY(jboolean, WB_IsContainerized(JNIEnv* env, jobject o)) 2500 LINUX_ONLY(return OSContainer::is_containerized();) 2501 return false; 2502 WB_END 2503 2504 // Physical memory of the host machine (including containers) 2505 WB_ENTRY(jlong, WB_HostPhysicalMemory(JNIEnv* env, jobject o)) 2506 LINUX_ONLY(return static_cast<jlong>(os::Linux::physical_memory());) 2507 return static_cast<jlong>(os::physical_memory()); 2508 WB_END 2509 2510 // Available memory of the host machine (container-aware) 2511 WB_ENTRY(jlong, WB_HostAvailableMemory(JNIEnv* env, jobject o)) 2512 size_t avail_mem = 0; 2513 // Return value ignored - defaulting to 0 on failure. 2514 (void)os::available_memory(avail_mem); 2515 return static_cast<jlong>(avail_mem); 2516 WB_END 2517 2518 // Physical swap of the host machine (including containers), Linux only. 2519 WB_ENTRY(jlong, WB_HostPhysicalSwap(JNIEnv* env, jobject o)) 2520 LINUX_ONLY(return (jlong)os::Linux::host_swap();) 2521 return -1; // Not used/implemented on other platforms 2522 WB_END 2523 2524 WB_ENTRY(jint, WB_ValidateCgroup(JNIEnv* env, 2525 jobject o, 2526 jboolean cgroups_v2_enabled, 2527 jstring controllers_file, 2528 jstring proc_self_cgroup, 2529 jstring proc_self_mountinfo)) 2530 jint ret = 0; 2531 #ifdef LINUX 2532 ThreadToNativeFromVM ttnfv(thread); 2533 const char* c_file = env->GetStringUTFChars(controllers_file, nullptr); 2534 CHECK_JNI_EXCEPTION_(env, 0); 2535 const char* p_s_cgroup = env->GetStringUTFChars(proc_self_cgroup, nullptr); 2536 CHECK_JNI_EXCEPTION_(env, 0); 2537 const char* p_s_mountinfo = env->GetStringUTFChars(proc_self_mountinfo, nullptr); 2538 CHECK_JNI_EXCEPTION_(env, 0); 2539 u1 cg_type_flags = 0; 2540 // This sets cg_type_flags 2541 WhiteBox::validate_cgroup(cgroups_v2_enabled, c_file, p_s_cgroup, p_s_mountinfo, &cg_type_flags); 2542 ret = (jint)cg_type_flags; 2543 env->ReleaseStringUTFChars(controllers_file, c_file); 2544 env->ReleaseStringUTFChars(proc_self_cgroup, p_s_cgroup); 2545 env->ReleaseStringUTFChars(proc_self_mountinfo, p_s_mountinfo); 2546 #endif 2547 return ret; 2548 WB_END 2549 2550 // Available cpus of the host machine, Linux only. 2551 // Used in container testing. 2552 WB_ENTRY(jint, WB_HostCPUs(JNIEnv* env, jobject o)) 2553 LINUX_ONLY(return os::Linux::active_processor_count();) 2554 return -1; // Not used/implemented on other platforms 2555 WB_END 2556 2557 WB_ENTRY(void, WB_PrintOsInfo(JNIEnv* env, jobject o)) 2558 os::print_os_info(tty); 2559 WB_END 2560 2561 // Elf decoder 2562 WB_ENTRY(void, WB_DisableElfSectionCache(JNIEnv* env)) 2563 #if !defined(_WINDOWS) && !defined(__APPLE__) && !defined(_AIX) 2564 ElfFile::_do_not_cache_elf_section = true; 2565 #endif 2566 WB_END 2567 2568 WB_ENTRY(jlong, WB_ResolvedMethodItemsCount(JNIEnv* env, jobject o)) 2569 return (jlong) ResolvedMethodTable::items_count(); 2570 WB_END 2571 2572 WB_ENTRY(jint, WB_GetKlassMetadataSize(JNIEnv* env, jobject wb, jclass mirror)) 2573 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(mirror)); 2574 // Return size in bytes. 2575 return k->size() * wordSize; 2576 WB_END 2577 2578 // See test/hotspot/jtreg/runtime/Thread/ThreadObjAccessAtExit.java. 2579 // It explains how the thread's priority field is used for test state coordination. 2580 // 2581 WB_ENTRY(void, WB_CheckThreadObjOfTerminatingThread(JNIEnv* env, jobject wb, jobject target_handle)) 2582 oop target_oop = JNIHandles::resolve_non_null(target_handle); 2583 jlong tid = java_lang_Thread::thread_id(target_oop); 2584 JavaThread* target = java_lang_Thread::thread(target_oop); 2585 2586 // Grab a ThreadsListHandle to protect the target thread whilst terminating 2587 ThreadsListHandle tlh; 2588 2589 // Look up the target thread by tid to ensure it is present 2590 JavaThread* t = tlh.list()->find_JavaThread_from_java_tid(tid); 2591 if (t == nullptr) { 2592 THROW_MSG(vmSymbols::java_lang_RuntimeException(), "Target thread not found in ThreadsList!"); 2593 } 2594 2595 tty->print_cr("WB_CheckThreadObjOfTerminatingThread: target thread is protected"); 2596 // Allow target to terminate by boosting priority 2597 java_lang_Thread::set_priority(t->threadObj(), ThreadPriority(NormPriority + 1)); 2598 2599 // Now wait for the target to terminate 2600 while (!target->is_terminated()) { 2601 ThreadBlockInVM tbivm(thread); // just in case target is involved in a safepoint 2602 os::naked_short_sleep(0); 2603 } 2604 2605 tty->print_cr("WB_CheckThreadObjOfTerminatingThread: target thread is terminated"); 2606 2607 // Now release the GC inducing thread - we have to re-resolve the external oop that 2608 // was passed in as GC may have occurred and we don't know if we can trust t->threadObj() now. 2609 oop original = JNIHandles::resolve_non_null(target_handle); 2610 java_lang_Thread::set_priority(original, ThreadPriority(NormPriority + 2)); 2611 2612 tty->print_cr("WB_CheckThreadObjOfTerminatingThread: GC has been initiated - checking threadObj:"); 2613 2614 // The Java code should be creating garbage and triggering GC, which would potentially move 2615 // the threadObj oop. If the exiting thread is properly protected then its threadObj should 2616 // remain valid and equal to our initial target_handle. Loop a few times to give GC a chance to 2617 // kick in. 2618 for (int i = 0; i < 5; i++) { 2619 oop original = JNIHandles::resolve_non_null(target_handle); 2620 oop current = t->threadObj(); 2621 if (original != current) { 2622 tty->print_cr("WB_CheckThreadObjOfTerminatingThread: failed comparison on iteration %d", i); 2623 THROW_MSG(vmSymbols::java_lang_RuntimeException(), "Target thread oop has changed!"); 2624 } else { 2625 tty->print_cr("WB_CheckThreadObjOfTerminatingThread: successful comparison on iteration %d", i); 2626 ThreadBlockInVM tbivm(thread); 2627 os::naked_short_sleep(50); 2628 } 2629 } 2630 WB_END 2631 2632 WB_ENTRY(void, WB_VerifyFrames(JNIEnv* env, jobject wb, jboolean log, jboolean update_map)) 2633 ResourceMark rm; // for verify 2634 stringStream st; 2635 for (StackFrameStream fst(JavaThread::current(), update_map, true); !fst.is_done(); fst.next()) { 2636 frame* current_frame = fst.current(); 2637 if (log) { 2638 current_frame->print_value_on(&st); 2639 } 2640 current_frame->verify(fst.register_map()); 2641 } 2642 if (log) { 2643 tty->print_cr("[WhiteBox::VerifyFrames] Walking Frames"); 2644 tty->print_raw(st.freeze()); 2645 tty->print_cr("[WhiteBox::VerifyFrames] Done"); 2646 } 2647 WB_END 2648 2649 WB_ENTRY(jboolean, WB_IsJVMTIIncluded(JNIEnv* env, jobject wb)) 2650 #if INCLUDE_JVMTI 2651 return JNI_TRUE; 2652 #else 2653 return JNI_FALSE; 2654 #endif 2655 WB_END 2656 2657 WB_ENTRY(void, WB_WaitUnsafe(JNIEnv* env, jobject wb, jint time)) 2658 os::naked_short_sleep(time); 2659 WB_END 2660 2661 WB_ENTRY(void, WB_BusyWait(JNIEnv* env, jobject wb, jint time)) 2662 ThreadToNativeFromVM ttn(thread); 2663 u8 start = os::current_thread_cpu_time(); 2664 u8 target_duration = time * (u8)1000000; 2665 while (os::current_thread_cpu_time() - start < target_duration) { 2666 for (volatile int i = 0; i < 1000000; i++); 2667 } 2668 WB_END 2669 2670 WB_ENTRY(jboolean, WB_CPUSamplerSetOutOfStackWalking(JNIEnv* env, jobject wb, jboolean enable)) 2671 #if defined(ASSERT) && INCLUDE_JFR && defined(LINUX) 2672 JfrCPUTimeThreadSampling::set_out_of_stack_walking_enabled(enable == JNI_TRUE); 2673 return JNI_TRUE; 2674 #else 2675 return JNI_FALSE; 2676 #endif 2677 WB_END 2678 2679 WB_ENTRY(jlong, WB_CPUSamplerOutOfStackWalkingIterations(JNIEnv* env, jobject wb)) 2680 #if defined(ASSERT) && INCLUDE_JFR && defined(LINUX) 2681 return (jlong)JfrCPUTimeThreadSampling::out_of_stack_walking_iterations(); 2682 #else 2683 return 0; 2684 #endif 2685 WB_END 2686 2687 WB_ENTRY(jstring, WB_GetLibcName(JNIEnv* env, jobject o)) 2688 ThreadToNativeFromVM ttn(thread); 2689 jstring info_string = env->NewStringUTF(XSTR(LIBC)); 2690 CHECK_JNI_EXCEPTION_(env, nullptr); 2691 return info_string; 2692 WB_END 2693 2694 WB_ENTRY(void, WB_PinObject(JNIEnv* env, jobject wb, jobject o)) 2695 #if INCLUDE_G1GC 2696 if (!UseG1GC) { 2697 ShouldNotReachHere(); 2698 return; 2699 } 2700 oop obj = JNIHandles::resolve(o); 2701 G1CollectedHeap::heap()->pin_object(thread, obj); 2702 #else 2703 ShouldNotReachHere(); 2704 #endif // INCLUDE_G1GC 2705 WB_END 2706 2707 WB_ENTRY(void, WB_UnpinObject(JNIEnv* env, jobject wb, jobject o)) 2708 #if INCLUDE_G1GC 2709 if (!UseG1GC) { 2710 ShouldNotReachHere(); 2711 return; 2712 } 2713 oop obj = JNIHandles::resolve(o); 2714 G1CollectedHeap::heap()->unpin_object(thread, obj); 2715 #else 2716 ShouldNotReachHere(); 2717 #endif // INCLUDE_G1GC 2718 WB_END 2719 2720 WB_ENTRY(jboolean, WB_SetVirtualThreadsNotifyJvmtiMode(JNIEnv* env, jobject wb, jboolean enable)) 2721 if (!Continuations::enabled()) { 2722 tty->print_cr("WB error: must be Continuations::enabled()!"); 2723 return JNI_FALSE; 2724 } 2725 jboolean result = false; 2726 #if INCLUDE_JVMTI 2727 if (enable) { 2728 result = JvmtiEnvBase::enable_virtual_threads_notify_jvmti(); 2729 } else { 2730 result = JvmtiEnvBase::disable_virtual_threads_notify_jvmti(); 2731 } 2732 #endif 2733 return result; 2734 WB_END 2735 2736 WB_ENTRY(void, WB_PreTouchMemory(JNIEnv* env, jobject wb, jlong addr, jlong size)) 2737 void* const from = (void*)addr; 2738 void* const to = (void*)(addr + size); 2739 if (from > to) { 2740 os::pretouch_memory(from, to, os::vm_page_size()); 2741 } 2742 WB_END 2743 2744 WB_ENTRY(void, WB_CleanMetaspaces(JNIEnv* env, jobject target)) 2745 ClassLoaderDataGraph::safepoint_and_clean_metaspaces(); 2746 WB_END 2747 2748 // Reports resident set size (RSS) in bytes 2749 WB_ENTRY(jlong, WB_Rss(JNIEnv* env, jobject o)) 2750 return os::rss(); 2751 WB_END 2752 2753 WB_ENTRY(void, WB_ControlledCrash(JNIEnv* env, jobject o, jint how)) 2754 #ifdef ASSERT 2755 VMError::controlled_crash(how); 2756 #else 2757 THROW_MSG(vmSymbols::java_lang_UnsupportedOperationException(), "Only available in debug builds"); 2758 #endif 2759 WB_END 2760 2761 #define CC (char*) 2762 2763 static JNINativeMethod methods[] = { 2764 {CC"getObjectAddress0", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectAddress }, 2765 {CC"getObjectSize0", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectSize }, 2766 {CC"isObjectInOldGen0", CC"(Ljava/lang/Object;)Z", (void*)&WB_isObjectInOldGen }, 2767 {CC"getHeapOopSize", CC"()I", (void*)&WB_GetHeapOopSize }, 2768 {CC"getVMPageSize", CC"()I", (void*)&WB_GetVMPageSize }, 2769 {CC"getVMAllocationGranularity", CC"()J", (void*)&WB_GetVMAllocationGranularity }, 2770 {CC"getVMLargePageSize", CC"()J", (void*)&WB_GetVMLargePageSize}, 2771 {CC"getHeapSpaceAlignment", CC"()J", (void*)&WB_GetHeapSpaceAlignment}, 2772 {CC"getHeapAlignment", CC"()J", (void*)&WB_GetHeapAlignment}, 2773 {CC"countAliveClasses0", CC"(Ljava/lang/String;)I", (void*)&WB_CountAliveClasses }, 2774 {CC"getSymbolRefcount", CC"(Ljava/lang/String;)I", (void*)&WB_GetSymbolRefcount }, 2775 {CC"parseCommandLine0", 2776 CC"(Ljava/lang/String;C[Ljdk/test/whitebox/parser/DiagnosticCommand;)[Ljava/lang/Object;", 2777 (void*) &WB_ParseCommandLine 2778 }, 2779 {CC"addToBootstrapClassLoaderSearch0", CC"(Ljava/lang/String;)V", 2780 (void*)&WB_AddToBootstrapClassLoaderSearch}, 2781 {CC"addToSystemClassLoaderSearch0", CC"(Ljava/lang/String;)V", 2782 (void*)&WB_AddToSystemClassLoaderSearch}, 2783 {CC"getCompressedOopsMaxHeapSize", CC"()J", 2784 (void*)&WB_GetCompressedOopsMaxHeapSize}, 2785 {CC"printHeapSizes", CC"()V", (void*)&WB_PrintHeapSizes }, 2786 {CC"readFromNoaccessArea",CC"()V", (void*)&WB_ReadFromNoaccessArea}, 2787 {CC"decodeNKlassAndAccessKlass",CC"(I)V", (void*)&WB_DecodeNKlassAndAccessKlass}, 2788 {CC"stressVirtualSpaceResize",CC"(JJJ)I", (void*)&WB_StressVirtualSpaceResize}, 2789 #if INCLUDE_CDS 2790 {CC"getCDSOffsetForName0", CC"(Ljava/lang/String;)I", (void*)&WB_GetCDSOffsetForName}, 2791 {CC"getCDSConstantForName0", CC"(Ljava/lang/String;)I", (void*)&WB_GetCDSConstantForName}, 2792 #endif 2793 #if INCLUDE_G1GC 2794 {CC"g1InConcurrentMark", CC"()Z", (void*)&WB_G1InConcurrentMark}, 2795 {CC"g1CompletedConcurrentMarkCycles", CC"()I", (void*)&WB_G1CompletedConcurrentMarkCycles}, 2796 {CC"g1IsHumongous0", CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous }, 2797 {CC"g1BelongsToHumongousRegion0", CC"(J)Z", (void*)&WB_G1BelongsToHumongousRegion}, 2798 {CC"g1BelongsToFreeRegion0", CC"(J)Z", (void*)&WB_G1BelongsToFreeRegion}, 2799 {CC"g1NumMaxRegions", CC"()J", (void*)&WB_G1NumMaxRegions }, 2800 {CC"g1NumFreeRegions", CC"()J", (void*)&WB_G1NumFreeRegions }, 2801 {CC"g1RegionSize", CC"()I", (void*)&WB_G1RegionSize }, 2802 {CC"g1HasRegionsToUncommit", CC"()Z", (void*)&WB_G1HasRegionsToUncommit}, 2803 {CC"g1AuxiliaryMemoryUsage", CC"()Ljava/lang/management/MemoryUsage;", 2804 (void*)&WB_G1AuxiliaryMemoryUsage }, 2805 {CC"g1ActiveMemoryNodeCount", CC"()I", (void*)&WB_G1ActiveMemoryNodeCount }, 2806 {CC"g1MemoryNodeIds", CC"()[I", (void*)&WB_G1MemoryNodeIds }, 2807 {CC"g1GetMixedGCInfo", CC"(I)[J", (void*)&WB_G1GetMixedGCInfo }, 2808 #endif // INCLUDE_G1GC 2809 {CC"NMTMalloc", CC"(J)J", (void*)&WB_NMTMalloc }, 2810 {CC"NMTMallocWithPseudoStack", CC"(JI)J", (void*)&WB_NMTMallocWithPseudoStack}, 2811 {CC"NMTMallocWithPseudoStackAndType", CC"(JII)J", (void*)&WB_NMTMallocWithPseudoStackAndType}, 2812 {CC"NMTFree", CC"(J)V", (void*)&WB_NMTFree }, 2813 {CC"NMTReserveMemory", CC"(J)J", (void*)&WB_NMTReserveMemory }, 2814 {CC"NMTAttemptReserveMemoryAt", CC"(JJ)J", (void*)&WB_NMTAttemptReserveMemoryAt }, 2815 {CC"NMTCommitMemory", CC"(JJ)V", (void*)&WB_NMTCommitMemory }, 2816 {CC"NMTUncommitMemory", CC"(JJ)V", (void*)&WB_NMTUncommitMemory }, 2817 {CC"NMTReleaseMemory", CC"(JJ)V", (void*)&WB_NMTReleaseMemory }, 2818 {CC"NMTGetHashSize", CC"()I", (void*)&WB_NMTGetHashSize }, 2819 {CC"NMTNewArena", CC"(J)J", (void*)&WB_NMTNewArena }, 2820 {CC"NMTFreeArena", CC"(J)V", (void*)&WB_NMTFreeArena }, 2821 {CC"NMTArenaMalloc", CC"(JJ)V", (void*)&WB_NMTArenaMalloc }, 2822 {CC"deoptimizeFrames", CC"(Z)I", (void*)&WB_DeoptimizeFrames }, 2823 {CC"isFrameDeoptimized", CC"(I)Z", (void*)&WB_IsFrameDeoptimized}, 2824 {CC"deoptimizeAll", CC"()V", (void*)&WB_DeoptimizeAll }, 2825 {CC"deoptimizeMethod0", CC"(Ljava/lang/reflect/Executable;Z)I", 2826 (void*)&WB_DeoptimizeMethod }, 2827 {CC"isMethodCompiled0", CC"(Ljava/lang/reflect/Executable;Z)Z", 2828 (void*)&WB_IsMethodCompiled }, 2829 {CC"isMethodCompilable0", CC"(Ljava/lang/reflect/Executable;IZ)Z", 2830 (void*)&WB_IsMethodCompilable}, 2831 {CC"isMethodQueuedForCompilation0", 2832 CC"(Ljava/lang/reflect/Executable;)Z", (void*)&WB_IsMethodQueuedForCompilation}, 2833 {CC"isIntrinsicAvailable0", 2834 CC"(Ljava/lang/reflect/Executable;Ljava/lang/reflect/Executable;I)Z", 2835 (void*)&WB_IsIntrinsicAvailable}, 2836 {CC"makeMethodNotCompilable0", 2837 CC"(Ljava/lang/reflect/Executable;IZ)V", (void*)&WB_MakeMethodNotCompilable}, 2838 {CC"testSetDontInlineMethod0", 2839 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetDontInlineMethod}, 2840 {CC"getMethodCompilationLevel0", 2841 CC"(Ljava/lang/reflect/Executable;Z)I", (void*)&WB_GetMethodCompilationLevel}, 2842 {CC"getMethodDecompileCount0", 2843 CC"(Ljava/lang/reflect/Executable;)I", (void*)&WB_GetMethodDecompileCount}, 2844 {CC"getMethodTrapCount0", 2845 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)I", 2846 (void*)&WB_GetMethodTrapCount}, 2847 {CC"getDeoptCount0", 2848 CC"(Ljava/lang/String;Ljava/lang/String;)I", (void*)&WB_GetDeoptCount}, 2849 {CC"getMethodEntryBci0", 2850 CC"(Ljava/lang/reflect/Executable;)I", (void*)&WB_GetMethodEntryBci}, 2851 {CC"getCompileQueueSize", 2852 CC"(I)I", (void*)&WB_GetCompileQueueSize}, 2853 {CC"testSetForceInlineMethod0", 2854 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetForceInlineMethod}, 2855 {CC"enqueueMethodForCompilation0", 2856 CC"(Ljava/lang/reflect/Executable;II)Z", (void*)&WB_EnqueueMethodForCompilation}, 2857 {CC"enqueueInitializerForCompilation0", 2858 CC"(Ljava/lang/Class;I)Z", (void*)&WB_EnqueueInitializerForCompilation}, 2859 {CC"markMethodProfiled", 2860 CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_MarkMethodProfiled}, 2861 {CC"clearMethodState0", 2862 CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_ClearMethodState}, 2863 {CC"lockCompilation", CC"()V", (void*)&WB_LockCompilation}, 2864 {CC"unlockCompilation", CC"()V", (void*)&WB_UnlockCompilation}, 2865 {CC"matchesMethod", 2866 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)I", 2867 (void*)&WB_MatchesMethod}, 2868 {CC"matchesInline", 2869 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)I", 2870 (void*)&WB_MatchesInline}, 2871 {CC"shouldPrintAssembly", 2872 CC"(Ljava/lang/reflect/Executable;I)Z", 2873 (void*)&WB_ShouldPrintAssembly}, 2874 2875 {CC"isConstantVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsConstantVMFlag}, 2876 {CC"isDefaultVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsDefaultVMFlag}, 2877 {CC"isLockedVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsLockedVMFlag}, 2878 {CC"setBooleanVMFlag", CC"(Ljava/lang/String;Z)V",(void*)&WB_SetBooleanVMFlag}, 2879 {CC"setIntVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntVMFlag}, 2880 {CC"setUintVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintVMFlag}, 2881 {CC"setIntxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag}, 2882 {CC"setUintxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag}, 2883 {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag}, 2884 {CC"setSizeTVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetSizeTVMFlag}, 2885 {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag}, 2886 {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V", 2887 (void*)&WB_SetStringVMFlag}, 2888 {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;", 2889 (void*)&WB_GetBooleanVMFlag}, 2890 {CC"getIntVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 2891 (void*)&WB_GetIntVMFlag}, 2892 {CC"getUintVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 2893 (void*)&WB_GetUintVMFlag}, 2894 {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 2895 (void*)&WB_GetIntxVMFlag}, 2896 {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 2897 (void*)&WB_GetUintxVMFlag}, 2898 {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 2899 (void*)&WB_GetUint64VMFlag}, 2900 {CC"getSizeTVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 2901 (void*)&WB_GetSizeTVMFlag}, 2902 {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;", 2903 (void*)&WB_GetDoubleVMFlag}, 2904 {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;", 2905 (void*)&WB_GetStringVMFlag}, 2906 {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable }, 2907 {CC"fullGC", CC"()V", (void*)&WB_FullGC }, 2908 {CC"youngGC", CC"()V", (void*)&WB_YoungGC }, 2909 {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory }, 2910 {CC"allocateMetaspace", 2911 CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace }, 2912 {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC }, 2913 {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC }, 2914 {CC"metaspaceSharedRegionAlignment", CC"()J", (void*)&WB_AOTMetaspaceRegionAlignment }, 2915 {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures }, 2916 {CC"getNMethod0", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;", 2917 (void*)&WB_GetNMethod }, 2918 {CC"allocateCodeBlob", CC"(II)J", (void*)&WB_AllocateCodeBlob }, 2919 {CC"freeCodeBlob", CC"(J)V", (void*)&WB_FreeCodeBlob }, 2920 {CC"getCodeHeapEntries", CC"(I)[Ljava/lang/Object;",(void*)&WB_GetCodeHeapEntries }, 2921 {CC"getCompilationActivityMode", 2922 CC"()I", (void*)&WB_GetCompilationActivityMode}, 2923 {CC"getMethodData0", CC"(Ljava/lang/reflect/Executable;)J", 2924 (void*)&WB_GetMethodData }, 2925 {CC"getCodeBlob", CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob }, 2926 {CC"getThreadStackSize", CC"()J", (void*)&WB_GetThreadStackSize }, 2927 {CC"getThreadRemainingStackSize", CC"()J", (void*)&WB_GetThreadRemainingStackSize }, 2928 {CC"DefineModule", CC"(Ljava/lang/Object;ZLjava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V", 2929 (void*)&WB_DefineModule }, 2930 {CC"AddModuleExports", CC"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V", 2931 (void*)&WB_AddModuleExports }, 2932 {CC"AddReadsModule", CC"(Ljava/lang/Object;Ljava/lang/Object;)V", 2933 (void*)&WB_AddReadsModule }, 2934 {CC"AddModuleExportsToAllUnnamed", CC"(Ljava/lang/Object;Ljava/lang/String;)V", 2935 (void*)&WB_AddModuleExportsToAllUnnamed }, 2936 {CC"AddModuleExportsToAll", CC"(Ljava/lang/Object;Ljava/lang/String;)V", 2937 (void*)&WB_AddModuleExportsToAll }, 2938 {CC"deflateIdleMonitors", CC"()Z", (void*)&WB_DeflateIdleMonitors }, 2939 {CC"isMonitorInflated0", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated }, 2940 {CC"isAsanEnabled", CC"()Z", (void*)&WB_IsAsanEnabled }, 2941 {CC"isUbsanEnabled", CC"()Z", (void*)&WB_IsUbsanEnabled }, 2942 {CC"getInUseMonitorCount", CC"()J", (void*)&WB_getInUseMonitorCount }, 2943 {CC"getLockStackCapacity", CC"()I", (void*)&WB_getLockStackCapacity }, 2944 {CC"supportsRecursiveLightweightLocking", CC"()Z", (void*)&WB_supportsRecursiveLightweightLocking }, 2945 {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint }, 2946 {CC"forceClassLoaderStatsSafepoint", CC"()V", (void*)&WB_ForceClassLoaderStatsSafepoint }, 2947 {CC"getConstantPool0", CC"(Ljava/lang/Class;)J", (void*)&WB_GetConstantPool }, 2948 {CC"getResolvedReferences0", CC"(Ljava/lang/Class;)[Ljava/lang/Object;", (void*)&WB_GetResolvedReferences}, 2949 {CC"getFieldEntriesLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_getFieldEntriesLength}, 2950 {CC"getFieldCPIndex0", CC"(Ljava/lang/Class;I)I", (void*)&WB_getFieldCPIndex}, 2951 {CC"getMethodEntriesLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_getMethodEntriesLength}, 2952 {CC"getMethodCPIndex0", CC"(Ljava/lang/Class;I)I", (void*)&WB_getMethodCPIndex}, 2953 {CC"getIndyInfoLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_getIndyInfoLength}, 2954 {CC"getIndyCPIndex0", CC"(Ljava/lang/Class;I)I", (void*)&WB_getIndyCPIndex}, 2955 {CC"printClasses0", CC"(Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_printClasses}, 2956 {CC"printMethods0", CC"(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_printMethods}, 2957 {CC"getMethodBooleanOption", 2958 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Boolean;", 2959 (void*)&WB_GetMethodBooleaneOption}, 2960 {CC"getMethodIntxOption", 2961 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;", 2962 (void*)&WB_GetMethodIntxOption}, 2963 {CC"getMethodUintxOption", 2964 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;", 2965 (void*)&WB_GetMethodUintxOption}, 2966 {CC"getMethodDoubleOption", 2967 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Double;", 2968 (void*)&WB_GetMethodDoubleOption}, 2969 {CC"getMethodStringOption", 2970 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/String;", 2971 (void*)&WB_GetMethodStringOption}, 2972 {CC"getDefaultArchivePath", CC"()Ljava/lang/String;", 2973 (void*)&WB_GetDefaultArchivePath}, 2974 {CC"getCDSGenericHeaderMinVersion", CC"()I", (void*)&WB_GetCDSGenericHeaderMinVersion}, 2975 {CC"getCurrentCDSVersion", CC"()I", (void*)&WB_GetCDSCurrentVersion}, 2976 {CC"isSharingEnabled", CC"()Z", (void*)&WB_IsSharingEnabled}, 2977 {CC"isSharedInternedString", CC"(Ljava/lang/String;)Z", (void*)&WB_IsSharedInternedString }, 2978 {CC"isSharedClass", CC"(Ljava/lang/Class;)Z", (void*)&WB_IsSharedClass }, 2979 {CC"areSharedStringsMapped", CC"()Z", (void*)&WB_AreSharedStringsMapped }, 2980 {CC"linkClass", CC"(Ljava/lang/Class;)V", (void*)&WB_LinkClass}, 2981 {CC"areOpenArchiveHeapObjectsMapped", CC"()Z", (void*)&WB_AreOpenArchiveHeapObjectsMapped}, 2982 {CC"isCDSIncluded", CC"()Z", (void*)&WB_IsCDSIncluded }, 2983 {CC"isJFRIncluded", CC"()Z", (void*)&WB_IsJFRIncluded }, 2984 {CC"isDTraceIncluded", CC"()Z", (void*)&WB_IsDTraceIncluded }, 2985 {CC"hasLibgraal", CC"()Z", (void*)&WB_HasLibgraal }, 2986 {CC"isC2OrJVMCIIncluded", CC"()Z", (void*)&WB_isC2OrJVMCIIncluded }, 2987 {CC"isJVMCISupportedByGC", CC"()Z", (void*)&WB_IsJVMCISupportedByGC}, 2988 {CC"canWriteJavaHeapArchive", CC"()Z", (void*)&WB_CanWriteJavaHeapArchive }, 2989 {CC"cdsMemoryMappingFailed", CC"()Z", (void*)&WB_CDSMemoryMappingFailed }, 2990 2991 {CC"clearInlineCaches0", CC"(Z)V", (void*)&WB_ClearInlineCaches }, 2992 {CC"handshakeReadMonitors", CC"(Ljava/lang/Thread;)Z", (void*)&WB_HandshakeReadMonitors }, 2993 {CC"handshakeWalkStack", CC"(Ljava/lang/Thread;Z)I", (void*)&WB_HandshakeWalkStack }, 2994 {CC"asyncHandshakeWalkStack", CC"(Ljava/lang/Thread;)V", (void*)&WB_AsyncHandshakeWalkStack }, 2995 {CC"lockAndBlock", CC"(Z)V", (void*)&WB_LockAndBlock}, 2996 {CC"checkThreadObjOfTerminatingThread", CC"(Ljava/lang/Thread;)V", (void*)&WB_CheckThreadObjOfTerminatingThread }, 2997 {CC"verifyFrames", CC"(ZZ)V", (void*)&WB_VerifyFrames }, 2998 {CC"addCompilerDirective", CC"(Ljava/lang/String;)I", 2999 (void*)&WB_AddCompilerDirective }, 3000 {CC"removeCompilerDirective", CC"(I)V", (void*)&WB_RemoveCompilerDirective }, 3001 {CC"isGCSupported", CC"(I)Z", (void*)&WB_IsGCSupported}, 3002 {CC"isGCSupportedByJVMCICompiler", CC"(I)Z", (void*)&WB_IsGCSupportedByJVMCICompiler}, 3003 {CC"isGCSelected", CC"(I)Z", (void*)&WB_IsGCSelected}, 3004 {CC"isGCSelectedErgonomically", CC"()Z", (void*)&WB_IsGCSelectedErgonomically}, 3005 {CC"supportsConcurrentGCBreakpoints", CC"()Z", (void*)&WB_SupportsConcurrentGCBreakpoints}, 3006 {CC"concurrentGCAcquireControl0", CC"()V", (void*)&WB_ConcurrentGCAcquireControl}, 3007 {CC"concurrentGCReleaseControl0", CC"()V", (void*)&WB_ConcurrentGCReleaseControl}, 3008 {CC"concurrentGCRunToIdle0", CC"()V", (void*)&WB_ConcurrentGCRunToIdle}, 3009 {CC"concurrentGCRunTo0", CC"(Ljava/lang/String;)Z", 3010 (void*)&WB_ConcurrentGCRunTo}, 3011 {CC"checkLibSpecifiesNoexecstack", CC"(Ljava/lang/String;)Z", 3012 (void*)&WB_CheckLibSpecifiesNoexecstack}, 3013 {CC"isContainerized", CC"()Z", (void*)&WB_IsContainerized }, 3014 {CC"validateCgroup", 3015 CC"(ZLjava/lang/String;Ljava/lang/String;Ljava/lang/String;)I", 3016 (void*)&WB_ValidateCgroup }, 3017 {CC"hostPhysicalMemory", CC"()J", (void*)&WB_HostPhysicalMemory }, 3018 {CC"hostPhysicalSwap", CC"()J", (void*)&WB_HostPhysicalSwap }, 3019 {CC"hostAvailableMemory", CC"()J", (void*)&WB_HostAvailableMemory }, 3020 {CC"hostCPUs", CC"()I", (void*)&WB_HostCPUs }, 3021 {CC"printOsInfo", CC"()V", (void*)&WB_PrintOsInfo }, 3022 {CC"disableElfSectionCache", CC"()V", (void*)&WB_DisableElfSectionCache }, 3023 {CC"resolvedMethodItemsCount", CC"()J", (void*)&WB_ResolvedMethodItemsCount }, 3024 {CC"getKlassMetadataSize", CC"(Ljava/lang/Class;)I",(void*)&WB_GetKlassMetadataSize}, 3025 3026 {CC"createMetaspaceTestContext", CC"(JJ)J", (void*)&WB_CreateMetaspaceTestContext}, 3027 {CC"destroyMetaspaceTestContext", CC"(J)V", (void*)&WB_DestroyMetaspaceTestContext}, 3028 {CC"purgeMetaspaceTestContext", CC"(J)V", (void*)&WB_PurgeMetaspaceTestContext}, 3029 {CC"printMetaspaceTestContext", CC"(J)V", (void*)&WB_PrintMetaspaceTestContext}, 3030 {CC"getTotalCommittedBytesInMetaspaceTestContext", CC"(J)J",(void*)&WB_GetTotalCommittedBytesInMetaspaceTestContext}, 3031 {CC"getTotalUsedBytesInMetaspaceTestContext", CC"(J)J", (void*)&WB_GetTotalUsedBytesInMetaspaceTestContext}, 3032 {CC"createArenaInTestContext", CC"(JZ)J", (void*)&WB_CreateArenaInTestContext}, 3033 {CC"destroyMetaspaceTestArena", CC"(J)V", (void*)&WB_DestroyMetaspaceTestArena}, 3034 {CC"allocateFromMetaspaceTestArena", CC"(JJ)J", (void*)&WB_AllocateFromMetaspaceTestArena}, 3035 {CC"deallocateToMetaspaceTestArena", CC"(JJJ)V", (void*)&WB_DeallocateToMetaspaceTestArena}, 3036 {CC"maxMetaspaceAllocationSize", CC"()J", (void*)&WB_GetMaxMetaspaceAllocationSize}, 3037 3038 {CC"isJVMTIIncluded", CC"()Z", (void*)&WB_IsJVMTIIncluded}, 3039 {CC"waitUnsafe", CC"(I)V", (void*)&WB_WaitUnsafe}, 3040 {CC"busyWait", CC"(I)V", (void*)&WB_BusyWait}, 3041 {CC"cpuSamplerSetOutOfStackWalking", CC"(Z)Z", (void*)&WB_CPUSamplerSetOutOfStackWalking}, 3042 {CC"cpuSamplerOutOfStackWalkingIterations", CC"()J",(void*)&WB_CPUSamplerOutOfStackWalkingIterations}, 3043 {CC"getLibcName", CC"()Ljava/lang/String;", (void*)&WB_GetLibcName}, 3044 3045 {CC"pinObject", CC"(Ljava/lang/Object;)V", (void*)&WB_PinObject}, 3046 {CC"unpinObject", CC"(Ljava/lang/Object;)V", (void*)&WB_UnpinObject}, 3047 {CC"setVirtualThreadsNotifyJvmtiMode", CC"(Z)Z", (void*)&WB_SetVirtualThreadsNotifyJvmtiMode}, 3048 {CC"preTouchMemory", CC"(JJ)V", (void*)&WB_PreTouchMemory}, 3049 {CC"cleanMetaspaces", CC"()V", (void*)&WB_CleanMetaspaces}, 3050 {CC"rss", CC"()J", (void*)&WB_Rss}, 3051 {CC"printString", CC"(Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_PrintString}, 3052 {CC"lockAndStuckInSafepoint", CC"()V", (void*)&WB_TakeLockAndHangInSafepoint}, 3053 {CC"wordSize", CC"()J", (void*)&WB_WordSize}, 3054 {CC"rootChunkWordSize", CC"()J", (void*)&WB_RootChunkWordSize}, 3055 {CC"isStatic", CC"()Z", (void*)&WB_IsStaticallyLinked}, 3056 {CC"controlledCrash",CC"(I)V", (void*)&WB_ControlledCrash}, 3057 }; 3058 3059 #undef CC 3060 3061 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass)) 3062 { 3063 if (WhiteBoxAPI) { 3064 // Make sure that wbclass is loaded by the null classloader 3065 InstanceKlass* ik = java_lang_Class::as_InstanceKlass(JNIHandles::resolve(wbclass)); 3066 Handle loader(THREAD, ik->class_loader()); 3067 if (loader.is_null()) { 3068 WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0])); 3069 WhiteBox::set_used(); 3070 } 3071 } 3072 } 3073 JVM_END