1 /*
2 * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26
27 #include "memory/metadataFactory.hpp"
28 #include "memory/universe.hpp"
29 #include "oops/oop.inline.hpp"
30
31 #include "classfile/symbolTable.hpp"
32 #include "classfile/classLoaderData.hpp"
33
34 #include "prims/whitebox.hpp"
35 #include "prims/wbtestmethods/parserTests.hpp"
36
37 #include "runtime/arguments.hpp"
38 #include "runtime/interfaceSupport.hpp"
39 #include "runtime/os.hpp"
40 #include "utilities/array.hpp"
41 #include "utilities/debug.hpp"
42 #include "utilities/macros.hpp"
43 #include "utilities/exceptions.hpp"
44
45 #if INCLUDE_ALL_GCS
46 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
47 #include "gc_implementation/g1/concurrentMark.hpp"
48 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
49 #include "gc_implementation/g1/heapRegionRemSet.hpp"
50 #endif // INCLUDE_ALL_GCS
51
52 #if INCLUDE_NMT
53 #include "services/mallocSiteTable.hpp"
54 #include "services/memTracker.hpp"
55 #include "utilities/nativeCallStack.hpp"
56 #endif // INCLUDE_NMT
57
58 #include "compiler/compileBroker.hpp"
59 #include "jvmtifiles/jvmtiEnv.hpp"
60 #include "runtime/compilationPolicy.hpp"
61
62 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
63
64 #define SIZE_T_MAX_VALUE ((size_t) -1)
65
66 bool WhiteBox::_used = false;
67
68 WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj))
69 return (jlong)(void*)JNIHandles::resolve(obj);
70 WB_END
71
72 WB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o))
73 return heapOopSize;
74 WB_END
75
76 WB_ENTRY(jint, WB_GetVMPageSize(JNIEnv* env, jobject o))
77 return os::vm_page_size();
78 WB_END
79
80 class WBIsKlassAliveClosure : public KlassClosure {
81 Symbol* _name;
82 bool _found;
83 public:
84 WBIsKlassAliveClosure(Symbol* name) : _name(name), _found(false) {}
85
86 void do_klass(Klass* k) {
87 if (_found) return;
88 Symbol* ksym = k->name();
89 if (ksym->fast_compare(_name) == 0) {
90 _found = true;
91 }
92 }
93
94 bool found() const {
95 return _found;
96 }
97 };
98
99 WB_ENTRY(jboolean, WB_IsClassAlive(JNIEnv* env, jobject target, jstring name))
100 Handle h_name = JNIHandles::resolve(name);
101 if (h_name.is_null()) return false;
102 Symbol* sym = java_lang_String::as_symbol(h_name, CHECK_false);
103 TempNewSymbol tsym(sym); // Make sure to decrement reference count on sym on return
104
105 WBIsKlassAliveClosure closure(sym);
106 ClassLoaderDataGraph::classes_do(&closure);
107
108 return closure.found();
109 WB_END
110
111 WB_ENTRY(jboolean, WB_ClassKnownToNotExist(JNIEnv* env, jobject o, jobject loader, jstring name))
112 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
113 const char* class_name = env->GetStringUTFChars(name, NULL);
114 jboolean result = JVM_KnownToNotExist(env, loader, class_name);
115 env->ReleaseStringUTFChars(name, class_name);
116 return result;
117 WB_END
118
119 WB_ENTRY(jobjectArray, WB_GetLookupCacheURLs(JNIEnv* env, jobject o, jobject loader))
120 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
121 return JVM_GetResourceLookupCacheURLs(env, loader);
122 WB_END
123
124 WB_ENTRY(jintArray, WB_GetLookupCacheMatches(JNIEnv* env, jobject o, jobject loader, jstring name))
125 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
126 const char* resource_name = env->GetStringUTFChars(name, NULL);
127 jintArray result = JVM_GetResourceLookupCache(env, loader, resource_name);
128
129 env->ReleaseStringUTFChars(name, resource_name);
130 return result;
131 WB_END
132
133 WB_ENTRY(void, WB_AddToBootstrapClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) {
134 #if INCLUDE_JVMTI
135 ResourceMark rm;
136 const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment));
137 JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION);
138 jvmtiError err = jvmti_env->AddToBootstrapClassLoaderSearch(seg);
139 assert(err == JVMTI_ERROR_NONE, "must not fail");
140 #endif
141 }
142 WB_END
143
144 WB_ENTRY(void, WB_AddToSystemClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) {
145 #if INCLUDE_JVMTI
146 ResourceMark rm;
147 const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment));
148 JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION);
149 jvmtiError err = jvmti_env->AddToSystemClassLoaderSearch(seg);
150 assert(err == JVMTI_ERROR_NONE, "must not fail");
151 #endif
152 }
153 WB_END
154
155
156 WB_ENTRY(jlong, WB_GetCompressedOopsMaxHeapSize(JNIEnv* env, jobject o)) {
157 return (jlong)Arguments::max_heap_for_compressed_oops();
158 }
159 WB_END
160
161 WB_ENTRY(void, WB_PrintHeapSizes(JNIEnv* env, jobject o)) {
162 CollectorPolicy * p = Universe::heap()->collector_policy();
163 gclog_or_tty->print_cr("Minimum heap "SIZE_FORMAT" Initial heap "
164 SIZE_FORMAT" Maximum heap "SIZE_FORMAT" Min alignment "SIZE_FORMAT" Max alignment "SIZE_FORMAT,
165 p->min_heap_byte_size(), p->initial_heap_byte_size(), p->max_heap_byte_size(),
166 p->space_alignment(), p->heap_alignment());
167 }
168 WB_END
169
170 #ifndef PRODUCT
171 // Forward declaration
172 void TestReservedSpace_test();
173 void TestReserveMemorySpecial_test();
174 void TestVirtualSpace_test();
175 void TestMetaspaceAux_test();
176 #endif
177
178 WB_ENTRY(void, WB_RunMemoryUnitTests(JNIEnv* env, jobject o))
179 #ifndef PRODUCT
180 TestReservedSpace_test();
181 TestReserveMemorySpecial_test();
182 TestVirtualSpace_test();
183 TestMetaspaceAux_test();
184 #endif
185 WB_END
186
187 WB_ENTRY(void, WB_ReadFromNoaccessArea(JNIEnv* env, jobject o))
188 size_t granularity = os::vm_allocation_granularity();
189 ReservedHeapSpace rhs(100 * granularity, granularity, false, NULL);
190 VirtualSpace vs;
191 vs.initialize(rhs, 50 * granularity);
192
193 //Check if constraints are complied
194 if (!( UseCompressedOops && rhs.base() != NULL &&
195 Universe::narrow_oop_base() != NULL &&
196 Universe::narrow_oop_use_implicit_null_checks() )) {
197 tty->print_cr("WB_ReadFromNoaccessArea method is useless:\n "
198 "\tUseCompressedOops is %d\n"
199 "\trhs.base() is "PTR_FORMAT"\n"
200 "\tUniverse::narrow_oop_base() is "PTR_FORMAT"\n"
201 "\tUniverse::narrow_oop_use_implicit_null_checks() is %d",
202 UseCompressedOops,
203 rhs.base(),
204 Universe::narrow_oop_base(),
205 Universe::narrow_oop_use_implicit_null_checks());
206 return;
207 }
208 tty->print_cr("Reading from no access area... ");
209 tty->print_cr("*(vs.low_boundary() - rhs.noaccess_prefix() / 2 ) = %c",
210 *(vs.low_boundary() - rhs.noaccess_prefix() / 2 ));
211 WB_END
212
213 static jint wb_stress_virtual_space_resize(size_t reserved_space_size,
214 size_t magnitude, size_t iterations) {
215 size_t granularity = os::vm_allocation_granularity();
216 ReservedHeapSpace rhs(reserved_space_size * granularity, granularity, false, NULL);
217 VirtualSpace vs;
218 if (!vs.initialize(rhs, 0)) {
219 tty->print_cr("Failed to initialize VirtualSpace. Can't proceed.");
220 return 3;
221 }
222
223 long seed = os::random();
224 tty->print_cr("Random seed is %ld", seed);
225 os::init_random(seed);
226
227 for (size_t i = 0; i < iterations; i++) {
228
229 // Whether we will shrink or grow
230 bool shrink = os::random() % 2L == 0;
231
232 // Get random delta to resize virtual space
233 size_t delta = (size_t)os::random() % magnitude;
234
235 // If we are about to shrink virtual space below zero, then expand instead
236 if (shrink && vs.committed_size() < delta) {
237 shrink = false;
238 }
239
240 // Resizing by delta
241 if (shrink) {
242 vs.shrink_by(delta);
243 } else {
244 // If expanding fails expand_by will silently return false
245 vs.expand_by(delta, true);
246 }
247 }
248 return 0;
249 }
250
251 WB_ENTRY(jint, WB_StressVirtualSpaceResize(JNIEnv* env, jobject o,
252 jlong reserved_space_size, jlong magnitude, jlong iterations))
253 tty->print_cr("reservedSpaceSize="JLONG_FORMAT", magnitude="JLONG_FORMAT", "
254 "iterations="JLONG_FORMAT"\n", reserved_space_size, magnitude,
255 iterations);
256 if (reserved_space_size < 0 || magnitude < 0 || iterations < 0) {
257 tty->print_cr("One of variables printed above is negative. Can't proceed.\n");
258 return 1;
259 }
260
261 // sizeof(size_t) depends on whether OS is 32bit or 64bit. sizeof(jlong) is
262 // always 8 byte. That's why we should avoid overflow in case of 32bit platform.
263 if (sizeof(size_t) < sizeof(jlong)) {
264 jlong size_t_max_value = (jlong) SIZE_T_MAX_VALUE;
265 if (reserved_space_size > size_t_max_value || magnitude > size_t_max_value
266 || iterations > size_t_max_value) {
267 tty->print_cr("One of variables printed above overflows size_t. Can't proceed.\n");
268 return 2;
269 }
270 }
271
272 return wb_stress_virtual_space_resize((size_t) reserved_space_size,
273 (size_t) magnitude, (size_t) iterations);
274 WB_END
275
276 WB_ENTRY(jboolean, WB_isObjectInOldGen(JNIEnv* env, jobject o, jobject obj))
277 oop p = JNIHandles::resolve(obj);
278 #if INCLUDE_ALL_GCS
279 if (UseG1GC) {
280 G1CollectedHeap* g1 = G1CollectedHeap::heap();
281 const HeapRegion* hr = g1->heap_region_containing(p);
282 if (hr == NULL) {
283 return false;
284 }
285 return !(hr->is_young());
286 } else if (UseParallelGC) {
287 ParallelScavengeHeap* psh = ParallelScavengeHeap::heap();
288 return !psh->is_in_young(p);
289 }
290 #endif // INCLUDE_ALL_GCS
291 GenCollectedHeap* gch = GenCollectedHeap::heap();
292 return !gch->is_in_young(p);
293 WB_END
294
295 WB_ENTRY(jlong, WB_GetObjectSize(JNIEnv* env, jobject o, jobject obj))
296 oop p = JNIHandles::resolve(obj);
297 return p->size() * HeapWordSize;
298 WB_END
299
300 #if INCLUDE_ALL_GCS
301 WB_ENTRY(jboolean, WB_G1IsHumongous(JNIEnv* env, jobject o, jobject obj))
302 G1CollectedHeap* g1 = G1CollectedHeap::heap();
303 oop result = JNIHandles::resolve(obj);
304 const HeapRegion* hr = g1->heap_region_containing(result);
305 return hr->isHumongous();
306 WB_END
307
308 WB_ENTRY(jlong, WB_G1NumFreeRegions(JNIEnv* env, jobject o))
309 G1CollectedHeap* g1 = G1CollectedHeap::heap();
310 size_t nr = g1->num_free_regions();
311 return (jlong)nr;
312 WB_END
313
314 WB_ENTRY(jboolean, WB_G1InConcurrentMark(JNIEnv* env, jobject o))
315 G1CollectedHeap* g1 = G1CollectedHeap::heap();
316 ConcurrentMark* cm = g1->concurrent_mark();
317 return cm->concurrent_marking_in_progress();
318 WB_END
319
320 WB_ENTRY(jint, WB_G1RegionSize(JNIEnv* env, jobject o))
321 return (jint)HeapRegion::GrainBytes;
322 WB_END
323 #endif // INCLUDE_ALL_GCS
324
325 #if INCLUDE_NMT
326 // Alloc memory using the test memory type so that we can use that to see if
327 // NMT picks it up correctly
328 WB_ENTRY(jlong, WB_NMTMalloc(JNIEnv* env, jobject o, jlong size))
329 jlong addr = 0;
330 addr = (jlong)(uintptr_t)os::malloc(size, mtTest);
331 return addr;
332 WB_END
333
334 // Alloc memory with pseudo call stack. The test can create psudo malloc
335 // allocation site to stress the malloc tracking.
336 WB_ENTRY(jlong, WB_NMTMallocWithPseudoStack(JNIEnv* env, jobject o, jlong size, jint pseudo_stack))
337 address pc = (address)(size_t)pseudo_stack;
338 NativeCallStack stack(&pc, 1);
339 return (jlong)(uintptr_t)os::malloc(size, mtTest, stack);
340 WB_END
341
342 // Free the memory allocated by NMTAllocTest
343 WB_ENTRY(void, WB_NMTFree(JNIEnv* env, jobject o, jlong mem))
344 os::free((void*)(uintptr_t)mem, mtTest);
345 WB_END
346
347 WB_ENTRY(jlong, WB_NMTReserveMemory(JNIEnv* env, jobject o, jlong size))
348 jlong addr = 0;
349
350 addr = (jlong)(uintptr_t)os::reserve_memory(size);
351 MemTracker::record_virtual_memory_type((address)addr, mtTest);
352
353 return addr;
354 WB_END
355
356
357 WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
358 os::commit_memory((char *)(uintptr_t)addr, size, !ExecMem);
359 MemTracker::record_virtual_memory_type((address)(uintptr_t)addr, mtTest);
360 WB_END
361
362 WB_ENTRY(void, WB_NMTUncommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
363 os::uncommit_memory((char *)(uintptr_t)addr, size);
364 WB_END
365
366 WB_ENTRY(void, WB_NMTReleaseMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
367 os::release_memory((char *)(uintptr_t)addr, size);
368 WB_END
369
370 WB_ENTRY(jboolean, WB_NMTIsDetailSupported(JNIEnv* env))
371 return MemTracker::tracking_level() == NMT_detail;
372 WB_END
373
374 WB_ENTRY(jboolean, WB_NMTChangeTrackingLevel(JNIEnv* env))
375 // Test that we can downgrade NMT levels but not upgrade them.
376 if (MemTracker::tracking_level() == NMT_off) {
377 MemTracker::transition_to(NMT_off);
378 return MemTracker::tracking_level() == NMT_off;
379 } else {
380 assert(MemTracker::tracking_level() == NMT_detail, "Should start out as detail tracking");
381 MemTracker::transition_to(NMT_summary);
382 assert(MemTracker::tracking_level() == NMT_summary, "Should be summary now");
383
384 // Can't go to detail once NMT is set to summary.
385 MemTracker::transition_to(NMT_detail);
386 assert(MemTracker::tracking_level() == NMT_summary, "Should still be summary now");
387
388 // Shutdown sets tracking level to minimal.
389 MemTracker::shutdown();
390 assert(MemTracker::tracking_level() == NMT_minimal, "Should be minimal now");
391
392 // Once the tracking level is minimal, we cannot increase to summary.
393 // The code ignores this request instead of asserting because if the malloc site
394 // table overflows in another thread, it tries to change the code to summary.
395 MemTracker::transition_to(NMT_summary);
396 assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now");
397
398 // Really can never go up to detail, verify that the code would never do this.
399 MemTracker::transition_to(NMT_detail);
400 assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now");
401 return MemTracker::tracking_level() == NMT_minimal;
402 }
403 WB_END
404
405 WB_ENTRY(jint, WB_NMTGetHashSize(JNIEnv* env, jobject o))
406 int hash_size = MallocSiteTable::hash_buckets();
407 assert(hash_size > 0, "NMT hash_size should be > 0");
408 return (jint)hash_size;
409 WB_END
410 #endif // INCLUDE_NMT
411
412 static jmethodID reflected_method_to_jmid(JavaThread* thread, JNIEnv* env, jobject method) {
413 assert(method != NULL, "method should not be null");
414 ThreadToNativeFromVM ttn(thread);
415 return env->FromReflectedMethod(method);
416 }
417
418 WB_ENTRY(void, WB_DeoptimizeAll(JNIEnv* env, jobject o))
419 MutexLockerEx mu(Compile_lock);
420 CodeCache::mark_all_nmethods_for_deoptimization();
421 VM_Deoptimize op;
422 VMThread::execute(&op);
423 WB_END
424
425 WB_ENTRY(jint, WB_DeoptimizeMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
426 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
427 int result = 0;
428 CHECK_JNI_EXCEPTION_(env, result);
429 MutexLockerEx mu(Compile_lock);
430 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
431 if (is_osr) {
432 result += mh->mark_osr_nmethods();
433 } else if (mh->code() != NULL) {
434 mh->code()->mark_for_deoptimization();
435 ++result;
436 }
437 result += CodeCache::mark_for_deoptimization(mh());
438 if (result > 0) {
439 VM_Deoptimize op;
440 VMThread::execute(&op);
441 }
442 return result;
443 WB_END
444
445 WB_ENTRY(jboolean, WB_IsMethodCompiled(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
446 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
447 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
448 MutexLockerEx mu(Compile_lock);
449 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
450 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
451 if (code == NULL) {
452 return JNI_FALSE;
453 }
454 return (code->is_alive() && !code->is_marked_for_deoptimization());
455 WB_END
456
457 WB_ENTRY(jboolean, WB_IsMethodCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr))
458 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
459 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
460 MutexLockerEx mu(Compile_lock);
461 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
462 if (is_osr) {
463 return CompilationPolicy::can_be_osr_compiled(mh, comp_level);
464 } else {
465 return CompilationPolicy::can_be_compiled(mh, comp_level);
466 }
467 WB_END
468
469 WB_ENTRY(jboolean, WB_IsMethodQueuedForCompilation(JNIEnv* env, jobject o, jobject method))
470 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
471 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
472 MutexLockerEx mu(Compile_lock);
473 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
474 return mh->queued_for_compilation();
475 WB_END
476
477 WB_ENTRY(jint, WB_GetMethodCompilationLevel(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
478 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
479 CHECK_JNI_EXCEPTION_(env, CompLevel_none);
480 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
481 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
482 return (code != NULL ? code->comp_level() : CompLevel_none);
483 WB_END
484
485 WB_ENTRY(void, WB_MakeMethodNotCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr))
486 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
487 CHECK_JNI_EXCEPTION(env);
488 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
489 if (is_osr) {
490 mh->set_not_osr_compilable(comp_level, true /* report */, "WhiteBox");
491 } else {
492 mh->set_not_compilable(comp_level, true /* report */, "WhiteBox");
493 }
494 WB_END
495
496 WB_ENTRY(jint, WB_GetMethodEntryBci(JNIEnv* env, jobject o, jobject method))
497 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
498 CHECK_JNI_EXCEPTION_(env, InvocationEntryBci);
499 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
500 nmethod* code = mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false);
501 return (code != NULL && code->is_osr_method() ? code->osr_entry_bci() : InvocationEntryBci);
502 WB_END
503
504 WB_ENTRY(jboolean, WB_TestSetDontInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
505 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
506 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
507 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
508 bool result = mh->dont_inline();
509 mh->set_dont_inline(value == JNI_TRUE);
510 return result;
511 WB_END
512
513 WB_ENTRY(jint, WB_GetCompileQueueSize(JNIEnv* env, jobject o, jint comp_level))
514 if (comp_level == CompLevel_any) {
515 return CompileBroker::queue_size(CompLevel_full_optimization) /* C2 */ +
516 CompileBroker::queue_size(CompLevel_full_profile) /* C1 */;
517 } else {
518 return CompileBroker::queue_size(comp_level);
519 }
520 WB_END
521
522 WB_ENTRY(jboolean, WB_TestSetForceInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
523 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
524 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
525 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
526 bool result = mh->force_inline();
527 mh->set_force_inline(value == JNI_TRUE);
528 return result;
529 WB_END
530
531 WB_ENTRY(jboolean, WB_EnqueueMethodForCompilation(JNIEnv* env, jobject o, jobject method, jint comp_level, jint bci))
532 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
533 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
534 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
535 nmethod* nm = CompileBroker::compile_method(mh, bci, comp_level, mh, mh->invocation_count(), "WhiteBox", THREAD);
536 MutexLockerEx mu(Compile_lock);
537 return (mh->queued_for_compilation() || nm != NULL);
538 WB_END
539
540 class VM_WhiteBoxOperation : public VM_Operation {
541 public:
542 VM_WhiteBoxOperation() { }
543 VMOp_Type type() const { return VMOp_WhiteBoxOperation; }
544 bool allow_nested_vm_operations() const { return true; }
545 };
546
547 class AlwaysFalseClosure : public BoolObjectClosure {
548 public:
549 bool do_object_b(oop p) { return false; }
550 };
551
552 static AlwaysFalseClosure always_false;
553
554 class VM_WhiteBoxCleanMethodData : public VM_WhiteBoxOperation {
555 public:
556 VM_WhiteBoxCleanMethodData(MethodData* mdo) : _mdo(mdo) { }
557 void doit() {
558 _mdo->clean_method_data(&always_false);
559 }
560 private:
561 MethodData* _mdo;
562 };
563
564 WB_ENTRY(void, WB_ClearMethodState(JNIEnv* env, jobject o, jobject method))
565 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
566 CHECK_JNI_EXCEPTION(env);
567 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
568 MutexLockerEx mu(Compile_lock);
569 MethodData* mdo = mh->method_data();
570 MethodCounters* mcs = mh->method_counters();
571
572 if (mdo != NULL) {
573 mdo->init();
574 ResourceMark rm;
575 int arg_count = mdo->method()->size_of_parameters();
576 for (int i = 0; i < arg_count; i++) {
577 mdo->set_arg_modified(i, 0);
578 }
579 VM_WhiteBoxCleanMethodData op(mdo);
580 VMThread::execute(&op);
581 }
582
583 mh->clear_not_c1_compilable();
584 mh->clear_not_c2_compilable();
585 mh->clear_not_c2_osr_compilable();
586 NOT_PRODUCT(mh->set_compiled_invocation_count(0));
587 if (mcs != NULL) {
588 mcs->backedge_counter()->init();
589 mcs->invocation_counter()->init();
590 mcs->set_interpreter_invocation_count(0);
591 mcs->set_interpreter_throwout_count(0);
592
593 #ifdef TIERED
594 mcs->set_rate(0.0F);
595 mh->set_prev_event_count(0);
596 mh->set_prev_time(0);
597 #endif
598 }
599 WB_END
600
601 template <typename T>
602 static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAt)(const char*, T*)) {
603 if (name == NULL) {
604 return false;
605 }
606 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
607 const char* flag_name = env->GetStringUTFChars(name, NULL);
608 bool result = (*TAt)(flag_name, value);
609 env->ReleaseStringUTFChars(name, flag_name);
610 return result;
611 }
612
613 template <typename T>
614 static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAtPut)(const char*, T*, Flag::Flags)) {
615 if (name == NULL) {
616 return false;
617 }
618 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
619 const char* flag_name = env->GetStringUTFChars(name, NULL);
620 bool result = (*TAtPut)(flag_name, value, Flag::INTERNAL);
621 env->ReleaseStringUTFChars(name, flag_name);
622 return result;
623 }
624
625 template <typename T>
626 static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {
627 ResourceMark rm(thread);
628 jclass clazz = env->FindClass(name->as_C_string());
629 CHECK_JNI_EXCEPTION_(env, NULL);
630 jmethodID methodID = env->GetStaticMethodID(clazz,
631 vmSymbols::valueOf_name()->as_C_string(),
632 sig->as_C_string());
633 CHECK_JNI_EXCEPTION_(env, NULL);
634 jobject result = env->CallStaticObjectMethod(clazz, methodID, value);
635 CHECK_JNI_EXCEPTION_(env, NULL);
636 return result;
637 }
638
639 static jobject booleanBox(JavaThread* thread, JNIEnv* env, jboolean value) {
640 return box(thread, env, vmSymbols::java_lang_Boolean(), vmSymbols::Boolean_valueOf_signature(), value);
641 }
642 static jobject integerBox(JavaThread* thread, JNIEnv* env, jint value) {
643 return box(thread, env, vmSymbols::java_lang_Integer(), vmSymbols::Integer_valueOf_signature(), value);
644 }
645 static jobject longBox(JavaThread* thread, JNIEnv* env, jlong value) {
646 return box(thread, env, vmSymbols::java_lang_Long(), vmSymbols::Long_valueOf_signature(), value);
647 }
648 /* static jobject floatBox(JavaThread* thread, JNIEnv* env, jfloat value) {
649 return box(thread, env, vmSymbols::java_lang_Float(), vmSymbols::Float_valueOf_signature(), value);
650 }*/
651 static jobject doubleBox(JavaThread* thread, JNIEnv* env, jdouble value) {
652 return box(thread, env, vmSymbols::java_lang_Double(), vmSymbols::Double_valueOf_signature(), value);
653 }
654
655 WB_ENTRY(jobject, WB_GetBooleanVMFlag(JNIEnv* env, jobject o, jstring name))
656 bool result;
657 if (GetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAt)) {
658 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
659 return booleanBox(thread, env, result);
660 }
661 return NULL;
662 WB_END
663
664 WB_ENTRY(jobject, WB_GetIntxVMFlag(JNIEnv* env, jobject o, jstring name))
665 intx result;
666 if (GetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAt)) {
667 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
668 return longBox(thread, env, result);
669 }
670 return NULL;
671 WB_END
672
673 WB_ENTRY(jobject, WB_GetUintxVMFlag(JNIEnv* env, jobject o, jstring name))
674 uintx result;
675 if (GetVMFlag <uintx> (thread, env, name, &result, &CommandLineFlags::uintxAt)) {
676 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
677 return longBox(thread, env, result);
678 }
679 return NULL;
680 WB_END
681
682 WB_ENTRY(jobject, WB_GetUint64VMFlag(JNIEnv* env, jobject o, jstring name))
683 uint64_t result;
684 if (GetVMFlag <uint64_t> (thread, env, name, &result, &CommandLineFlags::uint64_tAt)) {
685 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
686 return longBox(thread, env, result);
687 }
688 return NULL;
689 WB_END
690
691 WB_ENTRY(jobject, WB_GetDoubleVMFlag(JNIEnv* env, jobject o, jstring name))
692 double result;
693 if (GetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAt)) {
694 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
695 return doubleBox(thread, env, result);
696 }
697 return NULL;
698 WB_END
699
700 WB_ENTRY(jstring, WB_GetStringVMFlag(JNIEnv* env, jobject o, jstring name))
701 ccstr ccstrResult;
702 if (GetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAt)) {
703 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
704 jstring result = env->NewStringUTF(ccstrResult);
705 CHECK_JNI_EXCEPTION_(env, NULL);
706 return result;
707 }
708 return NULL;
709 WB_END
710
711 WB_ENTRY(void, WB_SetBooleanVMFlag(JNIEnv* env, jobject o, jstring name, jboolean value))
712 bool result = value == JNI_TRUE ? true : false;
713 SetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAtPut);
714 WB_END
715
716 WB_ENTRY(void, WB_SetIntxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
717 intx result = value;
718 SetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAtPut);
719 WB_END
720
721 WB_ENTRY(void, WB_SetUintxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
722 uintx result = value;
723 SetVMFlag <uintx> (thread, env, name, &result, &CommandLineFlags::uintxAtPut);
724 WB_END
725
726 WB_ENTRY(void, WB_SetUint64VMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
727 uint64_t result = value;
728 SetVMFlag <uint64_t> (thread, env, name, &result, &CommandLineFlags::uint64_tAtPut);
729 WB_END
730
731 WB_ENTRY(void, WB_SetDoubleVMFlag(JNIEnv* env, jobject o, jstring name, jdouble value))
732 double result = value;
733 SetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAtPut);
734 WB_END
735
736 WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value))
737 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
738 const char* ccstrValue = (value == NULL) ? NULL : env->GetStringUTFChars(value, NULL);
739 ccstr ccstrResult = ccstrValue;
740 bool needFree;
741 {
742 ThreadInVMfromNative ttvfn(thread); // back to VM
743 needFree = SetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAtPut);
744 }
745 if (value != NULL) {
746 env->ReleaseStringUTFChars(value, ccstrValue);
747 }
748 if (needFree) {
749 FREE_C_HEAP_ARRAY(char, ccstrResult, mtInternal);
750 }
751 WB_END
752
753
754 WB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString))
755 ResourceMark rm(THREAD);
756 int len;
757 jchar* name = java_lang_String::as_unicode_string(JNIHandles::resolve(javaString), len, CHECK_false);
758 return (StringTable::lookup(name, len) != NULL);
759 WB_END
760
761 WB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o))
762 Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(true);
763 Universe::heap()->collect(GCCause::_last_ditch_collection);
764 #if INCLUDE_ALL_GCS
765 if (UseG1GC) {
766 // Needs to be cleared explicitly for G1
767 Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(false);
768 }
769 #endif // INCLUDE_ALL_GCS
770 WB_END
771
772 WB_ENTRY(void, WB_YoungGC(JNIEnv* env, jobject o))
773 Universe::heap()->collect(GCCause::_wb_young_gc);
774 WB_END
775
776 WB_ENTRY(void, WB_ReadReservedMemory(JNIEnv* env, jobject o))
777 // static+volatile in order to force the read to happen
778 // (not be eliminated by the compiler)
779 static char c;
780 static volatile char* p;
781
782 p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
783 if (p == NULL) {
784 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
785 }
786
787 c = *p;
788 WB_END
789
790 WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
791 const char* cpu_features = VM_Version::cpu_features();
792 ThreadToNativeFromVM ttn(thread);
793 jstring features_string = env->NewStringUTF(cpu_features);
794
795 CHECK_JNI_EXCEPTION_(env, NULL);
796
797 return features_string;
798 WB_END
799
800
801 WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
802 ResourceMark rm(THREAD);
803 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
804 CHECK_JNI_EXCEPTION_(env, NULL);
805 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
806 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
807 jobjectArray result = NULL;
808 if (code == NULL) {
809 return result;
810 }
811 int insts_size = code->insts_size();
812
813 ThreadToNativeFromVM ttn(thread);
814 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
815 CHECK_JNI_EXCEPTION_(env, NULL);
816 result = env->NewObjectArray(2, clazz, NULL);
817 if (result == NULL) {
818 return result;
819 }
820
821 jobject obj = integerBox(thread, env, code->comp_level());
822 CHECK_JNI_EXCEPTION_(env, NULL);
823 env->SetObjectArrayElement(result, 0, obj);
824
825 jbyteArray insts = env->NewByteArray(insts_size);
826 CHECK_JNI_EXCEPTION_(env, NULL);
827 env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
828 env->SetObjectArrayElement(result, 1, insts);
829
830 return result;
831 WB_END
832
833
834 int WhiteBox::array_bytes_to_length(size_t bytes) {
835 return Array<u1>::bytes_to_length(bytes);
836 }
837
838 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
839 if (size < 0) {
840 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
841 err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
842 }
843
844 oop class_loader_oop = JNIHandles::resolve(class_loader);
845 ClassLoaderData* cld = class_loader_oop != NULL
846 ? java_lang_ClassLoader::loader_data(class_loader_oop)
847 : ClassLoaderData::the_null_class_loader_data();
848
849 void* metadata = MetadataFactory::new_writeable_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread);
850
851 return (jlong)(uintptr_t)metadata;
852 WB_END
853
854 WB_ENTRY(void, WB_FreeMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong addr, jlong size))
855 oop class_loader_oop = JNIHandles::resolve(class_loader);
856 ClassLoaderData* cld = class_loader_oop != NULL
857 ? java_lang_ClassLoader::loader_data(class_loader_oop)
858 : ClassLoaderData::the_null_class_loader_data();
859
860 MetadataFactory::free_array(cld, (Array<u1>*)(uintptr_t)addr);
861 WB_END
862
863 WB_ENTRY(jlong, WB_IncMetaspaceCapacityUntilGC(JNIEnv* env, jobject wb, jlong inc))
864 if (inc < 0) {
865 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
866 err_msg("WB_IncMetaspaceCapacityUntilGC: inc is negative: " JLONG_FORMAT, inc));
867 }
868
869 jlong max_size_t = (jlong) ((size_t) -1);
870 if (inc > max_size_t) {
871 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
872 err_msg("WB_IncMetaspaceCapacityUntilGC: inc does not fit in size_t: " JLONG_FORMAT, inc));
873 }
874
875 size_t new_cap_until_GC = 0;
876 size_t aligned_inc = align_size_down((size_t) inc, Metaspace::commit_alignment());
877 bool success = MetaspaceGC::inc_capacity_until_GC(aligned_inc, &new_cap_until_GC);
878 if (!success) {
879 THROW_MSG_0(vmSymbols::java_lang_IllegalStateException(),
880 "WB_IncMetaspaceCapacityUntilGC: could not increase capacity until GC "
881 "due to contention with another thread");
882 }
883 return (jlong) new_cap_until_GC;
884 WB_END
885
886 WB_ENTRY(jlong, WB_MetaspaceCapacityUntilGC(JNIEnv* env, jobject wb))
887 return (jlong) MetaspaceGC::capacity_until_GC();
888 WB_END
889
890 //Some convenience methods to deal with objects from java
891 int WhiteBox::offset_for_field(const char* field_name, oop object,
892 Symbol* signature_symbol) {
893 assert(field_name != NULL && strlen(field_name) > 0, "Field name not valid");
894 Thread* THREAD = Thread::current();
895
896 //Get the class of our object
897 Klass* arg_klass = object->klass();
898 //Turn it into an instance-klass
899 InstanceKlass* ik = InstanceKlass::cast(arg_klass);
900
901 //Create symbols to look for in the class
902 TempNewSymbol name_symbol = SymbolTable::lookup(field_name, (int) strlen(field_name),
903 THREAD);
904
905 //To be filled in with an offset of the field we're looking for
906 fieldDescriptor fd;
907
908 Klass* res = ik->find_field(name_symbol, signature_symbol, &fd);
909 if (res == NULL) {
910 tty->print_cr("Invalid layout of %s at %s", ik->external_name(),
911 name_symbol->as_C_string());
912 fatal("Invalid layout of preloaded class");
913 }
914
915 //fetch the field at the offset we've found
916 int dest_offset = fd.offset();
917
918 return dest_offset;
919 }
920
921
922 const char* WhiteBox::lookup_jstring(const char* field_name, oop object) {
923 int offset = offset_for_field(field_name, object,
924 vmSymbols::string_signature());
925 oop string = object->obj_field(offset);
926 if (string == NULL) {
927 return NULL;
928 }
929 const char* ret = java_lang_String::as_utf8_string(string);
930 return ret;
931 }
932
933 bool WhiteBox::lookup_bool(const char* field_name, oop object) {
934 int offset =
935 offset_for_field(field_name, object, vmSymbols::bool_signature());
936 bool ret = (object->bool_field(offset) == JNI_TRUE);
937 return ret;
938 }
939
940 void WhiteBox::register_methods(JNIEnv* env, jclass wbclass, JavaThread* thread, JNINativeMethod* method_array, int method_count) {
941 ResourceMark rm;
942 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
943
944 // one by one registration natives for exception catching
945 jclass no_such_method_error_klass = env->FindClass(vmSymbols::java_lang_NoSuchMethodError()->as_C_string());
946 CHECK_JNI_EXCEPTION(env);
947 for (int i = 0, n = method_count; i < n; ++i) {
948 // Skip dummy entries
949 if (method_array[i].fnPtr == NULL) continue;
950 if (env->RegisterNatives(wbclass, &method_array[i], 1) != 0) {
951 jthrowable throwable_obj = env->ExceptionOccurred();
952 if (throwable_obj != NULL) {
953 env->ExceptionClear();
954 if (env->IsInstanceOf(throwable_obj, no_such_method_error_klass)) {
955 // NoSuchMethodError is thrown when a method can't be found or a method is not native.
956 // Ignoring the exception since it is not preventing use of other WhiteBox methods.
957 tty->print_cr("Warning: 'NoSuchMethodError' on register of sun.hotspot.WhiteBox::%s%s",
958 method_array[i].name, method_array[i].signature);
959 }
960 } else {
961 // Registration failed unexpectedly.
962 tty->print_cr("Warning: unexpected error on register of sun.hotspot.WhiteBox::%s%s. All methods will be unregistered",
963 method_array[i].name, method_array[i].signature);
964 env->UnregisterNatives(wbclass);
965 break;
966 }
967 }
968 }
969 }
970
971 #define CC (char*)
972
973 static JNINativeMethod methods[] = {
974 {CC"getObjectAddress", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectAddress },
975 {CC"getObjectSize", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectSize },
976 {CC"isObjectInOldGen", CC"(Ljava/lang/Object;)Z", (void*)&WB_isObjectInOldGen },
977 {CC"getHeapOopSize", CC"()I", (void*)&WB_GetHeapOopSize },
978 {CC"getVMPageSize", CC"()I", (void*)&WB_GetVMPageSize },
979 {CC"isClassAlive0", CC"(Ljava/lang/String;)Z", (void*)&WB_IsClassAlive },
980 {CC"classKnownToNotExist",
981 CC"(Ljava/lang/ClassLoader;Ljava/lang/String;)Z",(void*)&WB_ClassKnownToNotExist},
982 {CC"getLookupCacheURLs", CC"(Ljava/lang/ClassLoader;)[Ljava/net/URL;", (void*)&WB_GetLookupCacheURLs},
983 {CC"getLookupCacheMatches", CC"(Ljava/lang/ClassLoader;Ljava/lang/String;)[I",
984 (void*)&WB_GetLookupCacheMatches},
985 {CC"parseCommandLine",
986 CC"(Ljava/lang/String;[Lsun/hotspot/parser/DiagnosticCommand;)[Ljava/lang/Object;",
987 (void*) &WB_ParseCommandLine
988 },
989 {CC"addToBootstrapClassLoaderSearch", CC"(Ljava/lang/String;)V",
990 (void*)&WB_AddToBootstrapClassLoaderSearch},
991 {CC"addToSystemClassLoaderSearch", CC"(Ljava/lang/String;)V",
992 (void*)&WB_AddToSystemClassLoaderSearch},
993 {CC"getCompressedOopsMaxHeapSize", CC"()J",
994 (void*)&WB_GetCompressedOopsMaxHeapSize},
995 {CC"printHeapSizes", CC"()V", (void*)&WB_PrintHeapSizes },
996 {CC"runMemoryUnitTests", CC"()V", (void*)&WB_RunMemoryUnitTests},
997 {CC"readFromNoaccessArea",CC"()V", (void*)&WB_ReadFromNoaccessArea},
998 {CC"stressVirtualSpaceResize",CC"(JJJ)I", (void*)&WB_StressVirtualSpaceResize},
999 #if INCLUDE_ALL_GCS
1000 {CC"g1InConcurrentMark", CC"()Z", (void*)&WB_G1InConcurrentMark},
1001 {CC"g1IsHumongous", CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous },
1002 {CC"g1NumFreeRegions", CC"()J", (void*)&WB_G1NumFreeRegions },
1003 {CC"g1RegionSize", CC"()I", (void*)&WB_G1RegionSize },
1004 #endif // INCLUDE_ALL_GCS
1005 #if INCLUDE_NMT
1006 {CC"NMTMalloc", CC"(J)J", (void*)&WB_NMTMalloc },
1007 {CC"NMTMallocWithPseudoStack", CC"(JI)J", (void*)&WB_NMTMallocWithPseudoStack},
1008 {CC"NMTFree", CC"(J)V", (void*)&WB_NMTFree },
1009 {CC"NMTReserveMemory", CC"(J)J", (void*)&WB_NMTReserveMemory },
1010 {CC"NMTCommitMemory", CC"(JJ)V", (void*)&WB_NMTCommitMemory },
1011 {CC"NMTUncommitMemory", CC"(JJ)V", (void*)&WB_NMTUncommitMemory },
1012 {CC"NMTReleaseMemory", CC"(JJ)V", (void*)&WB_NMTReleaseMemory },
1013 {CC"NMTIsDetailSupported",CC"()Z", (void*)&WB_NMTIsDetailSupported},
1014 {CC"NMTChangeTrackingLevel", CC"()Z", (void*)&WB_NMTChangeTrackingLevel},
1015 {CC"NMTGetHashSize", CC"()I", (void*)&WB_NMTGetHashSize },
1016 #endif // INCLUDE_NMT
1017 {CC"deoptimizeAll", CC"()V", (void*)&WB_DeoptimizeAll },
1018 {CC"deoptimizeMethod", CC"(Ljava/lang/reflect/Executable;Z)I",
1019 (void*)&WB_DeoptimizeMethod },
1020 {CC"isMethodCompiled", CC"(Ljava/lang/reflect/Executable;Z)Z",
1021 (void*)&WB_IsMethodCompiled },
1022 {CC"isMethodCompilable", CC"(Ljava/lang/reflect/Executable;IZ)Z",
1023 (void*)&WB_IsMethodCompilable},
1024 {CC"isMethodQueuedForCompilation",
1025 CC"(Ljava/lang/reflect/Executable;)Z", (void*)&WB_IsMethodQueuedForCompilation},
1026 {CC"makeMethodNotCompilable",
1027 CC"(Ljava/lang/reflect/Executable;IZ)V", (void*)&WB_MakeMethodNotCompilable},
1028 {CC"testSetDontInlineMethod",
1029 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetDontInlineMethod},
1030 {CC"getMethodCompilationLevel",
1031 CC"(Ljava/lang/reflect/Executable;Z)I", (void*)&WB_GetMethodCompilationLevel},
1032 {CC"getMethodEntryBci",
1033 CC"(Ljava/lang/reflect/Executable;)I", (void*)&WB_GetMethodEntryBci},
1034 {CC"getCompileQueueSize",
1035 CC"(I)I", (void*)&WB_GetCompileQueueSize},
1036 {CC"testSetForceInlineMethod",
1037 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetForceInlineMethod},
1038 {CC"enqueueMethodForCompilation",
1039 CC"(Ljava/lang/reflect/Executable;II)Z", (void*)&WB_EnqueueMethodForCompilation},
1040 {CC"clearMethodState",
1041 CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_ClearMethodState},
1042 {CC"setBooleanVMFlag", CC"(Ljava/lang/String;Z)V",(void*)&WB_SetBooleanVMFlag},
1043 {CC"setIntxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag},
1044 {CC"setUintxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag},
1045 {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
1046 {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag},
1047 {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V",
1048 (void*)&WB_SetStringVMFlag},
1049 {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
1050 (void*)&WB_GetBooleanVMFlag},
1051 {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1052 (void*)&WB_GetIntxVMFlag},
1053 {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1054 (void*)&WB_GetUintxVMFlag},
1055 {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1056 (void*)&WB_GetUint64VMFlag},
1057 {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;",
1058 (void*)&WB_GetDoubleVMFlag},
1059 {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;",
1060 (void*)&WB_GetStringVMFlag},
1061 {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
1062 {CC"fullGC", CC"()V", (void*)&WB_FullGC },
1063 {CC"youngGC", CC"()V", (void*)&WB_YoungGC },
1064 {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
1065 {CC"allocateMetaspace",
1066 CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
1067 {CC"freeMetaspace",
1068 CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
1069 {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
1070 {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
1071 {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
1072 {CC"getNMethod", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
1073 (void*)&WB_GetNMethod },
1074 };
1075
1076 #undef CC
1077
1078 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
1079 {
1080 if (WhiteBoxAPI) {
1081 // Make sure that wbclass is loaded by the null classloader
1082 instanceKlassHandle ikh = instanceKlassHandle(JNIHandles::resolve(wbclass)->klass());
1083 Handle loader(ikh->class_loader());
1084 if (loader.is_null()) {
1085 WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0]));
1086 WhiteBox::register_extended(env, wbclass, thread);
1087 WhiteBox::set_used();
1088 }
1089 }
1090 }
1091 JVM_END