whitebox.cpp revision 9287:40bd4478a362
1141104Sharti/* 294589Sobrien * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved. 394589Sobrien * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 45814Sjkh * 51590Srgrimes * This code is free software; you can redistribute it and/or modify it 61590Srgrimes * under the terms of the GNU General Public License version 2 only, as 71590Srgrimes * published by the Free Software Foundation. 81590Srgrimes * 91590Srgrimes * This code is distributed in the hope that it will be useful, but WITHOUT 101590Srgrimes * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 111590Srgrimes * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 121590Srgrimes * version 2 for more details (a copy is included in the LICENSE file that 131590Srgrimes * accompanied this code). 141590Srgrimes * 151590Srgrimes * You should have received a copy of the GNU General Public License version 161590Srgrimes * 2 along with this work; if not, write to the Free Software Foundation, 171590Srgrimes * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 181590Srgrimes * 191590Srgrimes * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 201590Srgrimes * or visit www.oracle.com if you need additional information or have any 211590Srgrimes * questions. 221590Srgrimes * 231590Srgrimes */ 241590Srgrimes 251590Srgrimes#include "precompiled.hpp" 261590Srgrimes 271590Srgrimes#include <new> 281590Srgrimes 291590Srgrimes#include "classfile/classLoaderData.hpp" 301590Srgrimes#include "classfile/stringTable.hpp" 311590Srgrimes#include "code/codeCache.hpp" 321590Srgrimes#include "compiler/methodMatcher.hpp" 331590Srgrimes#include "jvmtifiles/jvmtiEnv.hpp" 341590Srgrimes#include "memory/metadataFactory.hpp" 351590Srgrimes#include "memory/metaspaceShared.hpp" 361590Srgrimes#include "memory/universe.hpp" 371590Srgrimes#include "oops/oop.inline.hpp" 3862833Swsanchez#include "prims/wbtestmethods/parserTests.hpp" 3962833Swsanchez#include "prims/whitebox.hpp" 401590Srgrimes#include "runtime/arguments.hpp" 411590Srgrimes#include "runtime/compilationPolicy.hpp" 4262833Swsanchez#include "runtime/deoptimization.hpp" 4394587Sobrien#include "runtime/interfaceSupport.hpp" 441590Srgrimes#include "runtime/javaCalls.hpp" 4535483Simp#include "runtime/os.hpp" 46103503Sjmallett#include "runtime/sweeper.hpp" 4735483Simp#include "runtime/thread.hpp" 4835483Simp#include "runtime/vm_version.hpp" 491590Srgrimes#include "utilities/array.hpp" 501590Srgrimes#include "utilities/debug.hpp" 511590Srgrimes#include "utilities/exceptions.hpp" 521590Srgrimes#include "utilities/macros.hpp" 531590Srgrimes#if INCLUDE_ALL_GCS 54144467Sharti#include "gc/g1/concurrentMark.hpp" 551590Srgrimes#include "gc/g1/concurrentMarkThread.hpp" 56144467Sharti#include "gc/g1/g1CollectedHeap.inline.hpp" 57144467Sharti#include "gc/g1/heapRegionRemSet.hpp" 58144467Sharti#include "gc/parallel/parallelScavengeHeap.inline.hpp" 59144467Sharti#include "gc/parallel/adjoiningGenerations.hpp" 60144467Sharti#endif // INCLUDE_ALL_GCS 61144467Sharti#if INCLUDE_NMT 62144467Sharti#include "services/mallocSiteTable.hpp" 631590Srgrimes#include "services/memTracker.hpp" 64144467Sharti#include "utilities/nativeCallStack.hpp" 65144467Sharti#endif // INCLUDE_NMT 66144467Sharti 67144467Sharti 68144467Sharti#define SIZE_T_MAX_VALUE ((size_t) -1) 691590Srgrimes 70144467Shartibool WhiteBox::_used = false; 71144467Shartivolatile bool WhiteBox::compilation_locked = false; 72144467Sharti 73144467Sharticlass VM_WhiteBoxOperation : public VM_Operation { 741590Srgrimes public: 75144467Sharti VM_WhiteBoxOperation() { } 761590Srgrimes VMOp_Type type() const { return VMOp_WhiteBoxOperation; } 77144467Sharti bool allow_nested_vm_operations() const { return true; } 781590Srgrimes}; 79144467Sharti 80144467Sharti 81144467ShartiWB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj)) 821590Srgrimes return (jlong)(void*)JNIHandles::resolve(obj); 83144467ShartiWB_END 84144467Sharti 85144467ShartiWB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o)) 86144467Sharti return heapOopSize; 871590SrgrimesWB_END 88144467Sharti 89144467ShartiWB_ENTRY(jint, WB_GetVMPageSize(JNIEnv* env, jobject o)) 90144467Sharti return os::vm_page_size(); 911590SrgrimesWB_END 92144467Sharti 93144467ShartiWB_ENTRY(jlong, WB_GetVMAllocationGranularity(JNIEnv* env, jobject o)) 94144467Sharti return os::vm_allocation_granularity(); 951590SrgrimesWB_END 96144467Sharti 971590SrgrimesWB_ENTRY(jlong, WB_GetVMLargePageSize(JNIEnv* env, jobject o)) 98144467Sharti return os::large_page_size(); 991590SrgrimesWB_END 1001590Srgrimes 101144494Sharticlass WBIsKlassAliveClosure : public KlassClosure { 1021590Srgrimes Symbol* _name; 103141104Sharti bool _found; 1041590Srgrimespublic: 105107447Sru WBIsKlassAliveClosure(Symbol* name) : _name(name), _found(false) {} 106104475Sphk 107107447Sru void do_klass(Klass* k) { 1081590Srgrimes if (_found) return; 109141104Sharti Symbol* ksym = k->name(); 11094506Scharnier if (ksym->fast_compare(_name) == 0) { 1115814Sjkh _found = true; 112144665Sharti } 1131590Srgrimes } 1145814Sjkh 115141104Sharti bool found() const { 11680381Ssheldonh return _found; 11794506Scharnier } 118141104Sharti}; 119141104Sharti 120142457ShartiWB_ENTRY(jboolean, WB_IsClassAlive(JNIEnv* env, jobject target, jstring name)) 121146056Sharti Handle h_name = JNIHandles::resolve(name); 1221590Srgrimes if (h_name.is_null()) return false; 123141104Sharti Symbol* sym = java_lang_String::as_symbol(h_name, CHECK_false); 124141104Sharti TempNewSymbol tsym(sym); // Make sure to decrement reference count on sym on return 1251590Srgrimes 126141104Sharti WBIsKlassAliveClosure closure(sym); 127141104Sharti ClassLoaderDataGraph::classes_do(&closure); 1281590Srgrimes 129141104Sharti return closure.found(); 130146056ShartiWB_END 131141104Sharti 132141104ShartiWB_ENTRY(void, WB_AddToBootstrapClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) { 133141104Sharti#if INCLUDE_JVMTI 1341590Srgrimes ResourceMark rm; 135146057Sharti const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment)); 136146057Sharti JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION); 137146057Sharti jvmtiError err = jvmti_env->AddToBootstrapClassLoaderSearch(seg); 1381590Srgrimes assert(err == JVMTI_ERROR_NONE, "must not fail"); 139146057Sharti#endif 140146057Sharti} 141146057ShartiWB_END 142146057Sharti 143146057ShartiWB_ENTRY(void, WB_AddToSystemClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) { 144146057Sharti#if INCLUDE_JVMTI 145146057Sharti ResourceMark rm; 146146057Sharti const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment)); 147146057Sharti JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION); 148144483Sharti jvmtiError err = jvmti_env->AddToSystemClassLoaderSearch(seg); 149144483Sharti assert(err == JVMTI_ERROR_NONE, "must not fail"); 150144483Sharti#endif 151144483Sharti} 152144483ShartiWB_END 153144483Sharti 154144483Sharti 155144483ShartiWB_ENTRY(jlong, WB_GetCompressedOopsMaxHeapSize(JNIEnv* env, jobject o)) { 156144483Sharti return (jlong)Arguments::max_heap_for_compressed_oops(); 157144483Sharti} 158144483ShartiWB_END 159144483Sharti 160144665ShartiWB_ENTRY(void, WB_PrintHeapSizes(JNIEnv* env, jobject o)) { 161144483Sharti CollectorPolicy * p = Universe::heap()->collector_policy(); 162144483Sharti gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap " 163144483Sharti SIZE_FORMAT " Maximum heap " SIZE_FORMAT " Space alignment " SIZE_FORMAT " Heap alignment " SIZE_FORMAT, 164144483Sharti p->min_heap_byte_size(), p->initial_heap_byte_size(), p->max_heap_byte_size(), 165144483Sharti p->space_alignment(), p->heap_alignment()); 166144483Sharti} 167144483ShartiWB_END 168144483Sharti 169144483Sharti#ifndef PRODUCT 170144483Sharti// Forward declaration 171144483Shartivoid TestReservedSpace_test(); 172144483Shartivoid TestReserveMemorySpecial_test(); 173144483Shartivoid TestVirtualSpace_test(); 174144483Shartivoid TestMetaspaceAux_test(); 175144483Sharti#endif 176144483Sharti 177144483ShartiWB_ENTRY(void, WB_RunMemoryUnitTests(JNIEnv* env, jobject o)) 178144483Sharti#ifndef PRODUCT 179144483Sharti TestReservedSpace_test(); 180144483Sharti TestReserveMemorySpecial_test(); 181144483Sharti TestVirtualSpace_test(); 182144483Sharti TestMetaspaceAux_test(); 183144483Sharti#endif 184144483ShartiWB_END 185146061Sharti 186144483ShartiWB_ENTRY(void, WB_ReadFromNoaccessArea(JNIEnv* env, jobject o)) 187144483Sharti size_t granularity = os::vm_allocation_granularity(); 188144483Sharti ReservedHeapSpace rhs(100 * granularity, granularity, false); 189144483Sharti VirtualSpace vs; 190144483Sharti vs.initialize(rhs, 50 * granularity); 191144483Sharti 192144483Sharti // Check if constraints are complied 193144483Sharti if (!( UseCompressedOops && rhs.base() != NULL && 194144483Sharti Universe::narrow_oop_base() != NULL && 195144483Sharti Universe::narrow_oop_use_implicit_null_checks() )) { 196144483Sharti tty->print_cr("WB_ReadFromNoaccessArea method is useless:\n " 197144483Sharti "\tUseCompressedOops is %d\n" 198144483Sharti "\trhs.base() is " PTR_FORMAT "\n" 199146061Sharti "\tUniverse::narrow_oop_base() is " PTR_FORMAT "\n" 200144483Sharti "\tUniverse::narrow_oop_use_implicit_null_checks() is %d", 201144483Sharti UseCompressedOops, 202144483Sharti p2i(rhs.base()), 203144483Sharti p2i(Universe::narrow_oop_base()), 204144483Sharti Universe::narrow_oop_use_implicit_null_checks()); 205144483Sharti return; 206144483Sharti } 207144483Sharti tty->print_cr("Reading from no access area... "); 208144483Sharti tty->print_cr("*(vs.low_boundary() - rhs.noaccess_prefix() / 2 ) = %c", 209144483Sharti *(vs.low_boundary() - rhs.noaccess_prefix() / 2 )); 210144483ShartiWB_END 211144483Sharti 212144483Shartistatic jint wb_stress_virtual_space_resize(size_t reserved_space_size, 213144483Sharti size_t magnitude, size_t iterations) { 214144483Sharti size_t granularity = os::vm_allocation_granularity(); 215144483Sharti ReservedHeapSpace rhs(reserved_space_size * granularity, granularity, false); 216144483Sharti VirtualSpace vs; 217144483Sharti if (!vs.initialize(rhs, 0)) { 218144483Sharti tty->print_cr("Failed to initialize VirtualSpace. Can't proceed."); 219144483Sharti return 3; 220144483Sharti } 221144483Sharti 222144483Sharti long seed = os::random(); 223144483Sharti tty->print_cr("Random seed is %ld", seed); 224144483Sharti os::init_random(seed); 225144483Sharti 226144483Sharti for (size_t i = 0; i < iterations; i++) { 227144483Sharti 228144483Sharti // Whether we will shrink or grow 229144483Sharti bool shrink = os::random() % 2L == 0; 230144483Sharti 231144483Sharti // Get random delta to resize virtual space 232144483Sharti size_t delta = (size_t)os::random() % magnitude; 233144483Sharti 234144483Sharti // If we are about to shrink virtual space below zero, then expand instead 235144483Sharti if (shrink && vs.committed_size() < delta) { 236144483Sharti shrink = false; 237144483Sharti } 238144483Sharti 239144483Sharti // Resizing by delta 240144483Sharti if (shrink) { 241144483Sharti vs.shrink_by(delta); 242144483Sharti } else { 243144483Sharti // If expanding fails expand_by will silently return false 244144483Sharti vs.expand_by(delta, true); 245144494Sharti } 246144494Sharti } 247144483Sharti return 0; 248144483Sharti} 249146061Sharti 250146061ShartiWB_ENTRY(jint, WB_StressVirtualSpaceResize(JNIEnv* env, jobject o, 251144483Sharti jlong reserved_space_size, jlong magnitude, jlong iterations)) 252144483Sharti tty->print_cr("reservedSpaceSize=" JLONG_FORMAT ", magnitude=" JLONG_FORMAT ", " 253144483Sharti "iterations=" JLONG_FORMAT "\n", reserved_space_size, magnitude, 254146061Sharti iterations); 255144483Sharti if (reserved_space_size < 0 || magnitude < 0 || iterations < 0) { 256144494Sharti tty->print_cr("One of variables printed above is negative. Can't proceed.\n"); 257144494Sharti return 1; 258144483Sharti } 259144483Sharti 260144483Sharti // sizeof(size_t) depends on whether OS is 32bit or 64bit. sizeof(jlong) is 261144483Sharti // always 8 byte. That's why we should avoid overflow in case of 32bit platform. 262144483Sharti if (sizeof(size_t) < sizeof(jlong)) { 263144483Sharti jlong size_t_max_value = (jlong) SIZE_T_MAX_VALUE; 264144483Sharti if (reserved_space_size > size_t_max_value || magnitude > size_t_max_value 265144483Sharti || iterations > size_t_max_value) { 266144483Sharti tty->print_cr("One of variables printed above overflows size_t. Can't proceed.\n"); 267144483Sharti return 2; 268144483Sharti } 269144483Sharti } 270144483Sharti 271144483Sharti return wb_stress_virtual_space_resize((size_t) reserved_space_size, 272144483Sharti (size_t) magnitude, (size_t) iterations); 273144483ShartiWB_END 274144483Sharti 275144483ShartiWB_ENTRY(jboolean, WB_isObjectInOldGen(JNIEnv* env, jobject o, jobject obj)) 276144483Sharti oop p = JNIHandles::resolve(obj); 277144483Sharti#if INCLUDE_ALL_GCS 278144483Sharti if (UseG1GC) { 279144483Sharti G1CollectedHeap* g1 = G1CollectedHeap::heap(); 280144483Sharti const HeapRegion* hr = g1->heap_region_containing(p); 281144483Sharti if (hr == NULL) { 282144483Sharti return false; 283144483Sharti } 284144483Sharti return !(hr->is_young()); 285144483Sharti } else if (UseParallelGC) { 286144483Sharti ParallelScavengeHeap* psh = ParallelScavengeHeap::heap(); 287144483Sharti return !psh->is_in_young(p); 288144483Sharti } 289144483Sharti#endif // INCLUDE_ALL_GCS 290144483Sharti GenCollectedHeap* gch = GenCollectedHeap::heap(); 291144483Sharti return !gch->is_in_young(p); 292144483ShartiWB_END 293144483Sharti 294144483ShartiWB_ENTRY(jlong, WB_GetObjectSize(JNIEnv* env, jobject o, jobject obj)) 295144483Sharti oop p = JNIHandles::resolve(obj); 296144483Sharti return p->size() * HeapWordSize; 297144483ShartiWB_END 298144483Sharti 299144483ShartiWB_ENTRY(jlong, WB_GetHeapSpaceAlignment(JNIEnv* env, jobject o)) 300144483Sharti size_t alignment = Universe::heap()->collector_policy()->space_alignment(); 301144483Sharti return (jlong)alignment; 302144483ShartiWB_END 303144483Sharti 304144483Sharti#if INCLUDE_ALL_GCS 305144483ShartiWB_ENTRY(jboolean, WB_G1IsHumongous(JNIEnv* env, jobject o, jobject obj)) 306144483Sharti G1CollectedHeap* g1 = G1CollectedHeap::heap(); 307144483Sharti oop result = JNIHandles::resolve(obj); 308144483Sharti const HeapRegion* hr = g1->heap_region_containing(result); 3098874Srgrimes return hr->is_humongous(); 3101590SrgrimesWB_END 311144467Sharti 312144467ShartiWB_ENTRY(jlong, WB_G1NumMaxRegions(JNIEnv* env, jobject o)) 313144467Sharti G1CollectedHeap* g1 = G1CollectedHeap::heap(); 314144467Sharti size_t nr = g1->max_regions(); 315144467Sharti return (jlong)nr; 3161590SrgrimesWB_END 31718730Ssteve 31818730SsteveWB_ENTRY(jlong, WB_G1NumFreeRegions(JNIEnv* env, jobject o)) 31918730Ssteve G1CollectedHeap* g1 = G1CollectedHeap::heap(); 32018730Ssteve size_t nr = g1->num_free_regions(); 321138232Sharti return (jlong)nr; 3221590SrgrimesWB_END 3231590Srgrimes 3241590SrgrimesWB_ENTRY(jboolean, WB_G1InConcurrentMark(JNIEnv* env, jobject o)) 3251590Srgrimes G1CollectedHeap* g1 = G1CollectedHeap::heap(); 3261590Srgrimes return g1->concurrent_mark()->cmThread()->during_cycle(); 3271590SrgrimesWB_END 328144467Sharti 3291590SrgrimesWB_ENTRY(jboolean, WB_G1StartMarkCycle(JNIEnv* env, jobject o)) 3301590Srgrimes G1CollectedHeap* g1h = G1CollectedHeap::heap(); 331144467Sharti if (!g1h->concurrent_mark()->cmThread()->during_cycle()) { 332144467Sharti g1h->collect(GCCause::_wb_conc_mark); 333144467Sharti return true; 334144467Sharti } 335144467Sharti return false; 336144467ShartiWB_END 3371590Srgrimes 3381590SrgrimesWB_ENTRY(jint, WB_G1RegionSize(JNIEnv* env, jobject o)) 339144467Sharti return (jint)HeapRegion::GrainBytes; 340146061ShartiWB_END 341144467Sharti 342144467ShartiWB_ENTRY(jlong, WB_PSVirtualSpaceAlignment(JNIEnv* env, jobject o)) 3431590Srgrimes ParallelScavengeHeap* ps = ParallelScavengeHeap::heap(); 3441590Srgrimes size_t alignment = ps->gens()->virtual_spaces()->alignment(); 3451590Srgrimes return (jlong)alignment; 3461590SrgrimesWB_END 347144483Sharti 348144467ShartiWB_ENTRY(jlong, WB_PSHeapGenerationAlignment(JNIEnv* env, jobject o)) 349144467Sharti size_t alignment = ParallelScavengeHeap::heap()->generation_alignment(); 350144467Sharti return (jlong)alignment; 351144467ShartiWB_END 352144467Sharti 353144467ShartiWB_ENTRY(jobject, WB_G1AuxiliaryMemoryUsage(JNIEnv* env)) 354144467Sharti ResourceMark rm(THREAD); 355144741Sharti G1CollectedHeap* g1h = G1CollectedHeap::heap(); 356144467Sharti MemoryUsage usage = g1h->get_auxiliary_data_memory_usage(); 357144467Sharti Handle h = MemoryService::create_MemoryUsage_obj(usage, CHECK_NULL); 358144467Sharti return JNIHandles::make_local(env, h()); 359144467ShartiWB_END 360144467Sharti#endif // INCLUDE_ALL_GCS 361144467Sharti 362144467Sharti#if INCLUDE_NMT 363144467Sharti// Alloc memory using the test memory type so that we can use that to see if 364144467Sharti// NMT picks it up correctly 365144741ShartiWB_ENTRY(jlong, WB_NMTMalloc(JNIEnv* env, jobject o, jlong size)) 366144467Sharti jlong addr = 0; 36718730Ssteve addr = (jlong)(uintptr_t)os::malloc(size, mtTest); 368144467Sharti return addr; 36918730SsteveWB_END 370144467Sharti 371144467Sharti// Alloc memory with pseudo call stack. The test can create psudo malloc 372144467Sharti// allocation site to stress the malloc tracking. 373144467ShartiWB_ENTRY(jlong, WB_NMTMallocWithPseudoStack(JNIEnv* env, jobject o, jlong size, jint pseudo_stack)) 374144467Sharti address pc = (address)(size_t)pseudo_stack; 375144467Sharti NativeCallStack stack(&pc, 1); 376144467Sharti return (jlong)(uintptr_t)os::malloc(size, mtTest, stack); 377144467ShartiWB_END 378144741Sharti 379144467Sharti// Free the memory allocated by NMTAllocTest 380144467ShartiWB_ENTRY(void, WB_NMTFree(JNIEnv* env, jobject o, jlong mem)) 381144467Sharti os::free((void*)(uintptr_t)mem); 3821590SrgrimesWB_END 3831590Srgrimes 384144467ShartiWB_ENTRY(jlong, WB_NMTReserveMemory(JNIEnv* env, jobject o, jlong size)) 385144467Sharti jlong addr = 0; 386144467Sharti 387144467Sharti addr = (jlong)(uintptr_t)os::reserve_memory(size); 388144483Sharti MemTracker::record_virtual_memory_type((address)addr, mtTest); 389146059Sharti 390146059Sharti return addr; 3911590SrgrimesWB_END 392144467Sharti 393144656ShartiWB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size)) 394138916Sharti os::commit_memory((char *)(uintptr_t)addr, size, !ExecMem); 395138916Sharti MemTracker::record_virtual_memory_type((address)(uintptr_t)addr, mtTest); 396144494ShartiWB_END 397138916Sharti 398146061ShartiWB_ENTRY(void, WB_NMTUncommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size)) 3991590Srgrimes os::uncommit_memory((char *)(uintptr_t)addr, size); 400137572SphkWB_END 401104475Sphk 402104475SphkWB_ENTRY(void, WB_NMTReleaseMemory(JNIEnv* env, jobject o, jlong addr, jlong size)) 403104475Sphk os::release_memory((char *)(uintptr_t)addr, size); 404146061ShartiWB_END 4051590Srgrimes 4061590SrgrimesWB_ENTRY(jboolean, WB_NMTChangeTrackingLevel(JNIEnv* env)) 4071590Srgrimes // Test that we can downgrade NMT levels but not upgrade them. 408146061Sharti if (MemTracker::tracking_level() == NMT_off) { 4091590Srgrimes MemTracker::transition_to(NMT_off); 410146061Sharti return MemTracker::tracking_level() == NMT_off; 4111590Srgrimes } else { 4121590Srgrimes assert(MemTracker::tracking_level() == NMT_detail, "Should start out as detail tracking"); 4131590Srgrimes MemTracker::transition_to(NMT_summary); 414137202Sharti assert(MemTracker::tracking_level() == NMT_summary, "Should be summary now"); 415137202Sharti 416138232Sharti // Can't go to detail once NMT is set to summary. 41718730Ssteve MemTracker::transition_to(NMT_detail); 4181590Srgrimes assert(MemTracker::tracking_level() == NMT_summary, "Should still be summary now"); 419137252Sharti 420137252Sharti // Shutdown sets tracking level to minimal. 421137252Sharti MemTracker::shutdown(); 4228874Srgrimes assert(MemTracker::tracking_level() == NMT_minimal, "Should be minimal now"); 423138916Sharti 424138916Sharti // Once the tracking level is minimal, we cannot increase to summary. 425138916Sharti // The code ignores this request instead of asserting because if the malloc site 4261590Srgrimes // table overflows in another thread, it tries to change the code to summary. 427144494Sharti MemTracker::transition_to(NMT_summary); 4281590Srgrimes assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now"); 429144656Sharti 430144656Sharti // Really can never go up to detail, verify that the code would never do this. 431144656Sharti MemTracker::transition_to(NMT_detail); 4321590Srgrimes assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now"); 433137605Sharti return MemTracker::tracking_level() == NMT_minimal; 434137605Sharti } 435137605ShartiWB_END 4361590Srgrimes 43718730SsteveWB_ENTRY(jint, WB_NMTGetHashSize(JNIEnv* env, jobject o)) 4381590Srgrimes int hash_size = MallocSiteTable::hash_buckets(); 4391590Srgrimes assert(hash_size > 0, "NMT hash_size should be > 0"); 44018730Ssteve return (jint)hash_size; 4411590SrgrimesWB_END 44218730Ssteve#endif // INCLUDE_NMT 4431590Srgrimes 4441590Srgrimesstatic jmethodID reflected_method_to_jmid(JavaThread* thread, JNIEnv* env, jobject method) { 4451590Srgrimes assert(method != NULL, "method should not be null"); 44618730Ssteve ThreadToNativeFromVM ttn(thread); 44718730Ssteve return env->FromReflectedMethod(method); 44818730Ssteve} 44918730Ssteve 45018730Ssteve// Deoptimizes all compiled frames and makes nmethods not entrant if it's requested 45118730Ssteveclass VM_WhiteBoxDeoptimizeFrames : public VM_WhiteBoxOperation { 452103503Sjmallett private: 45318730Ssteve int _result; 454138232Sharti const bool _make_not_entrant; 45518730Ssteve public: 45618730Ssteve VM_WhiteBoxDeoptimizeFrames(bool make_not_entrant) : 45718730Ssteve _result(0), _make_not_entrant(make_not_entrant) { } 45818730Ssteve int result() const { return _result; } 45918730Ssteve 46018730Ssteve void doit() { 46118730Ssteve for (JavaThread* t = Threads::first(); t != NULL; t = t->next()) { 462103503Sjmallett if (t->has_last_Java_frame()) { 463103503Sjmallett for (StackFrameStream fst(t, UseBiasedLocking); !fst.is_done(); fst.next()) { 46418730Ssteve frame* f = fst.current(); 46592921Simp if (f->can_be_deoptimized() && !f->is_deoptimized_frame()) { 46692921Simp RegisterMap* reg_map = fst.register_map(); 46792921Simp Deoptimization::deoptimize(t, *f, reg_map); 468144483Sharti if (_make_not_entrant) { 46992921Simp nmethod* nm = CodeCache::find_nmethod(f->pc()); 47092921Simp assert(nm != NULL, "sanity check"); 4711590Srgrimes nm->make_not_entrant(); 472144467Sharti } 473137605Sharti ++_result; 474144467Sharti } 475144467Sharti } 476137605Sharti } 477137605Sharti } 478137605Sharti } 479137605Sharti}; 480137605Sharti 481137605ShartiWB_ENTRY(jint, WB_DeoptimizeFrames(JNIEnv* env, jobject o, jboolean make_not_entrant)) 482137605Sharti VM_WhiteBoxDeoptimizeFrames op(make_not_entrant == JNI_TRUE); 483137605Sharti VMThread::execute(&op); 484144467Sharti return op.result(); 4851590SrgrimesWB_END 486137252Sharti 4871590SrgrimesWB_ENTRY(void, WB_DeoptimizeAll(JNIEnv* env, jobject o)) 4881590Srgrimes MutexLockerEx mu(Compile_lock); 4891590Srgrimes CodeCache::mark_all_nmethods_for_deoptimization(); 4901590Srgrimes VM_Deoptimize op; 4911590Srgrimes VMThread::execute(&op); 4921590SrgrimesWB_END 493104696Sjmallett 4941590SrgrimesWB_ENTRY(jint, WB_DeoptimizeMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr)) 495144741Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 496144467Sharti int result = 0; 497144467Sharti CHECK_JNI_EXCEPTION_(env, result); 4988874Srgrimes MutexLockerEx mu(Compile_lock); 499144467Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 500144467Sharti if (is_osr) { 501144467Sharti result += mh->mark_osr_nmethods(); 502137605Sharti } else if (mh->code() != NULL) { 503144467Sharti mh->code()->mark_for_deoptimization(); 504144741Sharti ++result; 505144741Sharti } 506144741Sharti result += CodeCache::mark_for_deoptimization(mh()); 507144741Sharti if (result > 0) { 508144741Sharti VM_Deoptimize op; 5091590Srgrimes VMThread::execute(&op); 510144467Sharti } 511144467Sharti return result; 512144467ShartiWB_END 513144467Sharti 514144467ShartiWB_ENTRY(jboolean, WB_IsMethodCompiled(JNIEnv* env, jobject o, jobject method, jboolean is_osr)) 515144467Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 516144467Sharti CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 517144467Sharti MutexLockerEx mu(Compile_lock); 518144657Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 519144467Sharti nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code(); 520144467Sharti if (code == NULL) { 5218874Srgrimes return JNI_FALSE; 522144467Sharti } 523144467Sharti return (code->is_alive() && !code->is_marked_for_deoptimization()); 524144467ShartiWB_END 525144467Sharti 526144467ShartiWB_ENTRY(jboolean, WB_IsMethodCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr)) 527144467Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 5288874Srgrimes CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 529144467Sharti MutexLockerEx mu(Compile_lock); 530144467Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 531144467Sharti if (is_osr) { 532144467Sharti return CompilationPolicy::can_be_osr_compiled(mh, comp_level); 533144467Sharti } else { 534144467Sharti return CompilationPolicy::can_be_compiled(mh, comp_level); 535144467Sharti } 536144467ShartiWB_END 537144467Sharti 538144467ShartiWB_ENTRY(jboolean, WB_IsMethodQueuedForCompilation(JNIEnv* env, jobject o, jobject method)) 539144467Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 5401590Srgrimes CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 541144467Sharti MutexLockerEx mu(Compile_lock); 542144467Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 543144467Sharti return mh->queued_for_compilation(); 5441590SrgrimesWB_END 545144467Sharti 54618730SsteveWB_ENTRY(jboolean, WB_IsIntrinsicAvailable(JNIEnv* env, jobject o, jobject method, jobject compilation_context, jint compLevel)) 547144467Sharti if (compLevel < CompLevel_none || compLevel > CompLevel_highest_tier) { 548144741Sharti return false; // Intrinsic is not available on a non-existent compilation level. 549144741Sharti } 550144741Sharti jmethodID method_id, compilation_context_id; 551144741Sharti method_id = reflected_method_to_jmid(thread, env, method); 552144741Sharti CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 5531590Srgrimes methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(method_id)); 554144467Sharti 555144467Sharti DirectiveSet* directive; 556144467Sharti if (compilation_context != NULL) { 557144467Sharti compilation_context_id = reflected_method_to_jmid(thread, env, compilation_context); 5581590Srgrimes CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 5591590Srgrimes methodHandle cch(THREAD, Method::checked_resolve_jmethod_id(compilation_context_id)); 560144467Sharti directive = DirectivesStack::getMatchingDirective(cch, CompileBroker::compiler((int)compLevel)); 5611590Srgrimes } else { 5621590Srgrimes // Calling with NULL matches default directive 5631590Srgrimes directive = DirectivesStack::getDefaultDirective(CompileBroker::compiler((int)compLevel)); 5641590Srgrimes } 5651590Srgrimes bool result = CompileBroker::compiler(compLevel)->is_intrinsic_available(mh, directive); 5661590Srgrimes DirectivesStack::release(directive); 5671590Srgrimes return result; 5681590SrgrimesWB_END 5691590Srgrimes 5701590SrgrimesWB_ENTRY(jint, WB_GetMethodCompilationLevel(JNIEnv* env, jobject o, jobject method, jboolean is_osr)) 5711590Srgrimes jmethodID jmid = reflected_method_to_jmid(thread, env, method); 57294594Sobrien CHECK_JNI_EXCEPTION_(env, CompLevel_none); 573142993Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 5741590Srgrimes nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code(); 5751590Srgrimes return (code != NULL ? code->comp_level() : CompLevel_none); 5761590SrgrimesWB_END 5771590Srgrimes 5781590SrgrimesWB_ENTRY(void, WB_MakeMethodNotCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr)) 5791590Srgrimes jmethodID jmid = reflected_method_to_jmid(thread, env, method); 5801590Srgrimes CHECK_JNI_EXCEPTION(env); 5811590Srgrimes methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 5821590Srgrimes if (is_osr) { 5831590Srgrimes mh->set_not_osr_compilable(comp_level, true /* report */, "WhiteBox"); 5841590Srgrimes } else { 5851590Srgrimes mh->set_not_compilable(comp_level, true /* report */, "WhiteBox"); 586144741Sharti } 5871590SrgrimesWB_END 588144467Sharti 589141258ShartiWB_ENTRY(jint, WB_GetMethodEntryBci(JNIEnv* env, jobject o, jobject method)) 590141258Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 591144467Sharti CHECK_JNI_EXCEPTION_(env, InvocationEntryBci); 592141258Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 593144467Sharti nmethod* code = mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false); 594141258Sharti return (code != NULL && code->is_osr_method() ? code->osr_entry_bci() : InvocationEntryBci); 595141258ShartiWB_END 596144467Sharti 597144467ShartiWB_ENTRY(jboolean, WB_TestSetDontInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value)) 598144467Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 5991590Srgrimes CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 600144467Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 6011590Srgrimes bool result = mh->dont_inline(); 602144467Sharti mh->set_dont_inline(value == JNI_TRUE); 603144467Sharti return result; 604144467ShartiWB_END 605144467Sharti 606144467ShartiWB_ENTRY(jint, WB_GetCompileQueueSize(JNIEnv* env, jobject o, jint comp_level)) 607144467Sharti if (comp_level == CompLevel_any) { 608144467Sharti return CompileBroker::queue_size(CompLevel_full_optimization) /* C2 */ + 609144467Sharti CompileBroker::queue_size(CompLevel_full_profile) /* C1 */; 6101590Srgrimes } else { 6111590Srgrimes return CompileBroker::queue_size(comp_level); 612144467Sharti } 613144467ShartiWB_END 614144467Sharti 615144467ShartiWB_ENTRY(jboolean, WB_TestSetForceInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value)) 6161590Srgrimes jmethodID jmid = reflected_method_to_jmid(thread, env, method); 617144467Sharti CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 6181590Srgrimes methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 619144467Sharti bool result = mh->force_inline(); 620144467Sharti mh->set_force_inline(value == JNI_TRUE); 621144467Sharti return result; 622144467ShartiWB_END 623144467Sharti 624142457ShartiWB_ENTRY(jboolean, WB_EnqueueMethodForCompilation(JNIEnv* env, jobject o, jobject method, jint comp_level, jint bci)) 625146027Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 626144467Sharti CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 627142457Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 628144467Sharti nmethod* nm = CompileBroker::compile_method(mh, bci, comp_level, mh, mh->invocation_count(), "WhiteBox", THREAD); 6291590Srgrimes MutexLockerEx mu(Compile_lock); 630144467Sharti return (mh->queued_for_compilation() || nm != NULL); 6311590SrgrimesWB_END 632144467Sharti 633144467ShartiWB_ENTRY(jboolean, WB_ShouldPrintAssembly(JNIEnv* env, jobject o, jobject method)) 634144467Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 635144467Sharti CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 636144467Sharti 637144467Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 638132839Sharti DirectiveSet* directive = DirectivesStack::getMatchingDirective(mh, CompileBroker::compiler(CompLevel_simple)); 639144467Sharti bool result = directive->PrintAssemblyOption; 640144467Sharti DirectivesStack::release(directive); 641144467Sharti 642132839Sharti return result; 643144467ShartiWB_END 644144467Sharti 645144467ShartiWB_ENTRY(jint, WB_MatchesInline(JNIEnv* env, jobject o, jobject method, jstring pattern)) 646132839Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 647144467Sharti CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 648144467Sharti 649144467Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 650144467Sharti 651144467Sharti ResourceMark rm; 652144467Sharti const char* error_msg = NULL; 653144467Sharti char* method_str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(pattern)); 654144741Sharti InlineMatcher* m = InlineMatcher::parse_inline_pattern(method_str, error_msg); 655144467Sharti 656144467Sharti if (m == NULL) { 657144467Sharti assert(error_msg != NULL, "Always have an error message"); 658144467Sharti tty->print_cr("Got error: %s", error_msg); 659144467Sharti return -1; // Pattern failed 6601590Srgrimes } 6611590Srgrimes 662144467Sharti // Pattern works - now check if it matches 663144467Sharti int result; 6641590Srgrimes if (m->match(mh, InlineMatcher::force_inline)) { 665144467Sharti result = 2; // Force inline match 666144467Sharti } else if (m->match(mh, InlineMatcher::dont_inline)) { 6671590Srgrimes result = 1; // Dont inline match 66818730Ssteve } else { 6691590Srgrimes result = 0; // No match 670144467Sharti } 6711590Srgrimes delete m; 672144467Sharti return result; 673144467ShartiWB_END 674144467Sharti 675144467ShartiWB_ENTRY(jint, WB_MatchesMethod(JNIEnv* env, jobject o, jobject method, jstring pattern)) 676144467Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 677144467Sharti CHECK_JNI_EXCEPTION_(env, JNI_FALSE); 678144467Sharti 679144467Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 680144467Sharti 681144467Sharti ResourceMark rm; 682144467Sharti char* method_str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(pattern)); 683144467Sharti 684144467Sharti const char* error_msg = NULL; 685144467Sharti 686144467Sharti BasicMatcher* m = BasicMatcher::parse_method_pattern(method_str, error_msg); 687144467Sharti if (m == NULL) { 688144467Sharti assert(error_msg != NULL, "Must have error_msg"); 689144467Sharti tty->print_cr("Got error: %s", error_msg); 690144467Sharti return -1; 691144467Sharti } 692144467Sharti 693144467Sharti // Pattern works - now check if it matches 694144467Sharti int result = m->matches(mh); 695144657Sharti delete m; 696144467Sharti assert(result == 0 || result == 1, "Result out of range"); 697144467Sharti return result; 698144467ShartiWB_END 699144467Sharti 700144467Sharticlass AlwaysFalseClosure : public BoolObjectClosure { 701144467Sharti public: 702144467Sharti bool do_object_b(oop p) { return false; } 703144467Sharti}; 704144467Sharti 705144467Shartistatic AlwaysFalseClosure always_false; 706144467Sharti 707144467ShartiWB_ENTRY(void, WB_ClearMethodState(JNIEnv* env, jobject o, jobject method)) 708144467Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 709144467Sharti CHECK_JNI_EXCEPTION(env); 710144467Sharti methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 711144467Sharti MutexLockerEx mu(Compile_lock); 712144467Sharti MethodData* mdo = mh->method_data(); 713144467Sharti MethodCounters* mcs = mh->method_counters(); 714144467Sharti 715144467Sharti if (mdo != NULL) { 716144467Sharti mdo->init(); 717144467Sharti ResourceMark rm; 718144467Sharti int arg_count = mdo->method()->size_of_parameters(); 719144467Sharti for (int i = 0; i < arg_count; i++) { 720144467Sharti mdo->set_arg_modified(i, 0); 721144467Sharti } 722144467Sharti MutexLockerEx mu(mdo->extra_data_lock()); 723144467Sharti mdo->clean_method_data(&always_false); 724144467Sharti } 725144467Sharti 726144467Sharti mh->clear_not_c1_compilable(); 727144467Sharti mh->clear_not_c2_compilable(); 728144467Sharti mh->clear_not_c2_osr_compilable(); 729144467Sharti NOT_PRODUCT(mh->set_compiled_invocation_count(0)); 730144467Sharti if (mcs != NULL) { 7311590Srgrimes mcs->backedge_counter()->init(); 732144467Sharti mcs->invocation_counter()->init(); 733144467Sharti mcs->set_interpreter_invocation_count(0); 734144467Sharti mcs->set_interpreter_throwout_count(0); 7351590Srgrimes 736144467Sharti#ifdef TIERED 7371590Srgrimes mcs->set_rate(0.0F); 73818730Ssteve mh->set_prev_event_count(0); 7391590Srgrimes mh->set_prev_time(0); 7401590Srgrimes#endif 741144467Sharti } 7421590SrgrimesWB_END 743144467Sharti 744144467Shartitemplate <typename T> 7451590Srgrimesstatic bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, Flag::Error (*TAt)(const char*, T*, bool, bool)) { 746144467Sharti if (name == NULL) { 7471590Srgrimes return false; 7481590Srgrimes } 749144467Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 75018730Ssteve const char* flag_name = env->GetStringUTFChars(name, NULL); 75118730Ssteve Flag::Error result = (*TAt)(flag_name, value, true, true); 75218730Ssteve env->ReleaseStringUTFChars(name, flag_name); 75318730Ssteve return (result == Flag::SUCCESS); 75418730Ssteve} 75518730Ssteve 75618730Sstevetemplate <typename T> 757104696Sjmallettstatic bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, Flag::Error (*TAtPut)(const char*, T*, Flag::Flags)) { 75818730Ssteve if (name == NULL) { 759138232Sharti return false; 760144467Sharti } 761137202Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 762144467Sharti const char* flag_name = env->GetStringUTFChars(name, NULL); 76318730Ssteve Flag::Error result = (*TAtPut)(flag_name, value, Flag::INTERNAL); 764144467Sharti env->ReleaseStringUTFChars(name, flag_name); 765144467Sharti return (result == Flag::SUCCESS); 766144467Sharti} 767144467Sharti 768144467Shartitemplate <typename T> 769144467Shartistatic jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) { 770144467Sharti ResourceMark rm(thread); 771144467Sharti jclass clazz = env->FindClass(name->as_C_string()); 77218730Ssteve CHECK_JNI_EXCEPTION_(env, NULL); 77318730Ssteve jmethodID methodID = env->GetStaticMethodID(clazz, 77418730Ssteve vmSymbols::valueOf_name()->as_C_string(), 775144467Sharti sig->as_C_string()); 7761590Srgrimes CHECK_JNI_EXCEPTION_(env, NULL); 7771590Srgrimes jobject result = env->CallStaticObjectMethod(clazz, methodID, value); 7781590Srgrimes CHECK_JNI_EXCEPTION_(env, NULL); 7791590Srgrimes return result; 7801590Srgrimes} 7811590Srgrimes 7821590Srgrimesstatic jobject booleanBox(JavaThread* thread, JNIEnv* env, jboolean value) { 7831590Srgrimes return box(thread, env, vmSymbols::java_lang_Boolean(), vmSymbols::Boolean_valueOf_signature(), value); 7841590Srgrimes} 7851590Srgrimesstatic jobject integerBox(JavaThread* thread, JNIEnv* env, jint value) { 7861590Srgrimes return box(thread, env, vmSymbols::java_lang_Integer(), vmSymbols::Integer_valueOf_signature(), value); 7871590Srgrimes} 7881590Srgrimesstatic jobject longBox(JavaThread* thread, JNIEnv* env, jlong value) { 7891590Srgrimes return box(thread, env, vmSymbols::java_lang_Long(), vmSymbols::Long_valueOf_signature(), value); 7901590Srgrimes} 7911590Srgrimes/* static jobject floatBox(JavaThread* thread, JNIEnv* env, jfloat value) { 7921590Srgrimes return box(thread, env, vmSymbols::java_lang_Float(), vmSymbols::Float_valueOf_signature(), value); 7931590Srgrimes}*/ 794104696Sjmallettstatic jobject doubleBox(JavaThread* thread, JNIEnv* env, jdouble value) { 7951590Srgrimes return box(thread, env, vmSymbols::java_lang_Double(), vmSymbols::Double_valueOf_signature(), value); 796144467Sharti} 797144467Sharti 7981590Srgrimesstatic Flag* getVMFlag(JavaThread* thread, JNIEnv* env, jstring name) { 799144657Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 800144657Sharti const char* flag_name = env->GetStringUTFChars(name, NULL); 801144657Sharti Flag* result = Flag::find_flag(flag_name, strlen(flag_name), true, true); 802144467Sharti env->ReleaseStringUTFChars(name, flag_name); 803144467Sharti return result; 804144467Sharti} 805144467Sharti 806144467ShartiWB_ENTRY(jboolean, WB_IsConstantVMFlag(JNIEnv* env, jobject o, jstring name)) 807144467Sharti Flag* flag = getVMFlag(thread, env, name); 808144467Sharti return (flag != NULL) && flag->is_constant_in_binary(); 809144467ShartiWB_END 810144467Sharti 811144467ShartiWB_ENTRY(jboolean, WB_IsLockedVMFlag(JNIEnv* env, jobject o, jstring name)) 812144467Sharti Flag* flag = getVMFlag(thread, env, name); 813144467Sharti return (flag != NULL) && !(flag->is_unlocked() || flag->is_unlocker()); 8148874SrgrimesWB_END 815144467Sharti 816144467ShartiWB_ENTRY(jobject, WB_GetBooleanVMFlag(JNIEnv* env, jobject o, jstring name)) 817144467Sharti bool result; 818144467Sharti if (GetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAt)) { 819144467Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 820144467Sharti return booleanBox(thread, env, result); 821144467Sharti } 822144467Sharti return NULL; 823144467ShartiWB_END 8248874Srgrimes 825144467ShartiWB_ENTRY(jobject, WB_GetIntVMFlag(JNIEnv* env, jobject o, jstring name)) 826144467Sharti int result; 827144467Sharti if (GetVMFlag <int> (thread, env, name, &result, &CommandLineFlags::intAt)) { 828144467Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 829144467Sharti return longBox(thread, env, result); 830144467Sharti } 8311590Srgrimes return NULL; 832144467ShartiWB_END 833144467Sharti 834144467ShartiWB_ENTRY(jobject, WB_GetUintVMFlag(JNIEnv* env, jobject o, jstring name)) 835144467Sharti uint result; 8361590Srgrimes if (GetVMFlag <uint> (thread, env, name, &result, &CommandLineFlags::uintAt)) { 8371590Srgrimes ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 838144467Sharti return longBox(thread, env, result); 839144657Sharti } 840144467Sharti return NULL; 841144467ShartiWB_END 842144467Sharti 843144467ShartiWB_ENTRY(jobject, WB_GetIntxVMFlag(JNIEnv* env, jobject o, jstring name)) 844144467Sharti intx result; 845144467Sharti if (GetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAt)) { 846144467Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 847144467Sharti return longBox(thread, env, result); 848144467Sharti } 849144467Sharti return NULL; 850144467ShartiWB_END 851144467Sharti 852144467ShartiWB_ENTRY(jobject, WB_GetUintxVMFlag(JNIEnv* env, jobject o, jstring name)) 853144467Sharti uintx result; 8541590Srgrimes if (GetVMFlag <uintx> (thread, env, name, &result, &CommandLineFlags::uintxAt)) { 8551590Srgrimes ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 856144467Sharti return longBox(thread, env, result); 857144665Sharti } 858144665Sharti return NULL; 859144467ShartiWB_END 860144467Sharti 861144467ShartiWB_ENTRY(jobject, WB_GetUint64VMFlag(JNIEnv* env, jobject o, jstring name)) 862144467Sharti uint64_t result; 863144467Sharti if (GetVMFlag <uint64_t> (thread, env, name, &result, &CommandLineFlags::uint64_tAt)) { 864144467Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 865144467Sharti return longBox(thread, env, result); 866144467Sharti } 867144467Sharti return NULL; 868144467ShartiWB_END 869144467Sharti 870144467ShartiWB_ENTRY(jobject, WB_GetSizeTVMFlag(JNIEnv* env, jobject o, jstring name)) 871144467Sharti uintx result; 872144467Sharti if (GetVMFlag <size_t> (thread, env, name, &result, &CommandLineFlags::size_tAt)) { 873144467Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 874144467Sharti return longBox(thread, env, result); 875144467Sharti } 876144467Sharti return NULL; 877144467ShartiWB_END 878144467Sharti 879144467ShartiWB_ENTRY(jobject, WB_GetDoubleVMFlag(JNIEnv* env, jobject o, jstring name)) 880144467Sharti double result; 881144665Sharti if (GetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAt)) { 882144665Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 883144467Sharti return doubleBox(thread, env, result); 884144467Sharti } 885144467Sharti return NULL; 886144467ShartiWB_END 887144467Sharti 888144467ShartiWB_ENTRY(jstring, WB_GetStringVMFlag(JNIEnv* env, jobject o, jstring name)) 889144467Sharti ccstr ccstrResult; 890144494Sharti if (GetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAt)) { 891144467Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 892144467Sharti jstring result = env->NewStringUTF(ccstrResult); 893144467Sharti CHECK_JNI_EXCEPTION_(env, NULL); 894144467Sharti return result; 895144467Sharti } 896144467Sharti return NULL; 897144467ShartiWB_END 898144467Sharti 899144467ShartiWB_ENTRY(void, WB_SetBooleanVMFlag(JNIEnv* env, jobject o, jstring name, jboolean value)) 900144467Sharti bool result = value == JNI_TRUE ? true : false; 901144657Sharti SetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAtPut); 902144467ShartiWB_END 903144467Sharti 904144467ShartiWB_ENTRY(void, WB_SetIntVMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 905144467Sharti int result = value; 906144467Sharti SetVMFlag <int> (thread, env, name, &result, &CommandLineFlags::intAtPut); 907144467ShartiWB_END 908144467Sharti 909144665ShartiWB_ENTRY(void, WB_SetUintVMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 910144665Sharti uint result = value; 91118730Ssteve SetVMFlag <uint> (thread, env, name, &result, &CommandLineFlags::uintAtPut); 912144467ShartiWB_END 913144467Sharti 914144467ShartiWB_ENTRY(void, WB_SetIntxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 915144467Sharti intx result = value; 916144467Sharti SetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAtPut); 917144467ShartiWB_END 918144467Sharti 919144467ShartiWB_ENTRY(void, WB_SetUintxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 92018730Ssteve uintx result = value; 921144467Sharti SetVMFlag <uintx> (thread, env, name, &result, &CommandLineFlags::uintxAtPut); 922144467ShartiWB_END 923144494Sharti 924144467ShartiWB_ENTRY(void, WB_SetUint64VMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 925144665Sharti uint64_t result = value; 926144665Sharti SetVMFlag <uint64_t> (thread, env, name, &result, &CommandLineFlags::uint64_tAtPut); 927144467ShartiWB_END 928144467Sharti 929144467ShartiWB_ENTRY(void, WB_SetSizeTVMFlag(JNIEnv* env, jobject o, jstring name, jlong value)) 930144467Sharti size_t result = value; 931144467Sharti SetVMFlag <size_t> (thread, env, name, &result, &CommandLineFlags::size_tAtPut); 932144467ShartiWB_END 9331590Srgrimes 934144467ShartiWB_ENTRY(void, WB_SetDoubleVMFlag(JNIEnv* env, jobject o, jstring name, jdouble value)) 935144467Sharti double result = value; 936144467Sharti SetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAtPut); 937144467ShartiWB_END 938144467Sharti 939144467ShartiWB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value)) 940144467Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 9411590Srgrimes const char* ccstrValue = (value == NULL) ? NULL : env->GetStringUTFChars(value, NULL); 942144467Sharti ccstr ccstrResult = ccstrValue; 9431590Srgrimes bool needFree; 9441590Srgrimes { 9451590Srgrimes ThreadInVMfromNative ttvfn(thread); // back to VM 946144467Sharti needFree = SetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAtPut); 947144467Sharti } 948144467Sharti if (value != NULL) { 9491590Srgrimes env->ReleaseStringUTFChars(value, ccstrValue); 950144467Sharti } 951144467Sharti if (needFree) { 952144467Sharti FREE_C_HEAP_ARRAY(char, ccstrResult); 953144467Sharti } 954144467ShartiWB_END 955144467Sharti 956144467ShartiWB_ENTRY(void, WB_LockCompilation(JNIEnv* env, jobject o, jlong timeout)) 957144467Sharti WhiteBox::compilation_locked = true; 958144467ShartiWB_END 959144467Sharti 960144467ShartiWB_ENTRY(void, WB_UnlockCompilation(JNIEnv* env, jobject o)) 961144467Sharti MonitorLockerEx mo(Compilation_lock, Mutex::_no_safepoint_check_flag); 962144467Sharti WhiteBox::compilation_locked = false; 963144467Sharti mo.notify_all(); 964144467ShartiWB_END 965144467Sharti 966144467ShartiWB_ENTRY(void, WB_ForceNMethodSweep(JNIEnv* env, jobject o)) 967144467Sharti // Force a code cache sweep and block until it finished 968144467Sharti NMethodSweeper::force_sweep(); 969144467ShartiWB_END 970144467Sharti 971144467ShartiWB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString)) 972144467Sharti ResourceMark rm(THREAD); 973144467Sharti int len; 974144467Sharti jchar* name = java_lang_String::as_unicode_string(JNIHandles::resolve(javaString), len, CHECK_false); 975144467Sharti return (StringTable::lookup(name, len) != NULL); 9761590SrgrimesWB_END 977143703Sharti 978144657ShartiWB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o)) 979144657Sharti Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(true); 980144467Sharti Universe::heap()->collect(GCCause::_last_ditch_collection); 981144467Sharti#if INCLUDE_ALL_GCS 982144467Sharti if (UseG1GC) { 983144467Sharti // Needs to be cleared explicitly for G1 984144467Sharti Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(false); 985144467Sharti } 986144467Sharti#endif // INCLUDE_ALL_GCS 987144467ShartiWB_END 988146027Sharti 989146027ShartiWB_ENTRY(void, WB_YoungGC(JNIEnv* env, jobject o)) 990144467Sharti Universe::heap()->collect(GCCause::_wb_young_gc); 9911590SrgrimesWB_END 992144467Sharti 993144467ShartiWB_ENTRY(void, WB_ReadReservedMemory(JNIEnv* env, jobject o)) 994144467Sharti // static+volatile in order to force the read to happen 9951590Srgrimes // (not be eliminated by the compiler) 996144467Sharti static char c; 997144467Sharti static volatile char* p; 998144467Sharti 999144467Sharti p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0); 1000144467Sharti if (p == NULL) { 1001144467Sharti THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory"); 1002144467Sharti } 10031590Srgrimes 1004144467Sharti c = *p; 10051590SrgrimesWB_END 1006144657Sharti 1007144467ShartiWB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o)) 1008144467Sharti const char* cpu_features = VM_Version::cpu_features(); 1009144467Sharti ThreadToNativeFromVM ttn(thread); 1010144467Sharti jstring features_string = env->NewStringUTF(cpu_features); 1011144467Sharti 1012144467Sharti CHECK_JNI_EXCEPTION_(env, NULL); 1013144467Sharti 10148874Srgrimes return features_string; 1015144657ShartiWB_END 1016144467Sharti 1017144467Shartiint WhiteBox::get_blob_type(const CodeBlob* code) { 1018144467Sharti guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled"); 1019144467Sharti return CodeCache::get_code_heap(code)->code_blob_type(); 1020144467Sharti} 10211590Srgrimes 10221590SrgrimesCodeHeap* WhiteBox::get_code_heap(int blob_type) { 1023144467Sharti guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled"); 1024144467Sharti return CodeCache::get_code_heap(blob_type); 10251590Srgrimes} 1026104696Sjmallett 10271590Srgrimesstruct CodeBlobStub { 10281590Srgrimes CodeBlobStub(const CodeBlob* blob) : 10291590Srgrimes name(os::strdup(blob->name())), 10301590Srgrimes size(blob->size()), 10311590Srgrimes blob_type(WhiteBox::get_blob_type(blob)), 10321590Srgrimes address((jlong) blob) { } 1033104696Sjmallett ~CodeBlobStub() { os::free((void*) name); } 10341590Srgrimes const char* const name; 1035144467Sharti const jint size; 1036144467Sharti const jint blob_type; 10371590Srgrimes const jlong address; 1038144467Sharti}; 1039144467Sharti 1040144467Shartistatic jobjectArray codeBlob2objectArray(JavaThread* thread, JNIEnv* env, CodeBlobStub* cb) { 1041144467Sharti jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string()); 1042144467Sharti CHECK_JNI_EXCEPTION_(env, NULL); 1043144467Sharti jobjectArray result = env->NewObjectArray(4, clazz, NULL); 1044144467Sharti 10458874Srgrimes jstring name = env->NewStringUTF(cb->name); 1046144467Sharti CHECK_JNI_EXCEPTION_(env, NULL); 1047144467Sharti env->SetObjectArrayElement(result, 0, name); 1048144467Sharti 1049144467Sharti jobject obj = integerBox(thread, env, cb->size); 10501590Srgrimes CHECK_JNI_EXCEPTION_(env, NULL); 1051144467Sharti env->SetObjectArrayElement(result, 1, obj); 1052144467Sharti 1053144467Sharti obj = integerBox(thread, env, cb->blob_type); 10541590Srgrimes CHECK_JNI_EXCEPTION_(env, NULL); 1055144467Sharti env->SetObjectArrayElement(result, 2, obj); 1056144467Sharti 1057144467Sharti obj = longBox(thread, env, cb->address); 1058144467Sharti CHECK_JNI_EXCEPTION_(env, NULL); 1059144467Sharti env->SetObjectArrayElement(result, 3, obj); 1060144467Sharti 10611590Srgrimes return result; 1062144467Sharti} 1063144467Sharti 1064144467ShartiWB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr)) 10651590Srgrimes ResourceMark rm(THREAD); 1066144467Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1067144467Sharti CHECK_JNI_EXCEPTION_(env, NULL); 10681590Srgrimes methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid)); 1069144467Sharti nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code(); 1070144467Sharti jobjectArray result = NULL; 1071144467Sharti if (code == NULL) { 1072144467Sharti return result; 1073144467Sharti } 1074144467Sharti int insts_size = code->insts_size(); 1075144467Sharti 1076144467Sharti ThreadToNativeFromVM ttn(thread); 1077144467Sharti jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string()); 1078144467Sharti CHECK_JNI_EXCEPTION_(env, NULL); 1079144467Sharti result = env->NewObjectArray(5, clazz, NULL); 1080144467Sharti if (result == NULL) { 1081144467Sharti return result; 1082144467Sharti } 1083144467Sharti 10841590Srgrimes CodeBlobStub stub(code); 10851590Srgrimes jobjectArray codeBlob = codeBlob2objectArray(thread, env, &stub); 10861590Srgrimes env->SetObjectArrayElement(result, 0, codeBlob); 10871590Srgrimes 1088144467Sharti jobject level = integerBox(thread, env, code->comp_level()); 1089144467Sharti CHECK_JNI_EXCEPTION_(env, NULL); 10908874Srgrimes env->SetObjectArrayElement(result, 1, level); 10911590Srgrimes 10921590Srgrimes jbyteArray insts = env->NewByteArray(insts_size); 10931590Srgrimes CHECK_JNI_EXCEPTION_(env, NULL); 10941590Srgrimes env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin()); 10951590Srgrimes env->SetObjectArrayElement(result, 2, insts); 10961590Srgrimes 10971590Srgrimes jobject id = integerBox(thread, env, code->compile_id()); 10981590Srgrimes CHECK_JNI_EXCEPTION_(env, NULL); 10991590Srgrimes env->SetObjectArrayElement(result, 3, id); 1100104696Sjmallett 11011590Srgrimes jobject entry_point = longBox(thread, env, (jlong) code->entry_point()); 1102138232Sharti CHECK_JNI_EXCEPTION_(env, NULL); 1103144467Sharti env->SetObjectArrayElement(result, 4, entry_point); 1104144467Sharti 1105144467Sharti return result; 1106144467ShartiWB_END 1107144467Sharti 1108144467ShartiCodeBlob* WhiteBox::allocate_code_blob(int size, int blob_type) { 1109144657Sharti guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled"); 1110144467Sharti BufferBlob* blob; 1111144467Sharti int full_size = CodeBlob::align_code_offset(sizeof(BufferBlob)); 1112144467Sharti if (full_size < size) { 1113144467Sharti full_size += round_to(size - full_size, oopSize); 1114144467Sharti } 1115144467Sharti { 1116144467Sharti MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 1117144467Sharti blob = (BufferBlob*) CodeCache::allocate(full_size, blob_type); 1118144467Sharti ::new (blob) BufferBlob("WB::DummyBlob", full_size); 1119144467Sharti } 1120144467Sharti // Track memory usage statistic after releasing CodeCache_lock 1121144467Sharti MemoryService::track_code_cache_memory_usage(); 1122144467Sharti return blob; 1123144467Sharti} 112418730Ssteve 1125144467ShartiWB_ENTRY(jlong, WB_AllocateCodeBlob(JNIEnv* env, jobject o, jint size, jint blob_type)) 1126144467Sharti if (size < 0) { 1127144467Sharti THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 1128144467Sharti err_msg("WB_AllocateCodeBlob: size is negative: " INT32_FORMAT, size)); 1129144467Sharti } 1130144467Sharti return (jlong) WhiteBox::allocate_code_blob(size, blob_type); 1131144467ShartiWB_END 1132144467Sharti 1133144467ShartiWB_ENTRY(void, WB_FreeCodeBlob(JNIEnv* env, jobject o, jlong addr)) 1134144467Sharti if (addr == 0) { 1135144467Sharti return; 1136144467Sharti } 1137144467Sharti BufferBlob::free((BufferBlob*) addr); 1138144467ShartiWB_END 1139144467Sharti 1140144467ShartiWB_ENTRY(jobjectArray, WB_GetCodeHeapEntries(JNIEnv* env, jobject o, jint blob_type)) 1141144467Sharti ResourceMark rm; 1142144467Sharti GrowableArray<CodeBlobStub*> blobs; 1143144467Sharti { 1144144467Sharti MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 1145144467Sharti CodeHeap* heap = WhiteBox::get_code_heap(blob_type); 1146144467Sharti if (heap == NULL) { 114735483Simp return NULL; 1148144467Sharti } 1149144467Sharti for (CodeBlob* cb = (CodeBlob*) heap->first(); 1150144467Sharti cb != NULL; cb = (CodeBlob*) heap->next(cb)) { 115135483Simp CodeBlobStub* stub = NEW_RESOURCE_OBJ(CodeBlobStub); 1152144467Sharti new (stub) CodeBlobStub(cb); 1153144467Sharti blobs.append(stub); 1154144467Sharti } 1155144467Sharti } 1156144467Sharti if (blobs.length() == 0) { 11571590Srgrimes return NULL; 1158144467Sharti } 11591590Srgrimes ThreadToNativeFromVM ttn(thread); 11601590Srgrimes jobjectArray result = NULL; 1161144467Sharti jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string()); 1162144467Sharti CHECK_JNI_EXCEPTION_(env, NULL); 11631590Srgrimes result = env->NewObjectArray(blobs.length(), clazz, NULL); 11641590Srgrimes if (result == NULL) { 11651590Srgrimes return result; 11661590Srgrimes } 11671590Srgrimes int i = 0; 11681590Srgrimes for (GrowableArrayIterator<CodeBlobStub*> it = blobs.begin(); 11691590Srgrimes it != blobs.end(); ++it) { 11701590Srgrimes jobjectArray obj = codeBlob2objectArray(thread, env, *it); 1171104696Sjmallett env->SetObjectArrayElement(result, i, obj); 11721590Srgrimes ++i; 1173146061Sharti } 11748874Srgrimes return result; 1175144467ShartiWB_END 1176146061Sharti 11778874SrgrimesWB_ENTRY(jint, WB_GetCompilationActivityMode(JNIEnv* env, jobject o)) 1178144467Sharti return CompileBroker::get_compilation_activity_mode(); 1179144467ShartiWB_END 1180144467Sharti 1181144467ShartiWB_ENTRY(jobjectArray, WB_GetCodeBlob(JNIEnv* env, jobject o, jlong addr)) 1182144467Sharti if (addr == 0) { 1183144467Sharti THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(), 11841590Srgrimes "WB_GetCodeBlob: addr is null"); 11858874Srgrimes } 11861590Srgrimes ThreadToNativeFromVM ttn(thread); 1187144467Sharti CodeBlobStub stub((CodeBlob*) addr); 1188144467Sharti return codeBlob2objectArray(thread, env, &stub); 1189144467ShartiWB_END 1190144467Sharti 11911590SrgrimesWB_ENTRY(jlong, WB_GetMethodData(JNIEnv* env, jobject wv, jobject method)) 1192144657Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1193144467Sharti CHECK_JNI_EXCEPTION_(env, 0); 1194144467Sharti methodHandle mh(thread, Method::checked_resolve_jmethod_id(jmid)); 1195144467Sharti return (jlong) mh->method_data(); 11961590SrgrimesWB_END 11971590Srgrimes 1198146058ShartiWB_ENTRY(jlong, WB_GetThreadStackSize(JNIEnv* env, jobject o)) 1199144467Sharti return (jlong) Thread::current()->stack_size(); 1200146058ShartiWB_END 1201144467Sharti 1202144665ShartiWB_ENTRY(jlong, WB_GetThreadRemainingStackSize(JNIEnv* env, jobject o)) 1203144665Sharti JavaThread* t = JavaThread::current(); 1204144665Sharti return (jlong) t->stack_available(os::current_stack_pointer()) - (jlong) StackShadowPages * os::vm_page_size(); 1205144665ShartiWB_END 1206144467Sharti 1207144467Sharti 1208144467Shartiint WhiteBox::array_bytes_to_length(size_t bytes) { 1209144467Sharti return Array<u1>::bytes_to_length(bytes); 1210144467Sharti} 1211144467Sharti 1212144467ShartiWB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size)) 1213144467Sharti if (size < 0) { 1214144467Sharti THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 1215144467Sharti err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size)); 1216144467Sharti } 1217144467Sharti 1218144467Sharti oop class_loader_oop = JNIHandles::resolve(class_loader); 1219144467Sharti ClassLoaderData* cld = class_loader_oop != NULL 1220144467Sharti ? java_lang_ClassLoader::loader_data(class_loader_oop) 1221144467Sharti : ClassLoaderData::the_null_class_loader_data(); 1222144467Sharti 1223144467Sharti void* metadata = MetadataFactory::new_writeable_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread); 1224144467Sharti 1225144467Sharti return (jlong)(uintptr_t)metadata; 1226144467ShartiWB_END 1227144467Sharti 1228144467ShartiWB_ENTRY(void, WB_FreeMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong addr, jlong size)) 1229144467Sharti oop class_loader_oop = JNIHandles::resolve(class_loader); 1230144467Sharti ClassLoaderData* cld = class_loader_oop != NULL 1231144467Sharti ? java_lang_ClassLoader::loader_data(class_loader_oop) 1232144467Sharti : ClassLoaderData::the_null_class_loader_data(); 1233144467Sharti 1234144467Sharti MetadataFactory::free_array(cld, (Array<u1>*)(uintptr_t)addr); 1235144467ShartiWB_END 1236144467Sharti 1237144467ShartiWB_ENTRY(jlong, WB_IncMetaspaceCapacityUntilGC(JNIEnv* env, jobject wb, jlong inc)) 1238144467Sharti if (inc < 0) { 1239144467Sharti THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 1240144467Sharti err_msg("WB_IncMetaspaceCapacityUntilGC: inc is negative: " JLONG_FORMAT, inc)); 1241144467Sharti } 1242144467Sharti 1243144467Sharti jlong max_size_t = (jlong) ((size_t) -1); 1244144467Sharti if (inc > max_size_t) { 1245144467Sharti THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), 12461590Srgrimes err_msg("WB_IncMetaspaceCapacityUntilGC: inc does not fit in size_t: " JLONG_FORMAT, inc)); 1247144467Sharti } 1248144467Sharti 1249144467Sharti size_t new_cap_until_GC = 0; 1250144467Sharti size_t aligned_inc = align_size_down((size_t) inc, Metaspace::commit_alignment()); 1251144467Sharti bool success = MetaspaceGC::inc_capacity_until_GC(aligned_inc, &new_cap_until_GC); 125218730Ssteve if (!success) { 1253144467Sharti THROW_MSG_0(vmSymbols::java_lang_IllegalStateException(), 125418730Ssteve "WB_IncMetaspaceCapacityUntilGC: could not increase capacity until GC " 1255144467Sharti "due to contention with another thread"); 125618730Ssteve } 125718730Ssteve return (jlong) new_cap_until_GC; 12588874SrgrimesWB_END 1259144467Sharti 12601590SrgrimesWB_ENTRY(jlong, WB_MetaspaceCapacityUntilGC(JNIEnv* env, jobject wb)) 1261144467Sharti return (jlong) MetaspaceGC::capacity_until_GC(); 1262144467ShartiWB_END 1263144467Sharti 1264144665Sharti 1265144665Sharti 1266144665ShartiWB_ENTRY(void, WB_AssertMatchingSafepointCalls(JNIEnv* env, jobject o, jboolean mutexSafepointValue, jboolean attemptedNoSafepointValue)) 1267144665Sharti Monitor::SafepointCheckRequired sfpt_check_required = mutexSafepointValue ? 1268144665Sharti Monitor::_safepoint_check_always : 1269144467Sharti Monitor::_safepoint_check_never; 1270144665Sharti MutexLockerEx ml(new Mutex(Mutex::leaf, "SFPT_Test_lock", true, sfpt_check_required), 1271144665Sharti attemptedNoSafepointValue == JNI_TRUE); 1272144665ShartiWB_END 1273144665Sharti 1274144665ShartiWB_ENTRY(jboolean, WB_IsMonitorInflated(JNIEnv* env, jobject wb, jobject obj)) 1275144665Sharti oop obj_oop = JNIHandles::resolve(obj); 1276104475Sphk return (jboolean) obj_oop->mark()->has_monitor(); 1277144665ShartiWB_END 1278104475Sphk 1279144665ShartiWB_ENTRY(void, WB_ForceSafepoint(JNIEnv* env, jobject wb)) 12808874Srgrimes VM_ForceSafepoint force_safepoint_op; 1281137202Sharti VMThread::execute(&force_safepoint_op); 1282144665ShartiWB_END 1283144665Sharti 1284144665ShartiWB_ENTRY(jlong, WB_GetConstantPool(JNIEnv* env, jobject wb, jclass klass)) 1285144665Sharti instanceKlassHandle ikh(java_lang_Class::as_Klass(JNIHandles::resolve(klass))); 1286144665Sharti return (jlong) ikh->constants(); 1287144665ShartiWB_END 1288144665Sharti 1289144665Shartitemplate <typename T> 1290144665Shartistatic bool GetMethodOption(JavaThread* thread, JNIEnv* env, jobject method, jstring name, T* value) { 1291144665Sharti assert(value != NULL, "sanity"); 1292144665Sharti if (method == NULL || name == NULL) { 12931590Srgrimes return false; 1294144665Sharti } 1295137202Sharti jmethodID jmid = reflected_method_to_jmid(thread, env, method); 1296144665Sharti CHECK_JNI_EXCEPTION_(env, false); 1297144467Sharti methodHandle mh(thread, Method::checked_resolve_jmethod_id(jmid)); 1298144665Sharti // can't be in VM when we call JNI 1299144665Sharti ThreadToNativeFromVM ttnfv(thread); 1300144665Sharti const char* flag_name = env->GetStringUTFChars(name, NULL); 13011590Srgrimes bool result = CompilerOracle::has_option_value(mh, flag_name, *value); 13021590Srgrimes env->ReleaseStringUTFChars(name, flag_name); 1303144467Sharti return result; 1304144467Sharti} 1305144467Sharti 1306144467ShartiWB_ENTRY(jobject, WB_GetMethodBooleaneOption(JNIEnv* env, jobject wb, jobject method, jstring name)) 1307144494Sharti bool result; 1308144467Sharti if (GetMethodOption<bool> (thread, env, method, name, &result)) { 1309144467Sharti // can't be in VM when we call JNI 13101590Srgrimes ThreadToNativeFromVM ttnfv(thread); 13111590Srgrimes return booleanBox(thread, env, result); 13121590Srgrimes } 1313144467Sharti return NULL; 1314144467ShartiWB_END 13151590Srgrimes 13161590SrgrimesWB_ENTRY(jobject, WB_GetMethodIntxOption(JNIEnv* env, jobject wb, jobject method, jstring name)) 13171590Srgrimes intx result; 1318104696Sjmallett if (GetMethodOption <intx> (thread, env, method, name, &result)) { 13191590Srgrimes // can't be in VM when we call JNI 1320144467Sharti ThreadToNativeFromVM ttnfv(thread); 1321144467Sharti return longBox(thread, env, result); 13228874Srgrimes } 1323144467Sharti return NULL; 1324144467ShartiWB_END 13251590Srgrimes 1326144657ShartiWB_ENTRY(jobject, WB_GetMethodUintxOption(JNIEnv* env, jobject wb, jobject method, jstring name)) 1327144657Sharti uintx result; 1328144467Sharti if (GetMethodOption <uintx> (thread, env, method, name, &result)) { 1329144467Sharti // can't be in VM when we call JNI 1330144467Sharti ThreadToNativeFromVM ttnfv(thread); 1331144467Sharti return longBox(thread, env, result); 1332144467Sharti } 1333144467Sharti return NULL; 1334144467ShartiWB_END 1335144657Sharti 1336144657ShartiWB_ENTRY(jobject, WB_GetMethodDoubleOption(JNIEnv* env, jobject wb, jobject method, jstring name)) 1337144657Sharti double result; 1338144657Sharti if (GetMethodOption <double> (thread, env, method, name, &result)) { 13391590Srgrimes // can't be in VM when we call JNI 1340144467Sharti ThreadToNativeFromVM ttnfv(thread); 1341144467Sharti return doubleBox(thread, env, result); 1342144467Sharti } 1343144467Sharti return NULL; 1344144467ShartiWB_END 1345144467Sharti 1346144467ShartiWB_ENTRY(jobject, WB_GetMethodStringOption(JNIEnv* env, jobject wb, jobject method, jstring name)) 1347144467Sharti ccstr ccstrResult; 1348144467Sharti if (GetMethodOption <ccstr> (thread, env, method, name, &ccstrResult)) { 1349144467Sharti // can't be in VM when we call JNI 1350144467Sharti ThreadToNativeFromVM ttnfv(thread); 1351144467Sharti jstring result = env->NewStringUTF(ccstrResult); 1352144467Sharti CHECK_JNI_EXCEPTION_(env, NULL); 13531590Srgrimes return result; 1354144467Sharti } 13551590Srgrimes return NULL; 13561590SrgrimesWB_END 1357144467Sharti 1358144467ShartiWB_ENTRY(jboolean, WB_IsShared(JNIEnv* env, jobject wb, jobject obj)) 1359144494Sharti oop obj_oop = JNIHandles::resolve(obj); 1360144494Sharti return MetaspaceShared::is_in_shared_space((void*)obj_oop); 13611590SrgrimesWB_END 13621590Srgrimes 13631590SrgrimesWB_ENTRY(jboolean, WB_AreSharedStringsIgnored(JNIEnv* env)) 13641590Srgrimes return StringTable::shared_string_ignored(); 13651590SrgrimesWB_END 1366104696Sjmallett 13671590Srgrimes//Some convenience methods to deal with objects from java 136818730Ssteveint WhiteBox::offset_for_field(const char* field_name, oop object, 1369144467Sharti Symbol* signature_symbol) { 1370144467Sharti assert(field_name != NULL && strlen(field_name) > 0, "Field name not valid"); 1371144467Sharti Thread* THREAD = Thread::current(); 1372144467Sharti 1373144467Sharti //Get the class of our object 1374144467Sharti Klass* arg_klass = object->klass(); 1375144467Sharti //Turn it into an instance-klass 1376144467Sharti InstanceKlass* ik = InstanceKlass::cast(arg_klass); 1377144467Sharti 1378144467Sharti //Create symbols to look for in the class 1379144467Sharti TempNewSymbol name_symbol = SymbolTable::lookup(field_name, (int) strlen(field_name), 13808874Srgrimes THREAD); 1381144467Sharti 13828874Srgrimes //To be filled in with an offset of the field we're looking for 1383144467Sharti fieldDescriptor fd; 1384144657Sharti 1385144467Sharti Klass* res = ik->find_field(name_symbol, signature_symbol, &fd); 1386144657Sharti if (res == NULL) { 1387144657Sharti tty->print_cr("Invalid layout of %s at %s", ik->external_name(), 1388144467Sharti name_symbol->as_C_string()); 1389144467Sharti vm_exit_during_initialization("Invalid layout of preloaded class: use -XX:+TraceClassLoading to see the origin of the problem class"); 1390144494Sharti } 1391144467Sharti 1392144467Sharti //fetch the field at the offset we've found 1393144467Sharti int dest_offset = fd.offset(); 1394144467Sharti 1395144467Sharti return dest_offset; 1396144467Sharti} 1397144467Sharti 1398144467Sharti 1399144467Sharticonst char* WhiteBox::lookup_jstring(const char* field_name, oop object) { 1400144467Sharti int offset = offset_for_field(field_name, object, 1401144467Sharti vmSymbols::string_signature()); 1402137202Sharti oop string = object->obj_field(offset); 14031590Srgrimes if (string == NULL) { 1404144467Sharti return NULL; 1405144467Sharti } 14061590Srgrimes const char* ret = java_lang_String::as_utf8_string(string); 1407144467Sharti return ret; 1408144657Sharti} 1409144657Sharti 1410144467Shartibool WhiteBox::lookup_bool(const char* field_name, oop object) { 1411144467Sharti int offset = 1412144467Sharti offset_for_field(field_name, object, vmSymbols::bool_signature()); 1413144467Sharti bool ret = (object->bool_field(offset) == JNI_TRUE); 1414144467Sharti return ret; 1415144467Sharti} 1416144467Sharti 14178874Srgrimesvoid WhiteBox::register_methods(JNIEnv* env, jclass wbclass, JavaThread* thread, JNINativeMethod* method_array, int method_count) { 1418144467Sharti ResourceMark rm; 1419144467Sharti ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI 1420144467Sharti 1421144467Sharti // one by one registration natives for exception catching 1422144467Sharti jclass no_such_method_error_klass = env->FindClass(vmSymbols::java_lang_NoSuchMethodError()->as_C_string()); 1423144467Sharti CHECK_JNI_EXCEPTION(env); 1424144467Sharti for (int i = 0, n = method_count; i < n; ++i) { 1425144467Sharti // Skip dummy entries 1426144467Sharti if (method_array[i].fnPtr == NULL) continue; 1427144467Sharti if (env->RegisterNatives(wbclass, &method_array[i], 1) != 0) { 1428144467Sharti jthrowable throwable_obj = env->ExceptionOccurred(); 1429144467Sharti if (throwable_obj != NULL) { 1430144467Sharti env->ExceptionClear(); 1431144467Sharti if (env->IsInstanceOf(throwable_obj, no_such_method_error_klass)) { 1432144467Sharti // NoSuchMethodError is thrown when a method can't be found or a method is not native. 1433144467Sharti // Ignoring the exception since it is not preventing use of other WhiteBox methods. 1434144467Sharti tty->print_cr("Warning: 'NoSuchMethodError' on register of sun.hotspot.WhiteBox::%s%s", 1435144467Sharti method_array[i].name, method_array[i].signature); 1436144467Sharti } 1437144467Sharti } else { 1438144467Sharti // Registration failed unexpectedly. 1439144467Sharti tty->print_cr("Warning: unexpected error on register of sun.hotspot.WhiteBox::%s%s. All methods will be unregistered", 1440144467Sharti method_array[i].name, method_array[i].signature); 1441144467Sharti env->UnregisterNatives(wbclass); 1442144467Sharti break; 1443144467Sharti } 1444144467Sharti } 1445144467Sharti } 1446144494Sharti} 1447144467Sharti 1448144467Sharti#define CC (char*) 1449144467Sharti 14501590Srgrimesstatic JNINativeMethod methods[] = { 14511590Srgrimes {CC"getObjectAddress0", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectAddress }, 14521590Srgrimes {CC"getObjectSize0", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectSize }, 1453144467Sharti {CC"isObjectInOldGen0", CC"(Ljava/lang/Object;)Z", (void*)&WB_isObjectInOldGen }, 1454144467Sharti {CC"getHeapOopSize", CC"()I", (void*)&WB_GetHeapOopSize }, 14551590Srgrimes {CC"getVMPageSize", CC"()I", (void*)&WB_GetVMPageSize }, 14568874Srgrimes {CC"getVMAllocationGranularity", CC"()J", (void*)&WB_GetVMAllocationGranularity }, 14571590Srgrimes {CC"getVMLargePageSize", CC"()J", (void*)&WB_GetVMLargePageSize}, 14581590Srgrimes {CC"getHeapSpaceAlignment", CC"()J", (void*)&WB_GetHeapSpaceAlignment}, 14591590Srgrimes {CC"isClassAlive0", CC"(Ljava/lang/String;)Z", (void*)&WB_IsClassAlive }, 14601590Srgrimes {CC"parseCommandLine0", 14611590Srgrimes CC"(Ljava/lang/String;C[Lsun/hotspot/parser/DiagnosticCommand;)[Ljava/lang/Object;", 14621590Srgrimes (void*) &WB_ParseCommandLine 14631590Srgrimes }, 14641590Srgrimes {CC"addToBootstrapClassLoaderSearch0", CC"(Ljava/lang/String;)V", 14651590Srgrimes (void*)&WB_AddToBootstrapClassLoaderSearch}, 14661590Srgrimes {CC"addToSystemClassLoaderSearch0", CC"(Ljava/lang/String;)V", 14671590Srgrimes (void*)&WB_AddToSystemClassLoaderSearch}, 1468104696Sjmallett {CC"getCompressedOopsMaxHeapSize", CC"()J", 14691590Srgrimes (void*)&WB_GetCompressedOopsMaxHeapSize}, 1470144467Sharti {CC"printHeapSizes", CC"()V", (void*)&WB_PrintHeapSizes }, 1471144467Sharti {CC"runMemoryUnitTests", CC"()V", (void*)&WB_RunMemoryUnitTests}, 1472144467Sharti {CC"readFromNoaccessArea",CC"()V", (void*)&WB_ReadFromNoaccessArea}, 1473144467Sharti {CC"stressVirtualSpaceResize",CC"(JJJ)I", (void*)&WB_StressVirtualSpaceResize}, 1474144467Sharti#if INCLUDE_ALL_GCS 1475144467Sharti {CC"g1InConcurrentMark", CC"()Z", (void*)&WB_G1InConcurrentMark}, 1476144654Sharti {CC"g1IsHumongous0", CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous }, 14771590Srgrimes {CC"g1NumMaxRegions", CC"()J", (void*)&WB_G1NumMaxRegions }, 1478144467Sharti {CC"g1NumFreeRegions", CC"()J", (void*)&WB_G1NumFreeRegions }, 1479144467Sharti {CC"g1RegionSize", CC"()I", (void*)&WB_G1RegionSize }, 1480144467Sharti {CC"g1StartConcMarkCycle", CC"()Z", (void*)&WB_G1StartMarkCycle }, 1481144467Sharti {CC"g1AuxiliaryMemoryUsage", CC"()Ljava/lang/management/MemoryUsage;", 1482144467Sharti (void*)&WB_G1AuxiliaryMemoryUsage }, 1483144467Sharti {CC"psVirtualSpaceAlignment",CC"()J", (void*)&WB_PSVirtualSpaceAlignment}, 1484144467Sharti {CC"psHeapGenerationAlignment",CC"()J", (void*)&WB_PSHeapGenerationAlignment}, 1485144467Sharti#endif // INCLUDE_ALL_GCS 1486144467Sharti#if INCLUDE_NMT 1487144467Sharti {CC"NMTMalloc", CC"(J)J", (void*)&WB_NMTMalloc }, 1488144467Sharti {CC"NMTMallocWithPseudoStack", CC"(JI)J", (void*)&WB_NMTMallocWithPseudoStack}, 14891590Srgrimes {CC"NMTFree", CC"(J)V", (void*)&WB_NMTFree }, 1490144467Sharti {CC"NMTReserveMemory", CC"(J)J", (void*)&WB_NMTReserveMemory }, 1491144467Sharti {CC"NMTCommitMemory", CC"(JJ)V", (void*)&WB_NMTCommitMemory }, 14921590Srgrimes {CC"NMTUncommitMemory", CC"(JJ)V", (void*)&WB_NMTUncommitMemory }, 14931590Srgrimes {CC"NMTReleaseMemory", CC"(JJ)V", (void*)&WB_NMTReleaseMemory }, 1494144467Sharti {CC"NMTChangeTrackingLevel", CC"()Z", (void*)&WB_NMTChangeTrackingLevel}, 1495144467Sharti {CC"NMTGetHashSize", CC"()I", (void*)&WB_NMTGetHashSize }, 1496144467Sharti#endif // INCLUDE_NMT 14971590Srgrimes {CC"deoptimizeFrames", CC"(Z)I", (void*)&WB_DeoptimizeFrames }, 1498144467Sharti {CC"deoptimizeAll", CC"()V", (void*)&WB_DeoptimizeAll }, 1499144467Sharti {CC"deoptimizeMethod0", CC"(Ljava/lang/reflect/Executable;Z)I", 1500144467Sharti (void*)&WB_DeoptimizeMethod }, 15011590Srgrimes {CC"isMethodCompiled0", CC"(Ljava/lang/reflect/Executable;Z)Z", 1502144467Sharti (void*)&WB_IsMethodCompiled }, 1503144467Sharti {CC"isMethodCompilable0", CC"(Ljava/lang/reflect/Executable;IZ)Z", 1504144467Sharti (void*)&WB_IsMethodCompilable}, 1505144467Sharti {CC"isMethodQueuedForCompilation0", 15068874Srgrimes CC"(Ljava/lang/reflect/Executable;)Z", (void*)&WB_IsMethodQueuedForCompilation}, 15071590Srgrimes {CC"isIntrinsicAvailable0", 1508144467Sharti CC"(Ljava/lang/reflect/Executable;Ljava/lang/reflect/Executable;I)Z", 1509144658Sharti (void*)&WB_IsIntrinsicAvailable}, 15101590Srgrimes {CC"makeMethodNotCompilable0", 1511144658Sharti CC"(Ljava/lang/reflect/Executable;IZ)V", (void*)&WB_MakeMethodNotCompilable}, 1512144467Sharti {CC"testSetDontInlineMethod0", 1513144467Sharti CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetDontInlineMethod}, 1514144467Sharti {CC"getMethodCompilationLevel0", 1515144467Sharti CC"(Ljava/lang/reflect/Executable;Z)I", (void*)&WB_GetMethodCompilationLevel}, 15161590Srgrimes {CC"getMethodEntryBci0", 15171590Srgrimes CC"(Ljava/lang/reflect/Executable;)I", (void*)&WB_GetMethodEntryBci}, 1518144467Sharti {CC"getCompileQueueSize", 1519144467Sharti CC"(I)I", (void*)&WB_GetCompileQueueSize}, 1520144467Sharti {CC"testSetForceInlineMethod0", 1521144467Sharti CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetForceInlineMethod}, 15221590Srgrimes {CC"enqueueMethodForCompilation0", 1523144467Sharti CC"(Ljava/lang/reflect/Executable;II)Z", (void*)&WB_EnqueueMethodForCompilation}, 1524144467Sharti {CC"clearMethodState0", 1525144467Sharti CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_ClearMethodState}, 1526144467Sharti {CC"lockCompilation", CC"()V", (void*)&WB_LockCompilation}, 1527144467Sharti {CC"unlockCompilation", CC"()V", (void*)&WB_UnlockCompilation}, 1528144467Sharti {CC"matchesMethod", 1529144467Sharti CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)I", 1530144467Sharti (void*)&WB_MatchesMethod}, 15318874Srgrimes {CC"matchesInline", 1532144467Sharti CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)I", 1533144467Sharti (void*)&WB_MatchesInline}, 1534144467Sharti {CC"shouldPrintAssembly", 1535144467Sharti CC"(Ljava/lang/reflect/Executable;)Z", 1536144467Sharti (void*)&WB_ShouldPrintAssembly}, 1537144467Sharti 1538144467Sharti {CC"isConstantVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsConstantVMFlag}, 1539144467Sharti {CC"isLockedVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsLockedVMFlag}, 1540144467Sharti {CC"setBooleanVMFlag", CC"(Ljava/lang/String;Z)V",(void*)&WB_SetBooleanVMFlag}, 1541144467Sharti {CC"setIntVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntVMFlag}, 1542144467Sharti {CC"setUintVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintVMFlag}, 1543144467Sharti {CC"setIntxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag}, 1544144467Sharti {CC"setUintxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag}, 1545144467Sharti {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag}, 1546144467Sharti {CC"setSizeTVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetSizeTVMFlag}, 1547138564Sharti {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag}, 1548138564Sharti {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V", 1549144467Sharti (void*)&WB_SetStringVMFlag}, 1550144467Sharti {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;", 1551138564Sharti (void*)&WB_GetBooleanVMFlag}, 1552144467Sharti {CC"getIntVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 1553144467Sharti (void*)&WB_GetIntVMFlag}, 1554144467Sharti {CC"getUintVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 1555144467Sharti (void*)&WB_GetUintVMFlag}, 1556144467Sharti {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 1557144467Sharti (void*)&WB_GetIntxVMFlag}, 1558144467Sharti {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 1559144467Sharti (void*)&WB_GetUintxVMFlag}, 1560144467Sharti {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 1561144467Sharti (void*)&WB_GetUint64VMFlag}, 1562144467Sharti {CC"getSizeTVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;", 1563144467Sharti (void*)&WB_GetSizeTVMFlag}, 1564144467Sharti {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;", 1565144467Sharti (void*)&WB_GetDoubleVMFlag}, 1566144467Sharti {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;", 15678874Srgrimes (void*)&WB_GetStringVMFlag}, 1568144467Sharti {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable }, 1569144467Sharti {CC"fullGC", CC"()V", (void*)&WB_FullGC }, 1570144467Sharti {CC"youngGC", CC"()V", (void*)&WB_YoungGC }, 1571144467Sharti {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory }, 1572144467Sharti {CC"allocateMetaspace", 1573144467Sharti CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace }, 1574144467Sharti {CC"freeMetaspace", 1575144467Sharti CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace }, 1576144467Sharti {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC }, 1577144467Sharti {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC }, 1578144467Sharti {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures }, 1579144467Sharti {CC"getNMethod0", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;", 1580144467Sharti (void*)&WB_GetNMethod }, 1581144467Sharti {CC"forceNMethodSweep", CC"()V", (void*)&WB_ForceNMethodSweep }, 1582144467Sharti {CC"allocateCodeBlob", CC"(II)J", (void*)&WB_AllocateCodeBlob }, 1583144467Sharti {CC"freeCodeBlob", CC"(J)V", (void*)&WB_FreeCodeBlob }, 1584144467Sharti {CC"getCodeHeapEntries", CC"(I)[Ljava/lang/Object;",(void*)&WB_GetCodeHeapEntries }, 1585144467Sharti {CC"getCompilationActivityMode", 1586144467Sharti CC"()I", (void*)&WB_GetCompilationActivityMode}, 1587144467Sharti {CC"getMethodData0", CC"(Ljava/lang/reflect/Executable;)J", 1588144467Sharti (void*)&WB_GetMethodData }, 1589144467Sharti {CC"getCodeBlob", CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob }, 1590144467Sharti {CC"getThreadStackSize", CC"()J", (void*)&WB_GetThreadStackSize }, 1591144467Sharti {CC"getThreadRemainingStackSize", CC"()J", (void*)&WB_GetThreadRemainingStackSize }, 1592144467Sharti {CC"assertMatchingSafepointCalls", CC"(ZZ)V", (void*)&WB_AssertMatchingSafepointCalls }, 1593144467Sharti {CC"isMonitorInflated0", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated }, 1594144467Sharti {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint }, 1595144467Sharti {CC"getConstantPool0", CC"(Ljava/lang/Class;)J", (void*)&WB_GetConstantPool }, 1596144467Sharti {CC"getMethodBooleanOption", 1597144467Sharti CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Boolean;", 1598144467Sharti (void*)&WB_GetMethodBooleaneOption}, 1599144467Sharti {CC"getMethodIntxOption", 1600144467Sharti CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;", 1601144467Sharti (void*)&WB_GetMethodIntxOption}, 1602144467Sharti {CC"getMethodUintxOption", 1603144467Sharti CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;", 1604144467Sharti (void*)&WB_GetMethodUintxOption}, 1605144467Sharti {CC"getMethodDoubleOption", 1606144467Sharti CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Double;", 1607144467Sharti (void*)&WB_GetMethodDoubleOption}, 1608144467Sharti {CC"getMethodStringOption", 1609144467Sharti CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/String;", 1610144467Sharti (void*)&WB_GetMethodStringOption}, 1611144467Sharti {CC"isShared", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsShared }, 1612144467Sharti {CC"areSharedStringsIgnored", CC"()Z", (void*)&WB_AreSharedStringsIgnored }, 1613144467Sharti}; 1614144467Sharti 1615144467Sharti#undef CC 1616144467Sharti 1617144467ShartiJVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass)) 1618144467Sharti { 1619144467Sharti if (WhiteBoxAPI) { 1620144467Sharti // Make sure that wbclass is loaded by the null classloader 1621144467Sharti instanceKlassHandle ikh = instanceKlassHandle(JNIHandles::resolve(wbclass)->klass()); 1622144467Sharti Handle loader(ikh->class_loader()); 1623144467Sharti if (loader.is_null()) { 1624144467Sharti WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0])); 1625144467Sharti WhiteBox::register_extended(env, wbclass, thread); 1626144467Sharti WhiteBox::set_used(); 1627144467Sharti } 1628144467Sharti } 1629144467Sharti } 1630144467ShartiJVM_END 1631144467Sharti