1 /*
2 * Copyright (c) 2012, 2019, 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 <new>
28
29 #include "classfile/classLoaderDataGraph.hpp"
30 #include "classfile/modules.hpp"
31 #include "classfile/protectionDomainCache.hpp"
32 #include "classfile/stringTable.hpp"
33 #include "classfile/symbolTable.hpp"
34 #include "code/codeCache.hpp"
35 #include "compiler/compilationPolicy.hpp"
36 #include "compiler/methodMatcher.hpp"
37 #include "compiler/directivesParser.hpp"
38 #include "gc/shared/gcConfig.hpp"
39 #include "gc/shared/genArguments.hpp"
40 #include "gc/shared/genCollectedHeap.hpp"
41 #include "jvmtifiles/jvmtiEnv.hpp"
42 #include "memory/filemap.hpp"
43 #include "memory/heapShared.inline.hpp"
44 #include "memory/metaspaceShared.hpp"
45 #include "memory/metadataFactory.hpp"
46 #include "memory/iterator.hpp"
47 #include "memory/resourceArea.hpp"
48 #include "memory/universe.hpp"
49 #include "memory/oopFactory.hpp"
50 #include "oops/array.hpp"
51 #include "oops/compressedOops.hpp"
52 #include "oops/constantPool.inline.hpp"
53 #include "oops/method.inline.hpp"
54 #include "oops/objArrayKlass.hpp"
55 #include "oops/objArrayOop.inline.hpp"
56 #include "oops/oop.inline.hpp"
57 #include "oops/typeArrayOop.inline.hpp"
58 #include "prims/resolvedMethodTable.hpp"
59 #include "prims/wbtestmethods/parserTests.hpp"
60 #include "prims/whitebox.inline.hpp"
61 #include "runtime/arguments.hpp"
62 #include "runtime/atomic.hpp"
63 #include "runtime/deoptimization.hpp"
64 #include "runtime/fieldDescriptor.inline.hpp"
65 #include "runtime/flags/jvmFlag.hpp"
66 #include "runtime/frame.inline.hpp"
67 #include "runtime/handles.inline.hpp"
68 #include "runtime/handshake.hpp"
69 #include "runtime/interfaceSupport.inline.hpp"
70 #include "runtime/javaCalls.hpp"
71 #include "runtime/jniHandles.inline.hpp"
72 #include "runtime/os.hpp"
73 #include "runtime/sweeper.hpp"
74 #include "runtime/synchronizer.hpp"
75 #include "runtime/thread.hpp"
76 #include "runtime/threadSMR.hpp"
77 #include "runtime/vm_version.hpp"
78 #include "services/memoryService.hpp"
79 #include "utilities/align.hpp"
80 #include "utilities/debug.hpp"
81 #include "utilities/elfFile.hpp"
82 #include "utilities/exceptions.hpp"
83 #include "utilities/macros.hpp"
84 #if INCLUDE_CDS
85 #include "prims/cdsoffsets.hpp"
86 #endif // INCLUDE_CDS
87 #if INCLUDE_G1GC
88 #include "gc/g1/g1Arguments.hpp"
89 #include "gc/g1/g1CollectedHeap.inline.hpp"
90 #include "gc/g1/g1ConcurrentMark.hpp"
91 #include "gc/g1/g1ConcurrentMarkThread.hpp"
92 #include "gc/g1/heapRegionRemSet.hpp"
93 #include "gc/g1/heterogeneousHeapRegionManager.hpp"
94 #endif // INCLUDE_G1GC
95 #if INCLUDE_PARALLELGC
96 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
97 #include "gc/parallel/adjoiningGenerations.hpp"
98 #endif // INCLUDE_PARALLELGC
99 #if INCLUDE_NMT
100 #include "services/mallocSiteTable.hpp"
101 #include "services/memTracker.hpp"
102 #include "utilities/nativeCallStack.hpp"
103 #endif // INCLUDE_NMT
104 #if INCLUDE_AOT
105 #include "aot/aotLoader.hpp"
106 #endif // INCLUDE_AOT
107
108 #ifdef LINUX
109 #include "osContainer_linux.hpp"
110 #endif
111
112 #define SIZE_T_MAX_VALUE ((size_t) -1)
113
114 #define CHECK_JNI_EXCEPTION_(env, value) \
115 do { \
116 JavaThread* THREAD = JavaThread::thread_from_jni_environment(env); \
117 THREAD->clear_pending_jni_exception_check(); \
118 if (HAS_PENDING_EXCEPTION) { \
119 return(value); \
120 } \
121 } while (0)
122
123 #define CHECK_JNI_EXCEPTION(env) \
124 do { \
125 JavaThread* THREAD = JavaThread::thread_from_jni_environment(env); \
126 THREAD->clear_pending_jni_exception_check(); \
127 if (HAS_PENDING_EXCEPTION) { \
128 return; \
129 } \
130 } while (0)
131
132 bool WhiteBox::_used = false;
133 volatile bool WhiteBox::compilation_locked = false;
134
135 class VM_WhiteBoxOperation : public VM_Operation {
136 public:
137 VM_WhiteBoxOperation() { }
138 VMOp_Type type() const { return VMOp_WhiteBoxOperation; }
139 bool allow_nested_vm_operations() const { return true; }
140 };
141
142
143 WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj))
144 return (jlong)(void*)JNIHandles::resolve(obj);
145 WB_END
146
147 WB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o))
148 return heapOopSize;
149 WB_END
150
151 WB_ENTRY(jint, WB_GetVMPageSize(JNIEnv* env, jobject o))
152 return os::vm_page_size();
153 WB_END
154
155 WB_ENTRY(jlong, WB_GetVMAllocationGranularity(JNIEnv* env, jobject o))
156 return os::vm_allocation_granularity();
157 WB_END
158
159 WB_ENTRY(jlong, WB_GetVMLargePageSize(JNIEnv* env, jobject o))
160 return os::large_page_size();
161 WB_END
162
163 class WBIsKlassAliveClosure : public LockedClassesDo {
164 Symbol* _name;
165 bool _found;
166 public:
167 WBIsKlassAliveClosure(Symbol* name) : _name(name), _found(false) {}
168
169 void do_klass(Klass* k) {
170 if (_found) return;
171 Symbol* ksym = k->name();
172 if (ksym->fast_compare(_name) == 0) {
173 _found = true;
174 }
175 }
176
177 bool found() const {
178 return _found;
179 }
180 };
181
182 WB_ENTRY(jboolean, WB_IsClassAlive(JNIEnv* env, jobject target, jstring name))
183 oop h_name = JNIHandles::resolve(name);
184 if (h_name == NULL) return false;
185 Symbol* sym = java_lang_String::as_symbol(h_name);
186 TempNewSymbol tsym(sym); // Make sure to decrement reference count on sym on return
187
188 WBIsKlassAliveClosure closure(sym);
189 ClassLoaderDataGraph::classes_do(&closure);
190
191 return closure.found();
192 WB_END
193
194 WB_ENTRY(jint, WB_GetSymbolRefcount(JNIEnv* env, jobject unused, jstring name))
195 oop h_name = JNIHandles::resolve(name);
196 if (h_name == NULL) return false;
197 Symbol* sym = java_lang_String::as_symbol(h_name);
198 TempNewSymbol tsym(sym); // Make sure to decrement reference count on sym on return
199 return (jint)sym->refcount();
200 WB_END
201
202
203 WB_ENTRY(void, WB_AddToBootstrapClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) {
204 #if INCLUDE_JVMTI
205 ResourceMark rm;
206 const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment));
207 JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION);
208 jvmtiError err = jvmti_env->AddToBootstrapClassLoaderSearch(seg);
209 assert(err == JVMTI_ERROR_NONE, "must not fail");
210 #endif
211 }
212 WB_END
213
214 WB_ENTRY(void, WB_AddToSystemClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) {
215 #if INCLUDE_JVMTI
216 ResourceMark rm;
217 const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment));
218 JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION);
219 jvmtiError err = jvmti_env->AddToSystemClassLoaderSearch(seg);
220 assert(err == JVMTI_ERROR_NONE, "must not fail");
221 #endif
222 }
223 WB_END
224
225
226 WB_ENTRY(jlong, WB_GetCompressedOopsMaxHeapSize(JNIEnv* env, jobject o)) {
227 return (jlong)Arguments::max_heap_for_compressed_oops();
228 }
229 WB_END
230
231 WB_ENTRY(void, WB_PrintHeapSizes(JNIEnv* env, jobject o)) {
232 tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap " SIZE_FORMAT " "
233 "Maximum heap " SIZE_FORMAT " Space alignment " SIZE_FORMAT " Heap alignment " SIZE_FORMAT,
234 MinHeapSize,
235 InitialHeapSize,
236 MaxHeapSize,
237 SpaceAlignment,
238 HeapAlignment);
239 }
240 WB_END
241
242 #ifndef PRODUCT
243 // Forward declaration
244 void TestReservedSpace_test();
245 void TestReserveMemorySpecial_test();
246 void TestVirtualSpace_test();
247 #endif
248
249 WB_ENTRY(void, WB_RunMemoryUnitTests(JNIEnv* env, jobject o))
250 #ifndef PRODUCT
251 TestReservedSpace_test();
252 TestReserveMemorySpecial_test();
253 TestVirtualSpace_test();
254 #endif
255 WB_END
256
257 WB_ENTRY(void, WB_ReadFromNoaccessArea(JNIEnv* env, jobject o))
258 size_t granularity = os::vm_allocation_granularity();
259 ReservedHeapSpace rhs(100 * granularity, granularity, false);
260 VirtualSpace vs;
261 vs.initialize(rhs, 50 * granularity);
262
263 // Check if constraints are complied
264 if (!( UseCompressedOops && rhs.base() != NULL &&
265 CompressedOops::base() != NULL &&
266 CompressedOops::use_implicit_null_checks() )) {
267 tty->print_cr("WB_ReadFromNoaccessArea method is useless:\n "
268 "\tUseCompressedOops is %d\n"
269 "\trhs.base() is " PTR_FORMAT "\n"
270 "\tCompressedOops::base() is " PTR_FORMAT "\n"
271 "\tCompressedOops::use_implicit_null_checks() is %d",
272 UseCompressedOops,
273 p2i(rhs.base()),
274 p2i(CompressedOops::base()),
275 CompressedOops::use_implicit_null_checks());
276 return;
277 }
278 tty->print_cr("Reading from no access area... ");
279 tty->print_cr("*(vs.low_boundary() - rhs.noaccess_prefix() / 2 ) = %c",
280 *(vs.low_boundary() - rhs.noaccess_prefix() / 2 ));
281 WB_END
282
283 static jint wb_stress_virtual_space_resize(size_t reserved_space_size,
284 size_t magnitude, size_t iterations) {
285 size_t granularity = os::vm_allocation_granularity();
286 ReservedHeapSpace rhs(reserved_space_size * granularity, granularity, false);
287 VirtualSpace vs;
288 if (!vs.initialize(rhs, 0)) {
289 tty->print_cr("Failed to initialize VirtualSpace. Can't proceed.");
290 return 3;
291 }
292
293 int seed = os::random();
294 tty->print_cr("Random seed is %d", seed);
295 os::init_random(seed);
296
297 for (size_t i = 0; i < iterations; i++) {
298
299 // Whether we will shrink or grow
300 bool shrink = os::random() % 2L == 0;
301
302 // Get random delta to resize virtual space
303 size_t delta = (size_t)os::random() % magnitude;
304
305 // If we are about to shrink virtual space below zero, then expand instead
306 if (shrink && vs.committed_size() < delta) {
307 shrink = false;
308 }
309
310 // Resizing by delta
311 if (shrink) {
312 vs.shrink_by(delta);
313 } else {
314 // If expanding fails expand_by will silently return false
315 vs.expand_by(delta, true);
316 }
317 }
318 return 0;
319 }
320
321 WB_ENTRY(jint, WB_StressVirtualSpaceResize(JNIEnv* env, jobject o,
322 jlong reserved_space_size, jlong magnitude, jlong iterations))
323 tty->print_cr("reservedSpaceSize=" JLONG_FORMAT ", magnitude=" JLONG_FORMAT ", "
324 "iterations=" JLONG_FORMAT "\n", reserved_space_size, magnitude,
325 iterations);
326 if (reserved_space_size < 0 || magnitude < 0 || iterations < 0) {
327 tty->print_cr("One of variables printed above is negative. Can't proceed.\n");
328 return 1;
329 }
330
331 // sizeof(size_t) depends on whether OS is 32bit or 64bit. sizeof(jlong) is
332 // always 8 byte. That's why we should avoid overflow in case of 32bit platform.
333 if (sizeof(size_t) < sizeof(jlong)) {
334 jlong size_t_max_value = (jlong) SIZE_T_MAX_VALUE;
335 if (reserved_space_size > size_t_max_value || magnitude > size_t_max_value
336 || iterations > size_t_max_value) {
337 tty->print_cr("One of variables printed above overflows size_t. Can't proceed.\n");
338 return 2;
339 }
340 }
341
342 return wb_stress_virtual_space_resize((size_t) reserved_space_size,
343 (size_t) magnitude, (size_t) iterations);
344 WB_END
345
346 WB_ENTRY(jboolean, WB_IsGCSupported(JNIEnv* env, jobject o, jint name))
347 return GCConfig::is_gc_supported((CollectedHeap::Name)name);
348 WB_END
349
350 WB_ENTRY(jboolean, WB_IsGCSelected(JNIEnv* env, jobject o, jint name))
351 return GCConfig::is_gc_selected((CollectedHeap::Name)name);
352 WB_END
353
354 WB_ENTRY(jboolean, WB_IsGCSelectedErgonomically(JNIEnv* env, jobject o))
355 return GCConfig::is_gc_selected_ergonomically();
356 WB_END
357
358 WB_ENTRY(jboolean, WB_isObjectInOldGen(JNIEnv* env, jobject o, jobject obj))
359 oop p = JNIHandles::resolve(obj);
360 #if INCLUDE_G1GC
361 if (UseG1GC) {
362 G1CollectedHeap* g1h = G1CollectedHeap::heap();
363 const HeapRegion* hr = g1h->heap_region_containing(p);
364 if (hr == NULL) {
365 return false;
366 }
367 return !(hr->is_young());
368 }
369 #endif
370 #if INCLUDE_PARALLELGC
371 if (UseParallelGC) {
372 ParallelScavengeHeap* psh = ParallelScavengeHeap::heap();
373 return !psh->is_in_young(p);
374 }
375 #endif
376 #if INCLUDE_ZGC
377 if (UseZGC) {
378 return Universe::heap()->is_in(p);
379 }
380 #endif
381 GenCollectedHeap* gch = GenCollectedHeap::heap();
382 return !gch->is_in_young(p);
383 WB_END
384
385 WB_ENTRY(jlong, WB_GetObjectSize(JNIEnv* env, jobject o, jobject obj))
386 oop p = JNIHandles::resolve(obj);
387 return Universe::heap()->obj_size(p) * HeapWordSize;
388 WB_END
389
390 WB_ENTRY(jlong, WB_GetHeapSpaceAlignment(JNIEnv* env, jobject o))
391 return (jlong)SpaceAlignment;
392 WB_END
393
394 WB_ENTRY(jlong, WB_GetHeapAlignment(JNIEnv* env, jobject o))
395 return (jlong)HeapAlignment;
396 WB_END
397
398 WB_ENTRY(jboolean, WB_SupportsConcurrentGCPhaseControl(JNIEnv* env, jobject o))
399 return Universe::heap()->supports_concurrent_phase_control();
400 WB_END
401
402 WB_ENTRY(jboolean, WB_RequestConcurrentGCPhase(JNIEnv* env, jobject o, jstring name))
403 Handle h_name(THREAD, JNIHandles::resolve(name));
404 ResourceMark rm;
405 const char* c_name = java_lang_String::as_utf8_string(h_name());
406 return Universe::heap()->request_concurrent_phase(c_name);
407 WB_END
408
409 #if INCLUDE_G1GC
410
411 WB_ENTRY(jboolean, WB_G1IsHumongous(JNIEnv* env, jobject o, jobject obj))
412 if (UseG1GC) {
413 G1CollectedHeap* g1h = G1CollectedHeap::heap();
414 oop result = JNIHandles::resolve(obj);
415 const HeapRegion* hr = g1h->heap_region_containing(result);
416 return hr->is_humongous();
417 }
418 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1IsHumongous: G1 GC is not enabled");
419 WB_END
420
421 WB_ENTRY(jboolean, WB_G1BelongsToHumongousRegion(JNIEnv* env, jobject o, jlong addr))
422 if (UseG1GC) {
423 G1CollectedHeap* g1h = G1CollectedHeap::heap();
424 const HeapRegion* hr = g1h->heap_region_containing((void*) addr);
425 return hr->is_humongous();
426 }
427 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1BelongsToHumongousRegion: G1 GC is not enabled");
428 WB_END
429
430 WB_ENTRY(jboolean, WB_G1BelongsToFreeRegion(JNIEnv* env, jobject o, jlong addr))
431 if (UseG1GC) {
432 G1CollectedHeap* g1h = G1CollectedHeap::heap();
433 const HeapRegion* hr = g1h->heap_region_containing((void*) addr);
434 return hr->is_free();
435 }
436 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1BelongsToFreeRegion: G1 GC is not enabled");
437 WB_END
438
439 WB_ENTRY(jlong, WB_G1NumMaxRegions(JNIEnv* env, jobject o))
440 if (UseG1GC) {
441 G1CollectedHeap* g1h = G1CollectedHeap::heap();
442 size_t nr = g1h->max_regions();
443 return (jlong)nr;
444 }
445 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1NumMaxRegions: G1 GC is not enabled");
446 WB_END
447
448 WB_ENTRY(jlong, WB_G1NumFreeRegions(JNIEnv* env, jobject o))
449 if (UseG1GC) {
450 G1CollectedHeap* g1h = G1CollectedHeap::heap();
451 size_t nr = g1h->num_free_regions();
452 return (jlong)nr;
453 }
454 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1NumFreeRegions: G1 GC is not enabled");
455 WB_END
456
457 WB_ENTRY(jboolean, WB_G1InConcurrentMark(JNIEnv* env, jobject o))
458 if (UseG1GC) {
459 G1CollectedHeap* g1h = G1CollectedHeap::heap();
460 return g1h->concurrent_mark()->cm_thread()->during_cycle();
461 }
462 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1InConcurrentMark: G1 GC is not enabled");
463 WB_END
464
465 WB_ENTRY(jboolean, WB_G1StartMarkCycle(JNIEnv* env, jobject o))
466 if (UseG1GC) {
467 if (AsyncDeflateIdleMonitors) {
468 // AsyncDeflateIdleMonitors needs to know when System.gc() or
469 // the equivalent is called so any special clean up can be done
470 // at a safepoint, e.g., TestHumongousClassLoader.java.
471 ObjectSynchronizer::set_is_special_deflation_requested(true);
472 }
473 G1CollectedHeap* g1h = G1CollectedHeap::heap();
474 if (!g1h->concurrent_mark()->cm_thread()->during_cycle()) {
475 g1h->collect(GCCause::_wb_conc_mark);
476 return true;
477 }
478 return false;
479 }
480 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1StartMarkCycle: G1 GC is not enabled");
481 WB_END
482
483 WB_ENTRY(jint, WB_G1RegionSize(JNIEnv* env, jobject o))
484 if (UseG1GC) {
485 return (jint)HeapRegion::GrainBytes;
486 }
487 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1RegionSize: G1 GC is not enabled");
488 WB_END
489
490 #endif // INCLUDE_G1GC
491
492 #if INCLUDE_G1GC || INCLUDE_PARALLELGC
493 WB_ENTRY(jlong, WB_DramReservedStart(JNIEnv* env, jobject o))
494 #if INCLUDE_G1GC
495 if (UseG1GC) {
496 G1CollectedHeap* g1h = G1CollectedHeap::heap();
497 if (g1h->is_heterogeneous_heap()) {
498 uint start_region = HeterogeneousHeapRegionManager::manager()->start_index_of_dram();
499 return (jlong)(g1h->base() + start_region * HeapRegion::GrainBytes);
500 } else {
501 return (jlong)g1h->base();
502 }
503 }
504 #endif // INCLUDE_G1GC
505 #if INCLUDE_PARALLELGC
506 if (UseParallelGC) {
507 ParallelScavengeHeap* ps_heap = ParallelScavengeHeap::heap();
508 if (AllocateOldGenAt != NULL) {
509 MemRegion reserved = ps_heap->young_gen()->reserved();
510 return (jlong)reserved.start();
511 } else {
512 return (jlong)ps_heap->base();
513 }
514 }
515 #endif // INCLUDE_PARALLELGC
516 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_DramReservedStart: enabled only for G1 and Parallel GC");
517 WB_END
518
519 WB_ENTRY(jlong, WB_DramReservedEnd(JNIEnv* env, jobject o))
520 #if INCLUDE_G1GC
521 if (UseG1GC) {
522 G1CollectedHeap* g1h = G1CollectedHeap::heap();
523 if (g1h->is_heterogeneous_heap()) {
524 uint end_region = HeterogeneousHeapRegionManager::manager()->end_index_of_dram();
525 return (jlong)(g1h->base() + (end_region + 1) * HeapRegion::GrainBytes - 1);
526 } else {
527 return (jlong)g1h->base() + G1Arguments::heap_max_size_bytes();
528 }
529 }
530 #endif // INCLUDE_G1GC
531 #if INCLUDE_PARALLELGC
532 if (UseParallelGC) {
533 ParallelScavengeHeap* ps_heap = ParallelScavengeHeap::heap();
534 if (AllocateOldGenAt != NULL) {
535 MemRegion reserved = ps_heap->young_gen()->reserved();
536 return (jlong)reserved.end();
537 } else {
538 return (jlong)ps_heap->reserved_region().end();
539 }
540 }
541 #endif // INCLUDE_PARALLELGC
542 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_DramReservedEnd: enabled only for G1 and Parallel GC");
543 WB_END
544
545 WB_ENTRY(jlong, WB_NvdimmReservedStart(JNIEnv* env, jobject o))
546 #if INCLUDE_G1GC
547 if (UseG1GC) {
548 G1CollectedHeap* g1h = G1CollectedHeap::heap();
549 if (g1h->is_heterogeneous_heap()) {
550 uint start_region = HeterogeneousHeapRegionManager::manager()->start_index_of_nvdimm();
551 return (jlong)(g1h->base() + start_region * HeapRegion::GrainBytes);
552 } else {
553 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_NvdimmReservedStart: Old gen is not allocated on NV-DIMM using AllocateOldGenAt flag");
554 }
555 }
556 #endif // INCLUDE_G1GC
557 #if INCLUDE_PARALLELGC
558 if (UseParallelGC) {
559 ParallelScavengeHeap* ps_heap = ParallelScavengeHeap::heap();
560 if (AllocateOldGenAt != NULL) {
561 MemRegion reserved = ps_heap->old_gen()->reserved();
562 return (jlong)reserved.start();
563 } else {
564 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_NvdimmReservedStart: Old gen is not allocated on NV-DIMM using AllocateOldGenAt flag");
565 }
566 }
567 #endif // INCLUDE_PARALLELGC
568 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_NvdimmReservedStart: enabled only for G1 and Parallel GC");
569 WB_END
570
571 WB_ENTRY(jlong, WB_NvdimmReservedEnd(JNIEnv* env, jobject o))
572 #if INCLUDE_G1GC
573 if (UseG1GC) {
574 G1CollectedHeap* g1h = G1CollectedHeap::heap();
575 if (g1h->is_heterogeneous_heap()) {
576 uint end_region = HeterogeneousHeapRegionManager::manager()->start_index_of_nvdimm();
577 return (jlong)(g1h->base() + (end_region + 1) * HeapRegion::GrainBytes - 1);
578 } else {
579 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_NvdimmReservedEnd: Old gen is not allocated on NV-DIMM using AllocateOldGenAt flag");
580 }
581 }
582 #endif // INCLUDE_G1GC
583 #if INCLUDE_PARALLELGC
584 if (UseParallelGC) {
585 ParallelScavengeHeap* ps_heap = ParallelScavengeHeap::heap();
586 if (AllocateOldGenAt != NULL) {
587 MemRegion reserved = ps_heap->old_gen()->reserved();
588 return (jlong)reserved.end();
589 } else {
590 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_NvdimmReservedEnd: Old gen is not allocated on NV-DIMM using AllocateOldGenAt flag");
591 }
592 }
593 #endif // INCLUDE_PARALLELGC
594 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_NvdimmReservedEnd: enabled only for G1 and Parallel GC");
595 WB_END
596
597 #endif // INCLUDE_G1GC || INCLUDE_PARALLELGC
598
599 #if INCLUDE_PARALLELGC
600
601 WB_ENTRY(jlong, WB_PSVirtualSpaceAlignment(JNIEnv* env, jobject o))
602 if (UseParallelGC) {
603 return ParallelScavengeHeap::heap()->gens()->virtual_spaces()->alignment();
604 }
605 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_PSVirtualSpaceAlignment: Parallel GC is not enabled");
606 WB_END
607
608 WB_ENTRY(jlong, WB_PSHeapGenerationAlignment(JNIEnv* env, jobject o))
609 if (UseParallelGC) {
610 return GenAlignment;
611 }
612 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_PSHeapGenerationAlignment: Parallel GC is not enabled");
613 WB_END
614
615 #endif // INCLUDE_PARALLELGC
616
617 #if INCLUDE_G1GC
618
619 WB_ENTRY(jobject, WB_G1AuxiliaryMemoryUsage(JNIEnv* env))
620 if (UseG1GC) {
621 ResourceMark rm(THREAD);
622 G1CollectedHeap* g1h = G1CollectedHeap::heap();
623 MemoryUsage usage = g1h->get_auxiliary_data_memory_usage();
624 Handle h = MemoryService::create_MemoryUsage_obj(usage, CHECK_NULL);
625 return JNIHandles::make_local(env, h());
626 }
627 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1AuxiliaryMemoryUsage: G1 GC is not enabled");
628 WB_END
629
630 WB_ENTRY(jint, WB_G1ActiveMemoryNodeCount(JNIEnv* env, jobject o))
631 if (UseG1GC) {
632 G1NUMA* numa = G1NUMA::numa();
633 return (jint)numa->num_active_nodes();
634 }
635 THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1ActiveMemoryNodeCount: G1 GC is not enabled");
636 WB_END
637
638 WB_ENTRY(jintArray, WB_G1MemoryNodeIds(JNIEnv* env, jobject o))
639 if (UseG1GC) {
640 G1NUMA* numa = G1NUMA::numa();
641 int num_node_ids = (int)numa->num_active_nodes();
642 const int* node_ids = numa->node_ids();
643
644 typeArrayOop result = oopFactory::new_intArray(num_node_ids, CHECK_NULL);
645 for (int i = 0; i < num_node_ids; i++) {
646 result->int_at_put(i, (jint)node_ids[i]);
647 }
648 return (jintArray) JNIHandles::make_local(env, result);
649 }
650 THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1MemoryNodeIds: G1 GC is not enabled");
651 WB_END
652
653 class OldRegionsLivenessClosure: public HeapRegionClosure {
654
655 private:
656 const int _liveness;
657 size_t _total_count;
658 size_t _total_memory;
659 size_t _total_memory_to_free;
660
661 public:
662 OldRegionsLivenessClosure(int liveness) :
663 _liveness(liveness),
664 _total_count(0),
665 _total_memory(0),
666 _total_memory_to_free(0) { }
667
668 size_t total_count() { return _total_count; }
669 size_t total_memory() { return _total_memory; }
670 size_t total_memory_to_free() { return _total_memory_to_free; }
671
672 bool do_heap_region(HeapRegion* r) {
673 if (r->is_old()) {
674 size_t prev_live = r->marked_bytes();
675 size_t live = r->live_bytes();
676 size_t size = r->used();
677 size_t reg_size = HeapRegion::GrainBytes;
678 if (size > 0 && ((int)(live * 100 / size) < _liveness)) {
679 _total_memory += size;
680 ++_total_count;
681 if (size == reg_size) {
682 // we don't include non-full regions since they are unlikely included in mixed gc
683 // for testing purposes it's enough to have lowest estimation of total memory that is expected to be freed
684 _total_memory_to_free += size - prev_live;
685 }
686 }
687 }
688 return false;
689 }
690 };
691
692
693 WB_ENTRY(jlongArray, WB_G1GetMixedGCInfo(JNIEnv* env, jobject o, jint liveness))
694 if (!UseG1GC) {
695 THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1GetMixedGCInfo: G1 GC is not enabled");
696 }
697 if (liveness < 0) {
698 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "liveness value should be non-negative");
699 }
700
701 G1CollectedHeap* g1h = G1CollectedHeap::heap();
702 OldRegionsLivenessClosure rli(liveness);
703 g1h->heap_region_iterate(&rli);
704
705 typeArrayOop result = oopFactory::new_longArray(3, CHECK_NULL);
706 result->long_at_put(0, rli.total_count());
707 result->long_at_put(1, rli.total_memory());
708 result->long_at_put(2, rli.total_memory_to_free());
709 return (jlongArray) JNIHandles::make_local(env, result);
710 WB_END
711
712 #endif // INCLUDE_G1GC
713
714 #if INCLUDE_NMT
715 // Alloc memory using the test memory type so that we can use that to see if
716 // NMT picks it up correctly
717 WB_ENTRY(jlong, WB_NMTMalloc(JNIEnv* env, jobject o, jlong size))
718 jlong addr = 0;
719 addr = (jlong)(uintptr_t)os::malloc(size, mtTest);
720 return addr;
721 WB_END
722
723 // Alloc memory with pseudo call stack. The test can create psudo malloc
724 // allocation site to stress the malloc tracking.
725 WB_ENTRY(jlong, WB_NMTMallocWithPseudoStack(JNIEnv* env, jobject o, jlong size, jint pseudo_stack))
726 address pc = (address)(size_t)pseudo_stack;
727 NativeCallStack stack(&pc, 1);
728 return (jlong)(uintptr_t)os::malloc(size, mtTest, stack);
729 WB_END
730
731 // Alloc memory with pseudo call stack and specific memory type.
732 WB_ENTRY(jlong, WB_NMTMallocWithPseudoStackAndType(JNIEnv* env, jobject o, jlong size, jint pseudo_stack, jint type))
733 address pc = (address)(size_t)pseudo_stack;
734 NativeCallStack stack(&pc, 1);
735 return (jlong)(uintptr_t)os::malloc(size, (MEMFLAGS)type, stack);
736 WB_END
737
738 // Free the memory allocated by NMTAllocTest
739 WB_ENTRY(void, WB_NMTFree(JNIEnv* env, jobject o, jlong mem))
740 os::free((void*)(uintptr_t)mem);
741 WB_END
742
743 WB_ENTRY(jlong, WB_NMTReserveMemory(JNIEnv* env, jobject o, jlong size))
744 jlong addr = 0;
745
746 addr = (jlong)(uintptr_t)os::reserve_memory(size);
747 MemTracker::record_virtual_memory_type((address)addr, mtTest);
748
749 return addr;
750 WB_END
751
752 WB_ENTRY(jlong, WB_NMTAttemptReserveMemoryAt(JNIEnv* env, jobject o, jlong addr, jlong size))
753 addr = (jlong)(uintptr_t)os::attempt_reserve_memory_at((size_t)size, (char*)(uintptr_t)addr);
754 MemTracker::record_virtual_memory_type((address)addr, mtTest);
755
756 return addr;
757 WB_END
758
759 WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
760 os::commit_memory((char *)(uintptr_t)addr, size, !ExecMem);
761 MemTracker::record_virtual_memory_type((address)(uintptr_t)addr, mtTest);
762 WB_END
763
764 WB_ENTRY(void, WB_NMTUncommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
765 os::uncommit_memory((char *)(uintptr_t)addr, size);
766 WB_END
767
768 WB_ENTRY(void, WB_NMTReleaseMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
769 os::release_memory((char *)(uintptr_t)addr, size);
770 WB_END
771
772 WB_ENTRY(jboolean, WB_NMTChangeTrackingLevel(JNIEnv* env))
773 // Test that we can downgrade NMT levels but not upgrade them.
774 if (MemTracker::tracking_level() == NMT_off) {
775 MemTracker::transition_to(NMT_off);
776 return MemTracker::tracking_level() == NMT_off;
777 } else {
778 assert(MemTracker::tracking_level() == NMT_detail, "Should start out as detail tracking");
779 MemTracker::transition_to(NMT_summary);
780 assert(MemTracker::tracking_level() == NMT_summary, "Should be summary now");
781
782 // Can't go to detail once NMT is set to summary.
783 MemTracker::transition_to(NMT_detail);
784 assert(MemTracker::tracking_level() == NMT_summary, "Should still be summary now");
785
786 // Shutdown sets tracking level to minimal.
787 MemTracker::shutdown();
788 assert(MemTracker::tracking_level() == NMT_minimal, "Should be minimal now");
789
790 // Once the tracking level is minimal, we cannot increase to summary.
791 // The code ignores this request instead of asserting because if the malloc site
792 // table overflows in another thread, it tries to change the code to summary.
793 MemTracker::transition_to(NMT_summary);
794 assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now");
795
796 // Really can never go up to detail, verify that the code would never do this.
797 MemTracker::transition_to(NMT_detail);
798 assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now");
799 return MemTracker::tracking_level() == NMT_minimal;
800 }
801 WB_END
802
803 WB_ENTRY(jint, WB_NMTGetHashSize(JNIEnv* env, jobject o))
804 int hash_size = MallocSiteTable::hash_buckets();
805 assert(hash_size > 0, "NMT hash_size should be > 0");
806 return (jint)hash_size;
807 WB_END
808
809 WB_ENTRY(jlong, WB_NMTNewArena(JNIEnv* env, jobject o, jlong init_size))
810 Arena* arena = new (mtTest) Arena(mtTest, size_t(init_size));
811 return (jlong)arena;
812 WB_END
813
814 WB_ENTRY(void, WB_NMTFreeArena(JNIEnv* env, jobject o, jlong arena))
815 Arena* a = (Arena*)arena;
816 delete a;
817 WB_END
818
819 WB_ENTRY(void, WB_NMTArenaMalloc(JNIEnv* env, jobject o, jlong arena, jlong size))
820 Arena* a = (Arena*)arena;
821 a->Amalloc(size_t(size));
822 WB_END
823 #endif // INCLUDE_NMT
824
825 static jmethodID reflected_method_to_jmid(JavaThread* thread, JNIEnv* env, jobject method) {
826 assert(method != NULL, "method should not be null");
827 ThreadToNativeFromVM ttn(thread);
828 return env->FromReflectedMethod(method);
829 }
830
831 // Deoptimizes all compiled frames and makes nmethods not entrant if it's requested
832 class VM_WhiteBoxDeoptimizeFrames : public VM_WhiteBoxOperation {
833 private:
834 int _result;
835 const bool _make_not_entrant;
836 public:
837 VM_WhiteBoxDeoptimizeFrames(bool make_not_entrant) :
838 _result(0), _make_not_entrant(make_not_entrant) { }
839 int result() const { return _result; }
840
841 void doit() {
842 for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
843 if (t->has_last_Java_frame()) {
844 for (StackFrameStream fst(t, UseBiasedLocking); !fst.is_done(); fst.next()) {
845 frame* f = fst.current();
846 if (f->can_be_deoptimized() && !f->is_deoptimized_frame()) {
847 RegisterMap* reg_map = fst.register_map();
848 Deoptimization::deoptimize(t, *f, reg_map);
849 if (_make_not_entrant) {
850 CompiledMethod* cm = CodeCache::find_compiled(f->pc());
851 assert(cm != NULL, "sanity check");
852 cm->make_not_entrant();
853 }
854 ++_result;
855 }
856 }
857 }
858 }
859 }
860 };
861
862 WB_ENTRY(jint, WB_DeoptimizeFrames(JNIEnv* env, jobject o, jboolean make_not_entrant))
863 VM_WhiteBoxDeoptimizeFrames op(make_not_entrant == JNI_TRUE);
864 VMThread::execute(&op);
865 return op.result();
866 WB_END
867
868 WB_ENTRY(void, WB_DeoptimizeAll(JNIEnv* env, jobject o))
869 CodeCache::mark_all_nmethods_for_deoptimization();
870 Deoptimization::deoptimize_all_marked();
871 WB_END
872
873 WB_ENTRY(jint, WB_DeoptimizeMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
874 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
875 int result = 0;
876 CHECK_JNI_EXCEPTION_(env, result);
877 MutexLocker mu(Compile_lock);
878 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
879 if (is_osr) {
880 result += mh->mark_osr_nmethods();
881 } else if (mh->code() != NULL) {
882 mh->code()->mark_for_deoptimization();
883 ++result;
884 }
885 result += CodeCache::mark_for_deoptimization(mh());
886 if (result > 0) {
887 Deoptimization::deoptimize_all_marked();
888 }
889 return result;
890 WB_END
891
892 WB_ENTRY(jboolean, WB_IsMethodCompiled(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
893 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
894 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
895 MutexLocker mu(Compile_lock);
896 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
897 CompiledMethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
898 if (code == NULL) {
899 return JNI_FALSE;
900 }
901 return (code->is_alive() && !code->is_marked_for_deoptimization());
902 WB_END
903
904 WB_ENTRY(jboolean, WB_IsMethodCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr))
905 if (method == NULL || comp_level > MIN2((CompLevel) TieredStopAtLevel, CompLevel_highest_tier)) {
906 return false;
907 }
908 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
909 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
910 MutexLocker mu(Compile_lock);
911 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
912 if (is_osr) {
913 return CompilationPolicy::can_be_osr_compiled(mh, comp_level);
914 } else {
915 return CompilationPolicy::can_be_compiled(mh, comp_level);
916 }
917 WB_END
918
919 WB_ENTRY(jboolean, WB_IsMethodQueuedForCompilation(JNIEnv* env, jobject o, jobject method))
920 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
921 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
922 MutexLocker mu(Compile_lock);
923 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
924 return mh->queued_for_compilation();
925 WB_END
926
927 WB_ENTRY(jboolean, WB_IsIntrinsicAvailable(JNIEnv* env, jobject o, jobject method, jobject compilation_context, jint compLevel))
928 if (compLevel < CompLevel_none || compLevel > MIN2((CompLevel) TieredStopAtLevel, CompLevel_highest_tier)) {
929 return false; // Intrinsic is not available on a non-existent compilation level.
930 }
931 jmethodID method_id, compilation_context_id;
932 method_id = reflected_method_to_jmid(thread, env, method);
933 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
934 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(method_id));
935
936 DirectiveSet* directive;
937 AbstractCompiler* comp = CompileBroker::compiler((int)compLevel);
938 assert(comp != NULL, "compiler not available");
939 if (compilation_context != NULL) {
940 compilation_context_id = reflected_method_to_jmid(thread, env, compilation_context);
941 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
942 methodHandle cch(THREAD, Method::checked_resolve_jmethod_id(compilation_context_id));
943 directive = DirectivesStack::getMatchingDirective(cch, comp);
944 } else {
945 // Calling with NULL matches default directive
946 directive = DirectivesStack::getDefaultDirective(comp);
947 }
948 bool result = comp->is_intrinsic_available(mh, directive);
949 DirectivesStack::release(directive);
950 return result;
951 WB_END
952
953 WB_ENTRY(jint, WB_GetMethodCompilationLevel(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
954 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
955 CHECK_JNI_EXCEPTION_(env, CompLevel_none);
956 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
957 CompiledMethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
958 return (code != NULL ? code->comp_level() : CompLevel_none);
959 WB_END
960
961 WB_ENTRY(void, WB_MakeMethodNotCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr))
962 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
963 CHECK_JNI_EXCEPTION(env);
964 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
965 if (is_osr) {
966 mh->set_not_osr_compilable("WhiteBox", comp_level);
967 } else {
968 mh->set_not_compilable("WhiteBox", comp_level);
969 }
970 WB_END
971
972 WB_ENTRY(jint, WB_GetMethodEntryBci(JNIEnv* env, jobject o, jobject method))
973 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
974 CHECK_JNI_EXCEPTION_(env, InvocationEntryBci);
975 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
976 CompiledMethod* code = mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false);
977 return (code != NULL && code->is_osr_method() ? code->osr_entry_bci() : InvocationEntryBci);
978 WB_END
979
980 WB_ENTRY(jboolean, WB_TestSetDontInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
981 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
982 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
983 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
984 bool result = mh->dont_inline();
985 mh->set_dont_inline(value == JNI_TRUE);
986 return result;
987 WB_END
988
989 WB_ENTRY(jint, WB_GetCompileQueueSize(JNIEnv* env, jobject o, jint comp_level))
990 if (comp_level == CompLevel_any) {
991 return CompileBroker::queue_size(CompLevel_full_optimization) /* C2 */ +
992 CompileBroker::queue_size(CompLevel_full_profile) /* C1 */;
993 } else {
994 return CompileBroker::queue_size(comp_level);
995 }
996 WB_END
997
998 WB_ENTRY(jboolean, WB_TestSetForceInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
999 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1000 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
1001 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
1002 bool result = mh->force_inline();
1003 mh->set_force_inline(value == JNI_TRUE);
1004 return result;
1005 WB_END
1006
1007 bool WhiteBox::compile_method(Method* method, int comp_level, int bci, Thread* THREAD) {
1008 // Screen for unavailable/bad comp level or null method
1009 AbstractCompiler* comp = CompileBroker::compiler(comp_level);
1010 if (method == NULL) {
1011 tty->print_cr("WB error: request to compile NULL method");
1012 return false;
1013 }
1014 if (comp_level > MIN2((CompLevel) TieredStopAtLevel, CompLevel_highest_tier)) {
1015 tty->print_cr("WB error: invalid compilation level %d", comp_level);
1016 return false;
1017 }
1018 if (comp == NULL) {
1019 tty->print_cr("WB error: no compiler for requested compilation level %d", comp_level);
1020 return false;
1021 }
1022
1023 // Check if compilation is blocking
1024 methodHandle mh(THREAD, method);
1025 DirectiveSet* directive = DirectivesStack::getMatchingDirective(mh, comp);
1026 bool is_blocking = !directive->BackgroundCompilationOption;
1027 DirectivesStack::release(directive);
1028
1029 // Compile method and check result
1030 nmethod* nm = CompileBroker::compile_method(mh, bci, comp_level, mh, mh->invocation_count(), CompileTask::Reason_Whitebox, THREAD);
1031 MutexLocker mu(Compile_lock);
1032 bool is_queued = mh->queued_for_compilation();
1033 if ((!is_blocking && is_queued) || nm != NULL) {
1034 return true;
1035 }
1036 tty->print("WB error: failed to %s compile at level %d method ", is_blocking ? "blocking" : "", comp_level);
1037 mh->print_short_name(tty);
1038 tty->cr();
1039 if (is_blocking && is_queued) {
1040 tty->print_cr("WB error: blocking compilation is still in queue!");
1041 }
1042 return false;
1043 }
1044
1045 WB_ENTRY(jboolean, WB_EnqueueMethodForCompilation(JNIEnv* env, jobject o, jobject method, jint comp_level, jint bci))
1046 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1047 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
1048 return WhiteBox::compile_method(Method::checked_resolve_jmethod_id(jmid), comp_level, bci, THREAD);
1049 WB_END
1050
1051 WB_ENTRY(jboolean, WB_EnqueueInitializerForCompilation(JNIEnv* env, jobject o, jclass klass, jint comp_level))
1052 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1053 Method* clinit = ik->class_initializer();
1054 if (clinit == NULL) {
1055 return false;
1056 }
1057 return WhiteBox::compile_method(clinit, comp_level, InvocationEntryBci, THREAD);
1058 WB_END
1059
1060 WB_ENTRY(jboolean, WB_ShouldPrintAssembly(JNIEnv* env, jobject o, jobject method, jint comp_level))
1061 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1062 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
1063
1064 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
1065 DirectiveSet* directive = DirectivesStack::getMatchingDirective(mh, CompileBroker::compiler(comp_level));
1066 bool result = directive->PrintAssemblyOption;
1067 DirectivesStack::release(directive);
1068
1069 return result;
1070 WB_END
1071
1072 WB_ENTRY(jint, WB_MatchesInline(JNIEnv* env, jobject o, jobject method, jstring pattern))
1073 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1074 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
1075
1076 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
1077
1078 ResourceMark rm;
1079 const char* error_msg = NULL;
1080 char* method_str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(pattern));
1081 InlineMatcher* m = InlineMatcher::parse_inline_pattern(method_str, error_msg);
1082
1083 if (m == NULL) {
1084 assert(error_msg != NULL, "Always have an error message");
1085 tty->print_cr("Got error: %s", error_msg);
1086 return -1; // Pattern failed
1087 }
1088
1089 // Pattern works - now check if it matches
1090 int result;
1091 if (m->match(mh, InlineMatcher::force_inline)) {
1092 result = 2; // Force inline match
1093 } else if (m->match(mh, InlineMatcher::dont_inline)) {
1094 result = 1; // Dont inline match
1095 } else {
1096 result = 0; // No match
1097 }
1098 delete m;
1099 return result;
1100 WB_END
1101
1102 WB_ENTRY(jint, WB_MatchesMethod(JNIEnv* env, jobject o, jobject method, jstring pattern))
1103 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1104 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
1105
1106 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
1107
1108 ResourceMark rm;
1109 char* method_str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(pattern));
1110
1111 const char* error_msg = NULL;
1112
1113 BasicMatcher* m = BasicMatcher::parse_method_pattern(method_str, error_msg);
1114 if (m == NULL) {
1115 assert(error_msg != NULL, "Must have error_msg");
1116 tty->print_cr("Got error: %s", error_msg);
1117 return -1;
1118 }
1119
1120 // Pattern works - now check if it matches
1121 int result = m->matches(mh);
1122 delete m;
1123 assert(result == 0 || result == 1, "Result out of range");
1124 return result;
1125 WB_END
1126
1127 WB_ENTRY(void, WB_MarkMethodProfiled(JNIEnv* env, jobject o, jobject method))
1128 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1129 CHECK_JNI_EXCEPTION(env);
1130 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
1131
1132 MethodData* mdo = mh->method_data();
1133 if (mdo == NULL) {
1134 Method::build_interpreter_method_data(mh, CHECK_AND_CLEAR);
1135 mdo = mh->method_data();
1136 }
1137 mdo->init();
1138 InvocationCounter* icnt = mdo->invocation_counter();
1139 InvocationCounter* bcnt = mdo->backedge_counter();
1140 // set i-counter according to TieredThresholdPolicy::is_method_profiled
1141 icnt->set(InvocationCounter::wait_for_compile, Tier4MinInvocationThreshold);
1142 bcnt->set(InvocationCounter::wait_for_compile, Tier4CompileThreshold);
1143 WB_END
1144
1145 WB_ENTRY(void, WB_ClearMethodState(JNIEnv* env, jobject o, jobject method))
1146 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1147 CHECK_JNI_EXCEPTION(env);
1148 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
1149 MutexLocker mu(Compile_lock);
1150 MethodData* mdo = mh->method_data();
1151 MethodCounters* mcs = mh->method_counters();
1152
1153 if (mdo != NULL) {
1154 mdo->init();
1155 ResourceMark rm;
1156 int arg_count = mdo->method()->size_of_parameters();
1157 for (int i = 0; i < arg_count; i++) {
1158 mdo->set_arg_modified(i, 0);
1159 }
1160 MutexLocker mu(mdo->extra_data_lock());
1161 mdo->clean_method_data(/*always_clean*/true);
1162 }
1163
1164 mh->clear_not_c1_compilable();
1165 mh->clear_not_c2_compilable();
1166 mh->clear_not_c2_osr_compilable();
1167 NOT_PRODUCT(mh->set_compiled_invocation_count(0));
1168 if (mcs != NULL) {
1169 mcs->backedge_counter()->init();
1170 mcs->invocation_counter()->init();
1171 mcs->set_interpreter_invocation_count(0);
1172 mcs->set_interpreter_throwout_count(0);
1173
1174 #ifdef TIERED
1175 mcs->set_rate(0.0F);
1176 mh->set_prev_event_count(0);
1177 mh->set_prev_time(0);
1178 #endif
1179 }
1180 WB_END
1181
1182 template <typename T>
1183 static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, JVMFlag::Error (*TAt)(const JVMFlag*, T*)) {
1184 if (name == NULL) {
1185 return false;
1186 }
1187 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1188 const char* flag_name = env->GetStringUTFChars(name, NULL);
1189 CHECK_JNI_EXCEPTION_(env, false);
1190 const JVMFlag* flag = JVMFlag::find_declared_flag(flag_name);
1191 JVMFlag::Error result = (*TAt)(flag, value);
1192 env->ReleaseStringUTFChars(name, flag_name);
1193 return (result == JVMFlag::SUCCESS);
1194 }
1195
1196 template <typename T>
1197 static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, JVMFlag::Error (*TAtPut)(JVMFlag* flag, T*, JVMFlag::Flags)) {
1198 if (name == NULL) {
1199 return false;
1200 }
1201 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1202 const char* flag_name = env->GetStringUTFChars(name, NULL);
1203 CHECK_JNI_EXCEPTION_(env, false);
1204 JVMFlag* flag = JVMFlag::find_flag(flag_name);
1205 JVMFlag::Error result = (*TAtPut)(flag, value, JVMFlag::INTERNAL);
1206 env->ReleaseStringUTFChars(name, flag_name);
1207 return (result == JVMFlag::SUCCESS);
1208 }
1209
1210 template <typename T>
1211 static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {
1212 ResourceMark rm(thread);
1213 jclass clazz = env->FindClass(name->as_C_string());
1214 CHECK_JNI_EXCEPTION_(env, NULL);
1215 jmethodID methodID = env->GetStaticMethodID(clazz,
1216 vmSymbols::valueOf_name()->as_C_string(),
1217 sig->as_C_string());
1218 CHECK_JNI_EXCEPTION_(env, NULL);
1219 jobject result = env->CallStaticObjectMethod(clazz, methodID, value);
1220 CHECK_JNI_EXCEPTION_(env, NULL);
1221 return result;
1222 }
1223
1224 static jobject booleanBox(JavaThread* thread, JNIEnv* env, jboolean value) {
1225 return box(thread, env, vmSymbols::java_lang_Boolean(), vmSymbols::Boolean_valueOf_signature(), value);
1226 }
1227 static jobject integerBox(JavaThread* thread, JNIEnv* env, jint value) {
1228 return box(thread, env, vmSymbols::java_lang_Integer(), vmSymbols::Integer_valueOf_signature(), value);
1229 }
1230 static jobject longBox(JavaThread* thread, JNIEnv* env, jlong value) {
1231 return box(thread, env, vmSymbols::java_lang_Long(), vmSymbols::Long_valueOf_signature(), value);
1232 }
1233 /* static jobject floatBox(JavaThread* thread, JNIEnv* env, jfloat value) {
1234 return box(thread, env, vmSymbols::java_lang_Float(), vmSymbols::Float_valueOf_signature(), value);
1235 }*/
1236 static jobject doubleBox(JavaThread* thread, JNIEnv* env, jdouble value) {
1237 return box(thread, env, vmSymbols::java_lang_Double(), vmSymbols::Double_valueOf_signature(), value);
1238 }
1239
1240 static const JVMFlag* getVMFlag(JavaThread* thread, JNIEnv* env, jstring name) {
1241 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1242 const char* flag_name = env->GetStringUTFChars(name, NULL);
1243 CHECK_JNI_EXCEPTION_(env, NULL);
1244 const JVMFlag* result = JVMFlag::find_declared_flag(flag_name);
1245 env->ReleaseStringUTFChars(name, flag_name);
1246 return result;
1247 }
1248
1249 WB_ENTRY(jboolean, WB_IsConstantVMFlag(JNIEnv* env, jobject o, jstring name))
1250 const JVMFlag* flag = getVMFlag(thread, env, name);
1251 return (flag != NULL) && flag->is_constant_in_binary();
1252 WB_END
1253
1254 WB_ENTRY(jboolean, WB_IsLockedVMFlag(JNIEnv* env, jobject o, jstring name))
1255 const JVMFlag* flag = getVMFlag(thread, env, name);
1256 return (flag != NULL) && !(flag->is_unlocked() || flag->is_unlocker());
1257 WB_END
1258
1259 WB_ENTRY(jobject, WB_GetBooleanVMFlag(JNIEnv* env, jobject o, jstring name))
1260 bool result;
1261 if (GetVMFlag <bool> (thread, env, name, &result, &JVMFlag::boolAt)) {
1262 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1263 return booleanBox(thread, env, result);
1264 }
1265 return NULL;
1266 WB_END
1267
1268 WB_ENTRY(jobject, WB_GetIntVMFlag(JNIEnv* env, jobject o, jstring name))
1269 int result;
1270 if (GetVMFlag <int> (thread, env, name, &result, &JVMFlag::intAt)) {
1271 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1272 return longBox(thread, env, result);
1273 }
1274 return NULL;
1275 WB_END
1276
1277 WB_ENTRY(jobject, WB_GetUintVMFlag(JNIEnv* env, jobject o, jstring name))
1278 uint result;
1279 if (GetVMFlag <uint> (thread, env, name, &result, &JVMFlag::uintAt)) {
1280 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1281 return longBox(thread, env, result);
1282 }
1283 return NULL;
1284 WB_END
1285
1286 WB_ENTRY(jobject, WB_GetIntxVMFlag(JNIEnv* env, jobject o, jstring name))
1287 intx result;
1288 if (GetVMFlag <intx> (thread, env, name, &result, &JVMFlag::intxAt)) {
1289 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1290 return longBox(thread, env, result);
1291 }
1292 return NULL;
1293 WB_END
1294
1295 WB_ENTRY(jobject, WB_GetUintxVMFlag(JNIEnv* env, jobject o, jstring name))
1296 uintx result;
1297 if (GetVMFlag <uintx> (thread, env, name, &result, &JVMFlag::uintxAt)) {
1298 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1299 return longBox(thread, env, result);
1300 }
1301 return NULL;
1302 WB_END
1303
1304 WB_ENTRY(jobject, WB_GetUint64VMFlag(JNIEnv* env, jobject o, jstring name))
1305 uint64_t result;
1306 if (GetVMFlag <uint64_t> (thread, env, name, &result, &JVMFlag::uint64_tAt)) {
1307 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1308 return longBox(thread, env, result);
1309 }
1310 return NULL;
1311 WB_END
1312
1313 WB_ENTRY(jobject, WB_GetSizeTVMFlag(JNIEnv* env, jobject o, jstring name))
1314 size_t result;
1315 if (GetVMFlag <size_t> (thread, env, name, &result, &JVMFlag::size_tAt)) {
1316 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1317 return longBox(thread, env, result);
1318 }
1319 return NULL;
1320 WB_END
1321
1322 WB_ENTRY(jobject, WB_GetDoubleVMFlag(JNIEnv* env, jobject o, jstring name))
1323 double result;
1324 if (GetVMFlag <double> (thread, env, name, &result, &JVMFlag::doubleAt)) {
1325 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1326 return doubleBox(thread, env, result);
1327 }
1328 return NULL;
1329 WB_END
1330
1331 WB_ENTRY(jstring, WB_GetStringVMFlag(JNIEnv* env, jobject o, jstring name))
1332 ccstr ccstrResult;
1333 if (GetVMFlag <ccstr> (thread, env, name, &ccstrResult, &JVMFlag::ccstrAt)) {
1334 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1335 jstring result = env->NewStringUTF(ccstrResult);
1336 CHECK_JNI_EXCEPTION_(env, NULL);
1337 return result;
1338 }
1339 return NULL;
1340 WB_END
1341
1342 WB_ENTRY(void, WB_SetBooleanVMFlag(JNIEnv* env, jobject o, jstring name, jboolean value))
1343 bool result = value == JNI_TRUE ? true : false;
1344 SetVMFlag <bool> (thread, env, name, &result, &JVMFlag::boolAtPut);
1345 WB_END
1346
1347 WB_ENTRY(void, WB_SetIntVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1348 int result = value;
1349 SetVMFlag <int> (thread, env, name, &result, &JVMFlag::intAtPut);
1350 WB_END
1351
1352 WB_ENTRY(void, WB_SetUintVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1353 uint result = value;
1354 SetVMFlag <uint> (thread, env, name, &result, &JVMFlag::uintAtPut);
1355 WB_END
1356
1357 WB_ENTRY(void, WB_SetIntxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1358 intx result = value;
1359 SetVMFlag <intx> (thread, env, name, &result, &JVMFlag::intxAtPut);
1360 WB_END
1361
1362 WB_ENTRY(void, WB_SetUintxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1363 uintx result = value;
1364 SetVMFlag <uintx> (thread, env, name, &result, &JVMFlag::uintxAtPut);
1365 WB_END
1366
1367 WB_ENTRY(void, WB_SetUint64VMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1368 uint64_t result = value;
1369 SetVMFlag <uint64_t> (thread, env, name, &result, &JVMFlag::uint64_tAtPut);
1370 WB_END
1371
1372 WB_ENTRY(void, WB_SetSizeTVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1373 size_t result = value;
1374 SetVMFlag <size_t> (thread, env, name, &result, &JVMFlag::size_tAtPut);
1375 WB_END
1376
1377 WB_ENTRY(void, WB_SetDoubleVMFlag(JNIEnv* env, jobject o, jstring name, jdouble value))
1378 double result = value;
1379 SetVMFlag <double> (thread, env, name, &result, &JVMFlag::doubleAtPut);
1380 WB_END
1381
1382 WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value))
1383 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1384 const char* ccstrValue;
1385 if (value == NULL) {
1386 ccstrValue = NULL;
1387 }
1388 else {
1389 ccstrValue = env->GetStringUTFChars(value, NULL);
1390 CHECK_JNI_EXCEPTION(env);
1391 }
1392 ccstr ccstrResult = ccstrValue;
1393 bool needFree;
1394 {
1395 ThreadInVMfromNative ttvfn(thread); // back to VM
1396 needFree = SetVMFlag <ccstr> (thread, env, name, &ccstrResult, &JVMFlag::ccstrAtPut);
1397 }
1398 if (value != NULL) {
1399 env->ReleaseStringUTFChars(value, ccstrValue);
1400 }
1401 if (needFree) {
1402 FREE_C_HEAP_ARRAY(char, ccstrResult);
1403 }
1404 WB_END
1405
1406 WB_ENTRY(void, WB_LockCompilation(JNIEnv* env, jobject o, jlong timeout))
1407 WhiteBox::compilation_locked = true;
1408 WB_END
1409
1410 WB_ENTRY(void, WB_UnlockCompilation(JNIEnv* env, jobject o))
1411 MonitorLocker mo(Compilation_lock, Mutex::_no_safepoint_check_flag);
1412 WhiteBox::compilation_locked = false;
1413 mo.notify_all();
1414 WB_END
1415
1416 WB_ENTRY(void, WB_ForceNMethodSweep(JNIEnv* env, jobject o))
1417 // Force a code cache sweep and block until it finished
1418 NMethodSweeper::force_sweep();
1419 WB_END
1420
1421 WB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString))
1422 ResourceMark rm(THREAD);
1423 int len;
1424 jchar* name = java_lang_String::as_unicode_string(JNIHandles::resolve(javaString), len, CHECK_false);
1425 return (StringTable::lookup(name, len) != NULL);
1426 WB_END
1427
1428 WB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o))
1429 if (AsyncDeflateIdleMonitors) {
1430 // AsyncDeflateIdleMonitors needs to know when System.gc() or
1431 // the equivalent is called so any special clean up can be done
1432 // at a safepoint, e.g., TestHumongousClassLoader.java.
1433 ObjectSynchronizer::set_is_special_deflation_requested(true);
1434 }
1435 Universe::heap()->soft_ref_policy()->set_should_clear_all_soft_refs(true);
1436 Universe::heap()->collect(GCCause::_wb_full_gc);
1437 #if INCLUDE_G1GC
1438 if (UseG1GC) {
1439 // Needs to be cleared explicitly for G1
1440 Universe::heap()->soft_ref_policy()->set_should_clear_all_soft_refs(false);
1441 }
1442 #endif // INCLUDE_G1GC
1443 WB_END
1444
1445 WB_ENTRY(void, WB_YoungGC(JNIEnv* env, jobject o))
1446 Universe::heap()->collect(GCCause::_wb_young_gc);
1447 WB_END
1448
1449 WB_ENTRY(void, WB_ReadReservedMemory(JNIEnv* env, jobject o))
1450 // static+volatile in order to force the read to happen
1451 // (not be eliminated by the compiler)
1452 static char c;
1453 static volatile char* p;
1454
1455 p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
1456 if (p == NULL) {
1457 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
1458 }
1459
1460 c = *p;
1461 WB_END
1462
1463 WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
1464 const char* features = VM_Version::features_string();
1465 ThreadToNativeFromVM ttn(thread);
1466 jstring features_string = env->NewStringUTF(features);
1467
1468 CHECK_JNI_EXCEPTION_(env, NULL);
1469
1470 return features_string;
1471 WB_END
1472
1473 int WhiteBox::get_blob_type(const CodeBlob* code) {
1474 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
1475 if (code->is_aot()) {
1476 return -1;
1477 }
1478 return CodeCache::get_code_heap(code)->code_blob_type();
1479 }
1480
1481 CodeHeap* WhiteBox::get_code_heap(int blob_type) {
1482 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
1483 return CodeCache::get_code_heap(blob_type);
1484 }
1485
1486 struct CodeBlobStub {
1487 CodeBlobStub(const CodeBlob* blob) :
1488 name(os::strdup(blob->name())),
1489 size(blob->size()),
1490 blob_type(WhiteBox::get_blob_type(blob)),
1491 address((jlong) blob) { }
1492 ~CodeBlobStub() { os::free((void*) name); }
1493 const char* const name;
1494 const jint size;
1495 const jint blob_type;
1496 const jlong address;
1497 };
1498
1499 static jobjectArray codeBlob2objectArray(JavaThread* thread, JNIEnv* env, CodeBlobStub* cb) {
1500 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
1501 CHECK_JNI_EXCEPTION_(env, NULL);
1502 jobjectArray result = env->NewObjectArray(4, clazz, NULL);
1503
1504 jstring name = env->NewStringUTF(cb->name);
1505 CHECK_JNI_EXCEPTION_(env, NULL);
1506 env->SetObjectArrayElement(result, 0, name);
1507
1508 jobject obj = integerBox(thread, env, cb->size);
1509 CHECK_JNI_EXCEPTION_(env, NULL);
1510 env->SetObjectArrayElement(result, 1, obj);
1511
1512 obj = integerBox(thread, env, cb->blob_type);
1513 CHECK_JNI_EXCEPTION_(env, NULL);
1514 env->SetObjectArrayElement(result, 2, obj);
1515
1516 obj = longBox(thread, env, cb->address);
1517 CHECK_JNI_EXCEPTION_(env, NULL);
1518 env->SetObjectArrayElement(result, 3, obj);
1519
1520 return result;
1521 }
1522
1523 WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
1524 ResourceMark rm(THREAD);
1525 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1526 CHECK_JNI_EXCEPTION_(env, NULL);
1527 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
1528 CompiledMethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
1529 jobjectArray result = NULL;
1530 if (code == NULL) {
1531 return result;
1532 }
1533 int comp_level = code->comp_level();
1534 int insts_size = comp_level == CompLevel_aot ? code->code_end() - code->code_begin() : code->insts_size();
1535
1536 ThreadToNativeFromVM ttn(thread);
1537 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
1538 CHECK_JNI_EXCEPTION_(env, NULL);
1539 result = env->NewObjectArray(5, clazz, NULL);
1540 if (result == NULL) {
1541 return result;
1542 }
1543
1544 CodeBlobStub stub(code);
1545 jobjectArray codeBlob = codeBlob2objectArray(thread, env, &stub);
1546 CHECK_JNI_EXCEPTION_(env, NULL);
1547 env->SetObjectArrayElement(result, 0, codeBlob);
1548
1549 jobject level = integerBox(thread, env, comp_level);
1550 CHECK_JNI_EXCEPTION_(env, NULL);
1551 env->SetObjectArrayElement(result, 1, level);
1552
1553 jbyteArray insts = env->NewByteArray(insts_size);
1554 CHECK_JNI_EXCEPTION_(env, NULL);
1555 env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
1556 env->SetObjectArrayElement(result, 2, insts);
1557
1558 jobject id = integerBox(thread, env, code->compile_id());
1559 CHECK_JNI_EXCEPTION_(env, NULL);
1560 env->SetObjectArrayElement(result, 3, id);
1561
1562 jobject entry_point = longBox(thread, env, (jlong) code->entry_point());
1563 CHECK_JNI_EXCEPTION_(env, NULL);
1564 env->SetObjectArrayElement(result, 4, entry_point);
1565
1566 return result;
1567 WB_END
1568
1569 CodeBlob* WhiteBox::allocate_code_blob(int size, int blob_type) {
1570 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
1571 BufferBlob* blob;
1572 int full_size = CodeBlob::align_code_offset(sizeof(BufferBlob));
1573 if (full_size < size) {
1574 full_size += align_up(size - full_size, oopSize);
1575 }
1576 {
1577 MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
1578 blob = (BufferBlob*) CodeCache::allocate(full_size, blob_type);
1579 if (blob != NULL) {
1580 ::new (blob) BufferBlob("WB::DummyBlob", full_size);
1581 }
1582 }
1583 // Track memory usage statistic after releasing CodeCache_lock
1584 MemoryService::track_code_cache_memory_usage();
1585 return blob;
1586 }
1587
1588 WB_ENTRY(jlong, WB_AllocateCodeBlob(JNIEnv* env, jobject o, jint size, jint blob_type))
1589 if (size < 0) {
1590 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1591 err_msg("WB_AllocateCodeBlob: size is negative: " INT32_FORMAT, size));
1592 }
1593 return (jlong) WhiteBox::allocate_code_blob(size, blob_type);
1594 WB_END
1595
1596 WB_ENTRY(void, WB_FreeCodeBlob(JNIEnv* env, jobject o, jlong addr))
1597 if (addr == 0) {
1598 return;
1599 }
1600 BufferBlob::free((BufferBlob*) addr);
1601 WB_END
1602
1603 WB_ENTRY(jobjectArray, WB_GetCodeHeapEntries(JNIEnv* env, jobject o, jint blob_type))
1604 ResourceMark rm;
1605 GrowableArray<CodeBlobStub*> blobs;
1606 {
1607 MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
1608 CodeHeap* heap = WhiteBox::get_code_heap(blob_type);
1609 if (heap == NULL) {
1610 return NULL;
1611 }
1612 for (CodeBlob* cb = (CodeBlob*) heap->first();
1613 cb != NULL; cb = (CodeBlob*) heap->next(cb)) {
1614 CodeBlobStub* stub = NEW_RESOURCE_OBJ(CodeBlobStub);
1615 new (stub) CodeBlobStub(cb);
1616 blobs.append(stub);
1617 }
1618 }
1619 ThreadToNativeFromVM ttn(thread);
1620 jobjectArray result = NULL;
1621 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
1622 CHECK_JNI_EXCEPTION_(env, NULL);
1623 result = env->NewObjectArray(blobs.length(), clazz, NULL);
1624 CHECK_JNI_EXCEPTION_(env, NULL);
1625 if (result == NULL) {
1626 return result;
1627 }
1628 int i = 0;
1629 for (GrowableArrayIterator<CodeBlobStub*> it = blobs.begin();
1630 it != blobs.end(); ++it) {
1631 jobjectArray obj = codeBlob2objectArray(thread, env, *it);
1632 CHECK_JNI_EXCEPTION_(env, NULL);
1633 env->SetObjectArrayElement(result, i, obj);
1634 CHECK_JNI_EXCEPTION_(env, NULL);
1635 ++i;
1636 }
1637 return result;
1638 WB_END
1639
1640 WB_ENTRY(jint, WB_GetCompilationActivityMode(JNIEnv* env, jobject o))
1641 return CompileBroker::get_compilation_activity_mode();
1642 WB_END
1643
1644 WB_ENTRY(jobjectArray, WB_GetCodeBlob(JNIEnv* env, jobject o, jlong addr))
1645 if (addr == 0) {
1646 THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(),
1647 "WB_GetCodeBlob: addr is null");
1648 }
1649 ThreadToNativeFromVM ttn(thread);
1650 CodeBlobStub stub((CodeBlob*) addr);
1651 return codeBlob2objectArray(thread, env, &stub);
1652 WB_END
1653
1654 WB_ENTRY(jlong, WB_GetMethodData(JNIEnv* env, jobject wv, jobject method))
1655 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1656 CHECK_JNI_EXCEPTION_(env, 0);
1657 methodHandle mh(thread, Method::checked_resolve_jmethod_id(jmid));
1658 return (jlong) mh->method_data();
1659 WB_END
1660
1661 WB_ENTRY(jlong, WB_GetThreadStackSize(JNIEnv* env, jobject o))
1662 return (jlong) Thread::current()->stack_size();
1663 WB_END
1664
1665 WB_ENTRY(jlong, WB_GetThreadRemainingStackSize(JNIEnv* env, jobject o))
1666 JavaThread* t = JavaThread::current();
1667 return (jlong) t->stack_available(os::current_stack_pointer()) - (jlong)JavaThread::stack_shadow_zone_size();
1668 WB_END
1669
1670
1671 int WhiteBox::array_bytes_to_length(size_t bytes) {
1672 return Array<u1>::bytes_to_length(bytes);
1673 }
1674
1675 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
1676 if (size < 0) {
1677 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1678 err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
1679 }
1680
1681 oop class_loader_oop = JNIHandles::resolve(class_loader);
1682 ClassLoaderData* cld = class_loader_oop != NULL
1683 ? java_lang_ClassLoader::loader_data_acquire(class_loader_oop)
1684 : ClassLoaderData::the_null_class_loader_data();
1685
1686 void* metadata = MetadataFactory::new_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread);
1687
1688 return (jlong)(uintptr_t)metadata;
1689 WB_END
1690
1691 WB_ENTRY(void, WB_FreeMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong addr, jlong size))
1692 oop class_loader_oop = JNIHandles::resolve(class_loader);
1693 ClassLoaderData* cld = class_loader_oop != NULL
1694 ? java_lang_ClassLoader::loader_data_acquire(class_loader_oop)
1695 : ClassLoaderData::the_null_class_loader_data();
1696
1697 MetadataFactory::free_array(cld, (Array<u1>*)(uintptr_t)addr);
1698 WB_END
1699
1700 WB_ENTRY(void, WB_DefineModule(JNIEnv* env, jobject o, jobject module, jboolean is_open,
1701 jstring version, jstring location, jobjectArray packages))
1702 ResourceMark rm(THREAD);
1703
1704 objArrayOop packages_oop = objArrayOop(JNIHandles::resolve(packages));
1705 objArrayHandle packages_h(THREAD, packages_oop);
1706 int num_packages = (packages_h == NULL ? 0 : packages_h->length());
1707
1708 char** pkgs = NULL;
1709 if (num_packages > 0) {
1710 pkgs = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char*, num_packages);
1711 for (int x = 0; x < num_packages; x++) {
1712 oop pkg_str = packages_h->obj_at(x);
1713 if (pkg_str == NULL || !pkg_str->is_a(SystemDictionary::String_klass())) {
1714 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
1715 err_msg("Bad package name"));
1716 }
1717 pkgs[x] = java_lang_String::as_utf8_string(pkg_str);
1718 }
1719 }
1720 Modules::define_module(module, is_open, version, location, (const char* const*)pkgs, num_packages, CHECK);
1721 WB_END
1722
1723 WB_ENTRY(void, WB_AddModuleExports(JNIEnv* env, jobject o, jobject from_module, jstring package, jobject to_module))
1724 ResourceMark rm(THREAD);
1725 char* package_name = NULL;
1726 if (package != NULL) {
1727 package_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(package));
1728 }
1729 Modules::add_module_exports_qualified(from_module, package_name, to_module, CHECK);
1730 WB_END
1731
1732 WB_ENTRY(void, WB_AddModuleExportsToAllUnnamed(JNIEnv* env, jobject o, jclass module, jstring package))
1733 ResourceMark rm(THREAD);
1734 char* package_name = NULL;
1735 if (package != NULL) {
1736 package_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(package));
1737 }
1738 Modules::add_module_exports_to_all_unnamed(module, package_name, CHECK);
1739 WB_END
1740
1741 WB_ENTRY(void, WB_AddModuleExportsToAll(JNIEnv* env, jobject o, jclass module, jstring package))
1742 ResourceMark rm(THREAD);
1743 char* package_name = NULL;
1744 if (package != NULL) {
1745 package_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(package));
1746 }
1747 Modules::add_module_exports(module, package_name, NULL, CHECK);
1748 WB_END
1749
1750 WB_ENTRY(void, WB_AddReadsModule(JNIEnv* env, jobject o, jobject from_module, jobject source_module))
1751 Modules::add_reads_module(from_module, source_module, CHECK);
1752 WB_END
1753
1754 WB_ENTRY(jlong, WB_IncMetaspaceCapacityUntilGC(JNIEnv* env, jobject wb, jlong inc))
1755 if (inc < 0) {
1756 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1757 err_msg("WB_IncMetaspaceCapacityUntilGC: inc is negative: " JLONG_FORMAT, inc));
1758 }
1759
1760 jlong max_size_t = (jlong) ((size_t) -1);
1761 if (inc > max_size_t) {
1762 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1763 err_msg("WB_IncMetaspaceCapacityUntilGC: inc does not fit in size_t: " JLONG_FORMAT, inc));
1764 }
1765
1766 size_t new_cap_until_GC = 0;
1767 size_t aligned_inc = align_down((size_t) inc, Metaspace::commit_alignment());
1768 bool success = MetaspaceGC::inc_capacity_until_GC(aligned_inc, &new_cap_until_GC);
1769 if (!success) {
1770 THROW_MSG_0(vmSymbols::java_lang_IllegalStateException(),
1771 "WB_IncMetaspaceCapacityUntilGC: could not increase capacity until GC "
1772 "due to contention with another thread");
1773 }
1774 return (jlong) new_cap_until_GC;
1775 WB_END
1776
1777 WB_ENTRY(jlong, WB_MetaspaceCapacityUntilGC(JNIEnv* env, jobject wb))
1778 return (jlong) MetaspaceGC::capacity_until_GC();
1779 WB_END
1780
1781 WB_ENTRY(jlong, WB_MetaspaceReserveAlignment(JNIEnv* env, jobject wb))
1782 return (jlong)Metaspace::reserve_alignment();
1783 WB_END
1784
1785 WB_ENTRY(void, WB_AssertMatchingSafepointCalls(JNIEnv* env, jobject o, jboolean mutexSafepointValue, jboolean attemptedNoSafepointValue))
1786 Mutex::SafepointCheckRequired sfpt_check_required = mutexSafepointValue ?
1787 Mutex::_safepoint_check_always :
1788 Mutex::_safepoint_check_never;
1789 Mutex::SafepointCheckFlag sfpt_check_attempted = attemptedNoSafepointValue ?
1790 Mutex::_no_safepoint_check_flag :
1791 Mutex::_safepoint_check_flag;
1792 MutexLocker ml(new Mutex(Mutex::leaf, "SFPT_Test_lock", true, sfpt_check_required),
1793 sfpt_check_attempted);
1794 WB_END
1795
1796 WB_ENTRY(void, WB_AssertSpecialLock(JNIEnv* env, jobject o, jboolean allowVMBlock, jboolean safepointCheck))
1797 // Create a special lock violating condition in value
1798 Mutex::SafepointCheckRequired sfpt_check_required = safepointCheck ?
1799 Mutex::_safepoint_check_always :
1800 Mutex::_safepoint_check_never;
1801 Mutex::SafepointCheckFlag safepoint_check = safepointCheck ?
1802 Monitor::_safepoint_check_flag :
1803 Monitor::_no_safepoint_check_flag;
1804
1805 MutexLocker ml(new Mutex(Mutex::special, "SpecialTest_lock", allowVMBlock, sfpt_check_required), safepoint_check);
1806 // If the lock above succeeds, try to safepoint to test the NSV implied with this special lock.
1807 ThreadBlockInVM tbivm(JavaThread::current());
1808 WB_END
1809
1810 WB_ENTRY(jboolean, WB_IsMonitorInflated(JNIEnv* env, jobject wb, jobject obj))
1811 oop obj_oop = JNIHandles::resolve(obj);
1812 return (jboolean) obj_oop->mark().has_monitor();
1813 WB_END
1814
1815 WB_ENTRY(void, WB_ForceSafepoint(JNIEnv* env, jobject wb))
1816 VM_ForceSafepoint force_safepoint_op;
1817 VMThread::execute(&force_safepoint_op);
1818 WB_END
1819
1820 WB_ENTRY(jlong, WB_GetConstantPool(JNIEnv* env, jobject wb, jclass klass))
1821 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1822 return (jlong) ik->constants();
1823 WB_END
1824
1825 WB_ENTRY(jint, WB_GetConstantPoolCacheIndexTag(JNIEnv* env, jobject wb))
1826 return ConstantPool::CPCACHE_INDEX_TAG;
1827 WB_END
1828
1829 WB_ENTRY(jint, WB_GetConstantPoolCacheLength(JNIEnv* env, jobject wb, jclass klass))
1830 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1831 ConstantPool* cp = ik->constants();
1832 if (cp->cache() == NULL) {
1833 return -1;
1834 }
1835 return cp->cache()->length();
1836 WB_END
1837
1838 WB_ENTRY(jint, WB_ConstantPoolRemapInstructionOperandFromCache(JNIEnv* env, jobject wb, jclass klass, jint index))
1839 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1840 ConstantPool* cp = ik->constants();
1841 if (cp->cache() == NULL) {
1842 THROW_MSG_0(vmSymbols::java_lang_IllegalStateException(), "Constant pool does not have a cache");
1843 }
1844 jint cpci = index;
1845 jint cpciTag = ConstantPool::CPCACHE_INDEX_TAG;
1846 if (cpciTag > cpci || cpci >= cp->cache()->length() + cpciTag) {
1847 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Constant pool cache index is out of range");
1848 }
1849 jint cpi = cp->remap_instruction_operand_from_cache(cpci);
1850 return cpi;
1851 WB_END
1852
1853 WB_ENTRY(jint, WB_ConstantPoolEncodeIndyIndex(JNIEnv* env, jobject wb, jint index))
1854 return ConstantPool::encode_invokedynamic_index(index);
1855 WB_END
1856
1857 WB_ENTRY(void, WB_ClearInlineCaches(JNIEnv* env, jobject wb, jboolean preserve_static_stubs))
1858 VM_ClearICs clear_ics(preserve_static_stubs == JNI_TRUE);
1859 VMThread::execute(&clear_ics);
1860 WB_END
1861
1862 template <typename T>
1863 static bool GetMethodOption(JavaThread* thread, JNIEnv* env, jobject method, jstring name, T* value) {
1864 assert(value != NULL, "sanity");
1865 if (method == NULL || name == NULL) {
1866 return false;
1867 }
1868 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1869 CHECK_JNI_EXCEPTION_(env, false);
1870 methodHandle mh(thread, Method::checked_resolve_jmethod_id(jmid));
1871 // can't be in VM when we call JNI
1872 ThreadToNativeFromVM ttnfv(thread);
1873 const char* flag_name = env->GetStringUTFChars(name, NULL);
1874 CHECK_JNI_EXCEPTION_(env, false);
1875 bool result = CompilerOracle::has_option_value(mh, flag_name, *value);
1876 env->ReleaseStringUTFChars(name, flag_name);
1877 return result;
1878 }
1879
1880 WB_ENTRY(jobject, WB_GetMethodBooleaneOption(JNIEnv* env, jobject wb, jobject method, jstring name))
1881 bool result;
1882 if (GetMethodOption<bool> (thread, env, method, name, &result)) {
1883 // can't be in VM when we call JNI
1884 ThreadToNativeFromVM ttnfv(thread);
1885 return booleanBox(thread, env, result);
1886 }
1887 return NULL;
1888 WB_END
1889
1890 WB_ENTRY(jobject, WB_GetMethodIntxOption(JNIEnv* env, jobject wb, jobject method, jstring name))
1891 intx result;
1892 if (GetMethodOption <intx> (thread, env, method, name, &result)) {
1893 // can't be in VM when we call JNI
1894 ThreadToNativeFromVM ttnfv(thread);
1895 return longBox(thread, env, result);
1896 }
1897 return NULL;
1898 WB_END
1899
1900 WB_ENTRY(jobject, WB_GetMethodUintxOption(JNIEnv* env, jobject wb, jobject method, jstring name))
1901 uintx result;
1902 if (GetMethodOption <uintx> (thread, env, method, name, &result)) {
1903 // can't be in VM when we call JNI
1904 ThreadToNativeFromVM ttnfv(thread);
1905 return longBox(thread, env, result);
1906 }
1907 return NULL;
1908 WB_END
1909
1910 WB_ENTRY(jobject, WB_GetMethodDoubleOption(JNIEnv* env, jobject wb, jobject method, jstring name))
1911 double result;
1912 if (GetMethodOption <double> (thread, env, method, name, &result)) {
1913 // can't be in VM when we call JNI
1914 ThreadToNativeFromVM ttnfv(thread);
1915 return doubleBox(thread, env, result);
1916 }
1917 return NULL;
1918 WB_END
1919
1920 WB_ENTRY(jobject, WB_GetMethodStringOption(JNIEnv* env, jobject wb, jobject method, jstring name))
1921 ccstr ccstrResult;
1922 if (GetMethodOption <ccstr> (thread, env, method, name, &ccstrResult)) {
1923 // can't be in VM when we call JNI
1924 ThreadToNativeFromVM ttnfv(thread);
1925 jstring result = env->NewStringUTF(ccstrResult);
1926 CHECK_JNI_EXCEPTION_(env, NULL);
1927 return result;
1928 }
1929 return NULL;
1930 WB_END
1931
1932 WB_ENTRY(jobject, WB_GetDefaultArchivePath(JNIEnv* env, jobject wb))
1933 const char* p = Arguments::get_default_shared_archive_path();
1934 ThreadToNativeFromVM ttn(thread);
1935 jstring path_string = env->NewStringUTF(p);
1936
1937 CHECK_JNI_EXCEPTION_(env, NULL);
1938
1939 return path_string;
1940 WB_END
1941
1942 WB_ENTRY(jboolean, WB_IsSharingEnabled(JNIEnv* env, jobject wb))
1943 return UseSharedSpaces;
1944 WB_END
1945
1946 WB_ENTRY(jboolean, WB_CDSMemoryMappingFailed(JNIEnv* env, jobject wb))
1947 return FileMapInfo::memory_mapping_failed();
1948 WB_END
1949
1950 WB_ENTRY(jboolean, WB_IsShared(JNIEnv* env, jobject wb, jobject obj))
1951 oop obj_oop = JNIHandles::resolve(obj);
1952 return HeapShared::is_archived_object(obj_oop);
1953 WB_END
1954
1955 WB_ENTRY(jboolean, WB_IsSharedClass(JNIEnv* env, jobject wb, jclass clazz))
1956 return (jboolean)MetaspaceShared::is_in_shared_metaspace(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
1957 WB_END
1958
1959 WB_ENTRY(jboolean, WB_AreSharedStringsIgnored(JNIEnv* env))
1960 return !HeapShared::closed_archive_heap_region_mapped();
1961 WB_END
1962
1963 WB_ENTRY(jobject, WB_GetResolvedReferences(JNIEnv* env, jobject wb, jclass clazz))
1964 Klass *k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1965 if (k->is_instance_klass()) {
1966 InstanceKlass *ik = InstanceKlass::cast(k);
1967 ConstantPool *cp = ik->constants();
1968 objArrayOop refs = cp->resolved_references();
1969 return (jobject)JNIHandles::make_local(env, refs);
1970 } else {
1971 return NULL;
1972 }
1973 WB_END
1974
1975 WB_ENTRY(void, WB_LinkClass(JNIEnv* env, jobject wb, jclass clazz))
1976 Klass *k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1977 if (!k->is_instance_klass()) {
1978 return;
1979 }
1980 InstanceKlass *ik = InstanceKlass::cast(k);
1981 ik->link_class(THREAD); // may throw verification error
1982 WB_END
1983
1984 WB_ENTRY(jboolean, WB_AreOpenArchiveHeapObjectsMapped(JNIEnv* env))
1985 return HeapShared::open_archive_heap_region_mapped();
1986 WB_END
1987
1988 WB_ENTRY(jboolean, WB_IsCDSIncludedInVmBuild(JNIEnv* env))
1989 #if INCLUDE_CDS
1990 # ifdef _LP64
1991 if (!UseCompressedOops || !UseCompressedClassPointers) {
1992 // On 64-bit VMs, CDS is supported only with compressed oops/pointers
1993 return false;
1994 }
1995 # endif // _LP64
1996 return true;
1997 #else
1998 return false;
1999 #endif // INCLUDE_CDS
2000 WB_END
2001
2002 WB_ENTRY(jboolean, WB_IsJavaHeapArchiveSupported(JNIEnv* env))
2003 return HeapShared::is_heap_object_archiving_allowed();
2004 WB_END
2005
2006
2007 WB_ENTRY(jboolean, WB_IsJFRIncludedInVmBuild(JNIEnv* env))
2008 #if INCLUDE_JFR
2009 return true;
2010 #else
2011 return false;
2012 #endif // INCLUDE_JFR
2013 WB_END
2014
2015 #if INCLUDE_CDS
2016
2017 WB_ENTRY(jint, WB_GetOffsetForName(JNIEnv* env, jobject o, jstring name))
2018 ResourceMark rm;
2019 char* c_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name));
2020 int result = CDSOffsets::find_offset(c_name);
2021 return (jint)result;
2022 WB_END
2023
2024 #endif // INCLUDE_CDS
2025
2026 WB_ENTRY(jint, WB_HandshakeWalkStack(JNIEnv* env, jobject wb, jobject thread_handle, jboolean all_threads))
2027 class TraceSelfClosure : public HandshakeClosure {
2028 jint _num_threads_completed;
2029
2030 void do_thread(Thread* th) {
2031 assert(th->is_Java_thread(), "sanity");
2032 JavaThread* jt = (JavaThread*)th;
2033 ResourceMark rm;
2034
2035 jt->print_on(tty);
2036 jt->print_stack_on(tty);
2037 tty->cr();
2038 Atomic::inc(&_num_threads_completed);
2039 }
2040
2041 public:
2042 TraceSelfClosure() : HandshakeClosure("WB_TraceSelf"), _num_threads_completed(0) {}
2043
2044 jint num_threads_completed() const { return _num_threads_completed; }
2045 };
2046 TraceSelfClosure tsc;
2047
2048 if (all_threads) {
2049 Handshake::execute(&tsc);
2050 } else {
2051 oop thread_oop = JNIHandles::resolve(thread_handle);
2052 if (thread_oop != NULL) {
2053 JavaThread* target = java_lang_Thread::thread(thread_oop);
2054 Handshake::execute(&tsc, target);
2055 }
2056 }
2057 return tsc.num_threads_completed();
2058 WB_END
2059
2060 //Some convenience methods to deal with objects from java
2061 int WhiteBox::offset_for_field(const char* field_name, oop object,
2062 Symbol* signature_symbol) {
2063 assert(field_name != NULL && strlen(field_name) > 0, "Field name not valid");
2064 Thread* THREAD = Thread::current();
2065
2066 //Get the class of our object
2067 Klass* arg_klass = object->klass();
2068 //Turn it into an instance-klass
2069 InstanceKlass* ik = InstanceKlass::cast(arg_klass);
2070
2071 //Create symbols to look for in the class
2072 TempNewSymbol name_symbol = SymbolTable::new_symbol(field_name);
2073
2074 //To be filled in with an offset of the field we're looking for
2075 fieldDescriptor fd;
2076
2077 Klass* res = ik->find_field(name_symbol, signature_symbol, &fd);
2078 if (res == NULL) {
2079 tty->print_cr("Invalid layout of %s at %s", ik->external_name(),
2080 name_symbol->as_C_string());
2081 vm_exit_during_initialization("Invalid layout of preloaded class: use -Xlog:class+load=info to see the origin of the problem class");
2082 }
2083
2084 //fetch the field at the offset we've found
2085 int dest_offset = fd.offset();
2086
2087 return dest_offset;
2088 }
2089
2090
2091 const char* WhiteBox::lookup_jstring(const char* field_name, oop object) {
2092 int offset = offset_for_field(field_name, object,
2093 vmSymbols::string_signature());
2094 oop string = object->obj_field(offset);
2095 if (string == NULL) {
2096 return NULL;
2097 }
2098 const char* ret = java_lang_String::as_utf8_string(string);
2099 return ret;
2100 }
2101
2102 bool WhiteBox::lookup_bool(const char* field_name, oop object) {
2103 int offset =
2104 offset_for_field(field_name, object, vmSymbols::bool_signature());
2105 bool ret = (object->bool_field(offset) == JNI_TRUE);
2106 return ret;
2107 }
2108
2109 void WhiteBox::register_methods(JNIEnv* env, jclass wbclass, JavaThread* thread, JNINativeMethod* method_array, int method_count) {
2110 ResourceMark rm;
2111 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
2112
2113 // one by one registration natives for exception catching
2114 jclass no_such_method_error_klass = env->FindClass(vmSymbols::java_lang_NoSuchMethodError()->as_C_string());
2115 CHECK_JNI_EXCEPTION(env);
2116 for (int i = 0, n = method_count; i < n; ++i) {
2117 // Skip dummy entries
2118 if (method_array[i].fnPtr == NULL) continue;
2119 if (env->RegisterNatives(wbclass, &method_array[i], 1) != 0) {
2120 jthrowable throwable_obj = env->ExceptionOccurred();
2121 if (throwable_obj != NULL) {
2122 env->ExceptionClear();
2123 if (env->IsInstanceOf(throwable_obj, no_such_method_error_klass)) {
2124 // NoSuchMethodError is thrown when a method can't be found or a method is not native.
2125 // Ignoring the exception since it is not preventing use of other WhiteBox methods.
2126 tty->print_cr("Warning: 'NoSuchMethodError' on register of sun.hotspot.WhiteBox::%s%s",
2127 method_array[i].name, method_array[i].signature);
2128 }
2129 } else {
2130 // Registration failed unexpectedly.
2131 tty->print_cr("Warning: unexpected error on register of sun.hotspot.WhiteBox::%s%s. All methods will be unregistered",
2132 method_array[i].name, method_array[i].signature);
2133 env->UnregisterNatives(wbclass);
2134 break;
2135 }
2136 }
2137 }
2138 }
2139
2140 WB_ENTRY(jint, WB_AddCompilerDirective(JNIEnv* env, jobject o, jstring compDirect))
2141 // can't be in VM when we call JNI
2142 ThreadToNativeFromVM ttnfv(thread);
2143 const char* dir = env->GetStringUTFChars(compDirect, NULL);
2144 CHECK_JNI_EXCEPTION_(env, 0);
2145 int ret;
2146 {
2147 ThreadInVMfromNative ttvfn(thread); // back to VM
2148 ret = DirectivesParser::parse_string(dir, tty);
2149 }
2150 env->ReleaseStringUTFChars(compDirect, dir);
2151 // -1 for error parsing directive. Return 0 as number of directives added.
2152 if (ret == -1) {
2153 ret = 0;
2154 }
2155 return (jint) ret;
2156 WB_END
2157
2158 WB_ENTRY(void, WB_RemoveCompilerDirective(JNIEnv* env, jobject o, jint count))
2159 DirectivesStack::pop(count);
2160 WB_END
2161
2162 // Checks that the library libfile has the noexecstack bit set.
2163 WB_ENTRY(jboolean, WB_CheckLibSpecifiesNoexecstack(JNIEnv* env, jobject o, jstring libfile))
2164 jboolean ret = false;
2165 #ifdef LINUX
2166 // Can't be in VM when we call JNI.
2167 ThreadToNativeFromVM ttnfv(thread);
2168 const char* lf = env->GetStringUTFChars(libfile, NULL);
2169 CHECK_JNI_EXCEPTION_(env, 0);
2170 ret = (jboolean) ElfFile::specifies_noexecstack(lf);
2171 env->ReleaseStringUTFChars(libfile, lf);
2172 #endif
2173 return ret;
2174 WB_END
2175
2176 WB_ENTRY(jboolean, WB_IsContainerized(JNIEnv* env, jobject o))
2177 LINUX_ONLY(return OSContainer::is_containerized();)
2178 return false;
2179 WB_END
2180
2181 WB_ENTRY(void, WB_PrintOsInfo(JNIEnv* env, jobject o))
2182 os::print_os_info(tty);
2183 WB_END
2184
2185 // Elf decoder
2186 WB_ENTRY(void, WB_DisableElfSectionCache(JNIEnv* env))
2187 #if !defined(_WINDOWS) && !defined(__APPLE__) && !defined(_AIX)
2188 ElfFile::_do_not_cache_elf_section = true;
2189 #endif
2190 WB_END
2191
2192 WB_ENTRY(jlong, WB_ResolvedMethodItemsCount(JNIEnv* env, jobject o))
2193 return (jlong) ResolvedMethodTable::items_count();
2194 WB_END
2195
2196 WB_ENTRY(jint, WB_ProtectionDomainRemovedCount(JNIEnv* env, jobject o))
2197 return (jint) SystemDictionary::pd_cache_table()->removed_entries_count();
2198 WB_END
2199
2200 WB_ENTRY(jint, WB_AotLibrariesCount(JNIEnv* env, jobject o))
2201 jint result = 0;
2202 #if INCLUDE_AOT
2203 result = (jint) AOTLoader::heaps_count();
2204 #endif
2205 return result;
2206 WB_END
2207
2208 #define CC (char*)
2209
2210 static JNINativeMethod methods[] = {
2211 {CC"getObjectAddress0", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectAddress },
2212 {CC"getObjectSize0", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectSize },
2213 {CC"isObjectInOldGen0", CC"(Ljava/lang/Object;)Z", (void*)&WB_isObjectInOldGen },
2214 {CC"getHeapOopSize", CC"()I", (void*)&WB_GetHeapOopSize },
2215 {CC"getVMPageSize", CC"()I", (void*)&WB_GetVMPageSize },
2216 {CC"getVMAllocationGranularity", CC"()J", (void*)&WB_GetVMAllocationGranularity },
2217 {CC"getVMLargePageSize", CC"()J", (void*)&WB_GetVMLargePageSize},
2218 {CC"getHeapSpaceAlignment", CC"()J", (void*)&WB_GetHeapSpaceAlignment},
2219 {CC"getHeapAlignment", CC"()J", (void*)&WB_GetHeapAlignment},
2220 {CC"isClassAlive0", CC"(Ljava/lang/String;)Z", (void*)&WB_IsClassAlive },
2221 {CC"getSymbolRefcount", CC"(Ljava/lang/String;)I", (void*)&WB_GetSymbolRefcount },
2222 {CC"parseCommandLine0",
2223 CC"(Ljava/lang/String;C[Lsun/hotspot/parser/DiagnosticCommand;)[Ljava/lang/Object;",
2224 (void*) &WB_ParseCommandLine
2225 },
2226 {CC"addToBootstrapClassLoaderSearch0", CC"(Ljava/lang/String;)V",
2227 (void*)&WB_AddToBootstrapClassLoaderSearch},
2228 {CC"addToSystemClassLoaderSearch0", CC"(Ljava/lang/String;)V",
2229 (void*)&WB_AddToSystemClassLoaderSearch},
2230 {CC"getCompressedOopsMaxHeapSize", CC"()J",
2231 (void*)&WB_GetCompressedOopsMaxHeapSize},
2232 {CC"printHeapSizes", CC"()V", (void*)&WB_PrintHeapSizes },
2233 {CC"runMemoryUnitTests", CC"()V", (void*)&WB_RunMemoryUnitTests},
2234 {CC"readFromNoaccessArea",CC"()V", (void*)&WB_ReadFromNoaccessArea},
2235 {CC"stressVirtualSpaceResize",CC"(JJJ)I", (void*)&WB_StressVirtualSpaceResize},
2236 #if INCLUDE_CDS
2237 {CC"getOffsetForName0", CC"(Ljava/lang/String;)I", (void*)&WB_GetOffsetForName},
2238 #endif
2239 #if INCLUDE_G1GC
2240 {CC"g1InConcurrentMark", CC"()Z", (void*)&WB_G1InConcurrentMark},
2241 {CC"g1IsHumongous0", CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous },
2242 {CC"g1BelongsToHumongousRegion0", CC"(J)Z", (void*)&WB_G1BelongsToHumongousRegion},
2243 {CC"g1BelongsToFreeRegion0", CC"(J)Z", (void*)&WB_G1BelongsToFreeRegion},
2244 {CC"g1NumMaxRegions", CC"()J", (void*)&WB_G1NumMaxRegions },
2245 {CC"g1NumFreeRegions", CC"()J", (void*)&WB_G1NumFreeRegions },
2246 {CC"g1RegionSize", CC"()I", (void*)&WB_G1RegionSize },
2247 {CC"g1StartConcMarkCycle", CC"()Z", (void*)&WB_G1StartMarkCycle },
2248 {CC"g1AuxiliaryMemoryUsage", CC"()Ljava/lang/management/MemoryUsage;",
2249 (void*)&WB_G1AuxiliaryMemoryUsage },
2250 {CC"g1ActiveMemoryNodeCount", CC"()I", (void*)&WB_G1ActiveMemoryNodeCount },
2251 {CC"g1MemoryNodeIds", CC"()[I", (void*)&WB_G1MemoryNodeIds },
2252 {CC"g1GetMixedGCInfo", CC"(I)[J", (void*)&WB_G1GetMixedGCInfo },
2253 #endif // INCLUDE_G1GC
2254 #if INCLUDE_G1GC || INCLUDE_PARALLELGC
2255 {CC"dramReservedStart", CC"()J", (void*)&WB_DramReservedStart },
2256 {CC"dramReservedEnd", CC"()J", (void*)&WB_DramReservedEnd },
2257 {CC"nvdimmReservedStart", CC"()J", (void*)&WB_NvdimmReservedStart },
2258 {CC"nvdimmReservedEnd", CC"()J", (void*)&WB_NvdimmReservedEnd },
2259 #endif // INCLUDE_G1GC || INCLUDE_PARALLELGC
2260 #if INCLUDE_PARALLELGC
2261 {CC"psVirtualSpaceAlignment",CC"()J", (void*)&WB_PSVirtualSpaceAlignment},
2262 {CC"psHeapGenerationAlignment",CC"()J", (void*)&WB_PSHeapGenerationAlignment},
2263 #endif
2264 #if INCLUDE_NMT
2265 {CC"NMTMalloc", CC"(J)J", (void*)&WB_NMTMalloc },
2266 {CC"NMTMallocWithPseudoStack", CC"(JI)J", (void*)&WB_NMTMallocWithPseudoStack},
2267 {CC"NMTMallocWithPseudoStackAndType", CC"(JII)J", (void*)&WB_NMTMallocWithPseudoStackAndType},
2268 {CC"NMTFree", CC"(J)V", (void*)&WB_NMTFree },
2269 {CC"NMTReserveMemory", CC"(J)J", (void*)&WB_NMTReserveMemory },
2270 {CC"NMTAttemptReserveMemoryAt", CC"(JJ)J", (void*)&WB_NMTAttemptReserveMemoryAt },
2271 {CC"NMTCommitMemory", CC"(JJ)V", (void*)&WB_NMTCommitMemory },
2272 {CC"NMTUncommitMemory", CC"(JJ)V", (void*)&WB_NMTUncommitMemory },
2273 {CC"NMTReleaseMemory", CC"(JJ)V", (void*)&WB_NMTReleaseMemory },
2274 {CC"NMTChangeTrackingLevel", CC"()Z", (void*)&WB_NMTChangeTrackingLevel},
2275 {CC"NMTGetHashSize", CC"()I", (void*)&WB_NMTGetHashSize },
2276 {CC"NMTNewArena", CC"(J)J", (void*)&WB_NMTNewArena },
2277 {CC"NMTFreeArena", CC"(J)V", (void*)&WB_NMTFreeArena },
2278 {CC"NMTArenaMalloc", CC"(JJ)V", (void*)&WB_NMTArenaMalloc },
2279 #endif // INCLUDE_NMT
2280 {CC"deoptimizeFrames", CC"(Z)I", (void*)&WB_DeoptimizeFrames },
2281 {CC"deoptimizeAll", CC"()V", (void*)&WB_DeoptimizeAll },
2282 {CC"deoptimizeMethod0", CC"(Ljava/lang/reflect/Executable;Z)I",
2283 (void*)&WB_DeoptimizeMethod },
2284 {CC"isMethodCompiled0", CC"(Ljava/lang/reflect/Executable;Z)Z",
2285 (void*)&WB_IsMethodCompiled },
2286 {CC"isMethodCompilable0", CC"(Ljava/lang/reflect/Executable;IZ)Z",
2287 (void*)&WB_IsMethodCompilable},
2288 {CC"isMethodQueuedForCompilation0",
2289 CC"(Ljava/lang/reflect/Executable;)Z", (void*)&WB_IsMethodQueuedForCompilation},
2290 {CC"isIntrinsicAvailable0",
2291 CC"(Ljava/lang/reflect/Executable;Ljava/lang/reflect/Executable;I)Z",
2292 (void*)&WB_IsIntrinsicAvailable},
2293 {CC"makeMethodNotCompilable0",
2294 CC"(Ljava/lang/reflect/Executable;IZ)V", (void*)&WB_MakeMethodNotCompilable},
2295 {CC"testSetDontInlineMethod0",
2296 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetDontInlineMethod},
2297 {CC"getMethodCompilationLevel0",
2298 CC"(Ljava/lang/reflect/Executable;Z)I", (void*)&WB_GetMethodCompilationLevel},
2299 {CC"getMethodEntryBci0",
2300 CC"(Ljava/lang/reflect/Executable;)I", (void*)&WB_GetMethodEntryBci},
2301 {CC"getCompileQueueSize",
2302 CC"(I)I", (void*)&WB_GetCompileQueueSize},
2303 {CC"testSetForceInlineMethod0",
2304 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetForceInlineMethod},
2305 {CC"enqueueMethodForCompilation0",
2306 CC"(Ljava/lang/reflect/Executable;II)Z", (void*)&WB_EnqueueMethodForCompilation},
2307 {CC"enqueueInitializerForCompilation0",
2308 CC"(Ljava/lang/Class;I)Z", (void*)&WB_EnqueueInitializerForCompilation},
2309 {CC"markMethodProfiled",
2310 CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_MarkMethodProfiled},
2311 {CC"clearMethodState0",
2312 CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_ClearMethodState},
2313 {CC"lockCompilation", CC"()V", (void*)&WB_LockCompilation},
2314 {CC"unlockCompilation", CC"()V", (void*)&WB_UnlockCompilation},
2315 {CC"matchesMethod",
2316 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)I",
2317 (void*)&WB_MatchesMethod},
2318 {CC"matchesInline",
2319 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)I",
2320 (void*)&WB_MatchesInline},
2321 {CC"shouldPrintAssembly",
2322 CC"(Ljava/lang/reflect/Executable;I)Z",
2323 (void*)&WB_ShouldPrintAssembly},
2324
2325 {CC"isConstantVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsConstantVMFlag},
2326 {CC"isLockedVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsLockedVMFlag},
2327 {CC"setBooleanVMFlag", CC"(Ljava/lang/String;Z)V",(void*)&WB_SetBooleanVMFlag},
2328 {CC"setIntVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntVMFlag},
2329 {CC"setUintVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintVMFlag},
2330 {CC"setIntxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag},
2331 {CC"setUintxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag},
2332 {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
2333 {CC"setSizeTVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetSizeTVMFlag},
2334 {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag},
2335 {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V",
2336 (void*)&WB_SetStringVMFlag},
2337 {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
2338 (void*)&WB_GetBooleanVMFlag},
2339 {CC"getIntVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
2340 (void*)&WB_GetIntVMFlag},
2341 {CC"getUintVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
2342 (void*)&WB_GetUintVMFlag},
2343 {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
2344 (void*)&WB_GetIntxVMFlag},
2345 {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
2346 (void*)&WB_GetUintxVMFlag},
2347 {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
2348 (void*)&WB_GetUint64VMFlag},
2349 {CC"getSizeTVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
2350 (void*)&WB_GetSizeTVMFlag},
2351 {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;",
2352 (void*)&WB_GetDoubleVMFlag},
2353 {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;",
2354 (void*)&WB_GetStringVMFlag},
2355 {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
2356 {CC"fullGC", CC"()V", (void*)&WB_FullGC },
2357 {CC"youngGC", CC"()V", (void*)&WB_YoungGC },
2358 {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
2359 {CC"allocateMetaspace",
2360 CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
2361 {CC"freeMetaspace",
2362 CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
2363 {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
2364 {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
2365 {CC"metaspaceReserveAlignment", CC"()J", (void*)&WB_MetaspaceReserveAlignment },
2366 {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
2367 {CC"getNMethod0", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
2368 (void*)&WB_GetNMethod },
2369 {CC"forceNMethodSweep", CC"()V", (void*)&WB_ForceNMethodSweep },
2370 {CC"allocateCodeBlob", CC"(II)J", (void*)&WB_AllocateCodeBlob },
2371 {CC"freeCodeBlob", CC"(J)V", (void*)&WB_FreeCodeBlob },
2372 {CC"getCodeHeapEntries", CC"(I)[Ljava/lang/Object;",(void*)&WB_GetCodeHeapEntries },
2373 {CC"getCompilationActivityMode",
2374 CC"()I", (void*)&WB_GetCompilationActivityMode},
2375 {CC"getMethodData0", CC"(Ljava/lang/reflect/Executable;)J",
2376 (void*)&WB_GetMethodData },
2377 {CC"getCodeBlob", CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob },
2378 {CC"getThreadStackSize", CC"()J", (void*)&WB_GetThreadStackSize },
2379 {CC"getThreadRemainingStackSize", CC"()J", (void*)&WB_GetThreadRemainingStackSize },
2380 {CC"DefineModule", CC"(Ljava/lang/Object;ZLjava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
2381 (void*)&WB_DefineModule },
2382 {CC"AddModuleExports", CC"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V",
2383 (void*)&WB_AddModuleExports },
2384 {CC"AddReadsModule", CC"(Ljava/lang/Object;Ljava/lang/Object;)V",
2385 (void*)&WB_AddReadsModule },
2386 {CC"AddModuleExportsToAllUnnamed", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
2387 (void*)&WB_AddModuleExportsToAllUnnamed },
2388 {CC"AddModuleExportsToAll", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
2389 (void*)&WB_AddModuleExportsToAll },
2390 {CC"assertMatchingSafepointCalls", CC"(ZZ)V", (void*)&WB_AssertMatchingSafepointCalls },
2391 {CC"assertSpecialLock", CC"(ZZ)V", (void*)&WB_AssertSpecialLock },
2392 {CC"isMonitorInflated0", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated },
2393 {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint },
2394 {CC"getConstantPool0", CC"(Ljava/lang/Class;)J", (void*)&WB_GetConstantPool },
2395 {CC"getConstantPoolCacheIndexTag0", CC"()I", (void*)&WB_GetConstantPoolCacheIndexTag},
2396 {CC"getConstantPoolCacheLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_GetConstantPoolCacheLength},
2397 {CC"remapInstructionOperandFromCPCache0",
2398 CC"(Ljava/lang/Class;I)I", (void*)&WB_ConstantPoolRemapInstructionOperandFromCache},
2399 {CC"encodeConstantPoolIndyIndex0",
2400 CC"(I)I", (void*)&WB_ConstantPoolEncodeIndyIndex},
2401 {CC"getMethodBooleanOption",
2402 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Boolean;",
2403 (void*)&WB_GetMethodBooleaneOption},
2404 {CC"getMethodIntxOption",
2405 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
2406 (void*)&WB_GetMethodIntxOption},
2407 {CC"getMethodUintxOption",
2408 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
2409 (void*)&WB_GetMethodUintxOption},
2410 {CC"getMethodDoubleOption",
2411 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Double;",
2412 (void*)&WB_GetMethodDoubleOption},
2413 {CC"getMethodStringOption",
2414 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/String;",
2415 (void*)&WB_GetMethodStringOption},
2416 {CC"getDefaultArchivePath", CC"()Ljava/lang/String;",
2417 (void*)&WB_GetDefaultArchivePath},
2418 {CC"isSharingEnabled", CC"()Z", (void*)&WB_IsSharingEnabled},
2419 {CC"isShared", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsShared },
2420 {CC"isSharedClass", CC"(Ljava/lang/Class;)Z", (void*)&WB_IsSharedClass },
2421 {CC"areSharedStringsIgnored", CC"()Z", (void*)&WB_AreSharedStringsIgnored },
2422 {CC"getResolvedReferences", CC"(Ljava/lang/Class;)Ljava/lang/Object;", (void*)&WB_GetResolvedReferences},
2423 {CC"linkClass", CC"(Ljava/lang/Class;)V", (void*)&WB_LinkClass},
2424 {CC"areOpenArchiveHeapObjectsMapped", CC"()Z", (void*)&WB_AreOpenArchiveHeapObjectsMapped},
2425 {CC"isCDSIncludedInVmBuild", CC"()Z", (void*)&WB_IsCDSIncludedInVmBuild },
2426 {CC"isJFRIncludedInVmBuild", CC"()Z", (void*)&WB_IsJFRIncludedInVmBuild },
2427 {CC"isJavaHeapArchiveSupported", CC"()Z", (void*)&WB_IsJavaHeapArchiveSupported },
2428 {CC"cdsMemoryMappingFailed", CC"()Z", (void*)&WB_CDSMemoryMappingFailed },
2429
2430 {CC"clearInlineCaches0", CC"(Z)V", (void*)&WB_ClearInlineCaches },
2431 {CC"handshakeWalkStack", CC"(Ljava/lang/Thread;Z)I", (void*)&WB_HandshakeWalkStack },
2432 {CC"addCompilerDirective", CC"(Ljava/lang/String;)I",
2433 (void*)&WB_AddCompilerDirective },
2434 {CC"removeCompilerDirective", CC"(I)V", (void*)&WB_RemoveCompilerDirective },
2435 {CC"isGCSupported", CC"(I)Z", (void*)&WB_IsGCSupported},
2436 {CC"isGCSelected", CC"(I)Z", (void*)&WB_IsGCSelected},
2437 {CC"isGCSelectedErgonomically", CC"()Z", (void*)&WB_IsGCSelectedErgonomically},
2438 {CC"supportsConcurrentGCPhaseControl", CC"()Z", (void*)&WB_SupportsConcurrentGCPhaseControl},
2439 {CC"requestConcurrentGCPhase0", CC"(Ljava/lang/String;)Z",
2440 (void*)&WB_RequestConcurrentGCPhase},
2441 {CC"checkLibSpecifiesNoexecstack", CC"(Ljava/lang/String;)Z",
2442 (void*)&WB_CheckLibSpecifiesNoexecstack},
2443 {CC"isContainerized", CC"()Z", (void*)&WB_IsContainerized },
2444 {CC"printOsInfo", CC"()V", (void*)&WB_PrintOsInfo },
2445 {CC"disableElfSectionCache", CC"()V", (void*)&WB_DisableElfSectionCache },
2446 {CC"resolvedMethodItemsCount", CC"()J", (void*)&WB_ResolvedMethodItemsCount },
2447 {CC"protectionDomainRemovedCount", CC"()I", (void*)&WB_ProtectionDomainRemovedCount },
2448 {CC"aotLibrariesCount", CC"()I", (void*)&WB_AotLibrariesCount },
2449 };
2450
2451
2452 #undef CC
2453
2454 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
2455 {
2456 if (WhiteBoxAPI) {
2457 // Make sure that wbclass is loaded by the null classloader
2458 InstanceKlass* ik = InstanceKlass::cast(JNIHandles::resolve(wbclass)->klass());
2459 Handle loader(THREAD, ik->class_loader());
2460 if (loader.is_null()) {
2461 WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0]));
2462 WhiteBox::set_used();
2463 }
2464 }
2465 }
2466 JVM_END