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(&reg_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, &param)) {
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