1 /*
2 * Copyright (c) 2012, 2017, 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/classLoaderData.hpp"
30 #include "classfile/modules.hpp"
31 #include "classfile/stringTable.hpp"
32 #include "code/codeCache.hpp"
33 #include "compiler/methodMatcher.hpp"
34 #include "compiler/directivesParser.hpp"
35 #include "jvmtifiles/jvmtiEnv.hpp"
36 #include "memory/metadataFactory.hpp"
37 #include "memory/metaspaceShared.hpp"
38 #include "memory/iterator.hpp"
39 #include "memory/resourceArea.hpp"
40 #include "memory/universe.hpp"
41 #include "memory/oopFactory.hpp"
42 #include "oops/constantPool.hpp"
43 #include "oops/oop.inline.hpp"
44 #include "prims/wbtestmethods/parserTests.hpp"
45 #include "prims/whitebox.hpp"
46 #include "runtime/arguments.hpp"
47 #include "runtime/compilationPolicy.hpp"
48 #include "runtime/deoptimization.hpp"
49 #include "runtime/interfaceSupport.hpp"
50 #include "runtime/javaCalls.hpp"
51 #include "runtime/os.hpp"
52 #include "runtime/sweeper.hpp"
53 #include "runtime/thread.hpp"
54 #include "runtime/vm_version.hpp"
55 #include "utilities/array.hpp"
56 #include "utilities/debug.hpp"
57 #include "utilities/exceptions.hpp"
58 #include "utilities/macros.hpp"
59 #if INCLUDE_ALL_GCS
60 #include "gc/g1/concurrentMarkThread.hpp"
61 #include "gc/g1/g1CollectedHeap.inline.hpp"
62 #include "gc/g1/g1ConcurrentMark.hpp"
63 #include "gc/g1/heapRegionRemSet.hpp"
64 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
65 #include "gc/parallel/adjoiningGenerations.hpp"
66 #endif // INCLUDE_ALL_GCS
67 #if INCLUDE_NMT
68 #include "services/mallocSiteTable.hpp"
69 #include "services/memTracker.hpp"
70 #include "utilities/nativeCallStack.hpp"
71 #endif // INCLUDE_NMT
72
73
74 #define SIZE_T_MAX_VALUE ((size_t) -1)
75
76 bool WhiteBox::_used = false;
77 volatile bool WhiteBox::compilation_locked = false;
78
79 class VM_WhiteBoxOperation : public VM_Operation {
80 public:
81 VM_WhiteBoxOperation() { }
82 VMOp_Type type() const { return VMOp_WhiteBoxOperation; }
83 bool allow_nested_vm_operations() const { return true; }
84 };
85
86
87 WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj))
88 return (jlong)(void*)JNIHandles::resolve(obj);
89 WB_END
90
91 WB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o))
92 return heapOopSize;
93 WB_END
94
95 WB_ENTRY(jint, WB_GetVMPageSize(JNIEnv* env, jobject o))
96 return os::vm_page_size();
97 WB_END
98
99 WB_ENTRY(jlong, WB_GetVMAllocationGranularity(JNIEnv* env, jobject o))
100 return os::vm_allocation_granularity();
101 WB_END
102
103 WB_ENTRY(jlong, WB_GetVMLargePageSize(JNIEnv* env, jobject o))
104 return os::large_page_size();
105 WB_END
106
107 class WBIsKlassAliveClosure : public KlassClosure {
108 Symbol* _name;
109 bool _found;
110 public:
111 WBIsKlassAliveClosure(Symbol* name) : _name(name), _found(false) {}
112
113 void do_klass(Klass* k) {
114 if (_found) return;
115 Symbol* ksym = k->name();
116 if (ksym->fast_compare(_name) == 0) {
117 _found = true;
118 }
119 }
120
121 bool found() const {
122 return _found;
123 }
124 };
125
126 WB_ENTRY(jboolean, WB_IsClassAlive(JNIEnv* env, jobject target, jstring name))
127 oop h_name = JNIHandles::resolve(name);
128 if (h_name == NULL) return false;
129 Symbol* sym = java_lang_String::as_symbol(h_name, CHECK_false);
130 TempNewSymbol tsym(sym); // Make sure to decrement reference count on sym on return
131
132 WBIsKlassAliveClosure closure(sym);
133 ClassLoaderDataGraph::classes_do(&closure);
134
135 return closure.found();
136 WB_END
137
138 WB_ENTRY(void, WB_AddToBootstrapClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) {
139 #if INCLUDE_JVMTI
140 ResourceMark rm;
141 const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment));
142 JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION);
143 jvmtiError err = jvmti_env->AddToBootstrapClassLoaderSearch(seg);
144 assert(err == JVMTI_ERROR_NONE, "must not fail");
145 #endif
146 }
147 WB_END
148
149 WB_ENTRY(void, WB_AddToSystemClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) {
150 #if INCLUDE_JVMTI
151 ResourceMark rm;
152 const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment));
153 JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION);
154 jvmtiError err = jvmti_env->AddToSystemClassLoaderSearch(seg);
155 assert(err == JVMTI_ERROR_NONE, "must not fail");
156 #endif
157 }
158 WB_END
159
160
161 WB_ENTRY(jlong, WB_GetCompressedOopsMaxHeapSize(JNIEnv* env, jobject o)) {
162 return (jlong)Arguments::max_heap_for_compressed_oops();
163 }
164 WB_END
165
166 WB_ENTRY(void, WB_PrintHeapSizes(JNIEnv* env, jobject o)) {
167 CollectorPolicy * p = Universe::heap()->collector_policy();
168 tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap "
169 SIZE_FORMAT " Maximum heap " SIZE_FORMAT " Space alignment " SIZE_FORMAT " Heap alignment " SIZE_FORMAT,
170 p->min_heap_byte_size(), p->initial_heap_byte_size(), p->max_heap_byte_size(),
171 p->space_alignment(), p->heap_alignment());
172 }
173 WB_END
174
175 #ifndef PRODUCT
176 // Forward declaration
177 void TestReservedSpace_test();
178 void TestReserveMemorySpecial_test();
179 void TestVirtualSpace_test();
180 void TestMetaspaceAux_test();
181 #endif
182
183 WB_ENTRY(void, WB_RunMemoryUnitTests(JNIEnv* env, jobject o))
184 #ifndef PRODUCT
185 TestReservedSpace_test();
186 TestReserveMemorySpecial_test();
187 TestVirtualSpace_test();
188 TestMetaspaceAux_test();
189 #endif
190 WB_END
191
192 WB_ENTRY(void, WB_ReadFromNoaccessArea(JNIEnv* env, jobject o))
193 size_t granularity = os::vm_allocation_granularity();
194 ReservedHeapSpace rhs(100 * granularity, granularity, false);
195 VirtualSpace vs;
196 vs.initialize(rhs, 50 * granularity);
197
198 // Check if constraints are complied
199 if (!( UseCompressedOops && rhs.base() != NULL &&
200 Universe::narrow_oop_base() != NULL &&
201 Universe::narrow_oop_use_implicit_null_checks() )) {
202 tty->print_cr("WB_ReadFromNoaccessArea method is useless:\n "
203 "\tUseCompressedOops is %d\n"
204 "\trhs.base() is " PTR_FORMAT "\n"
205 "\tUniverse::narrow_oop_base() is " PTR_FORMAT "\n"
206 "\tUniverse::narrow_oop_use_implicit_null_checks() is %d",
207 UseCompressedOops,
208 p2i(rhs.base()),
209 p2i(Universe::narrow_oop_base()),
210 Universe::narrow_oop_use_implicit_null_checks());
211 return;
212 }
213 tty->print_cr("Reading from no access area... ");
214 tty->print_cr("*(vs.low_boundary() - rhs.noaccess_prefix() / 2 ) = %c",
215 *(vs.low_boundary() - rhs.noaccess_prefix() / 2 ));
216 WB_END
217
218 static jint wb_stress_virtual_space_resize(size_t reserved_space_size,
219 size_t magnitude, size_t iterations) {
220 size_t granularity = os::vm_allocation_granularity();
221 ReservedHeapSpace rhs(reserved_space_size * granularity, granularity, false);
222 VirtualSpace vs;
223 if (!vs.initialize(rhs, 0)) {
224 tty->print_cr("Failed to initialize VirtualSpace. Can't proceed.");
225 return 3;
226 }
227
228 long seed = os::random();
229 tty->print_cr("Random seed is %ld", seed);
230 os::init_random(seed);
231
232 for (size_t i = 0; i < iterations; i++) {
233
234 // Whether we will shrink or grow
235 bool shrink = os::random() % 2L == 0;
236
237 // Get random delta to resize virtual space
238 size_t delta = (size_t)os::random() % magnitude;
239
240 // If we are about to shrink virtual space below zero, then expand instead
241 if (shrink && vs.committed_size() < delta) {
242 shrink = false;
243 }
244
245 // Resizing by delta
246 if (shrink) {
247 vs.shrink_by(delta);
248 } else {
249 // If expanding fails expand_by will silently return false
250 vs.expand_by(delta, true);
251 }
252 }
253 return 0;
254 }
255
256 WB_ENTRY(jint, WB_StressVirtualSpaceResize(JNIEnv* env, jobject o,
257 jlong reserved_space_size, jlong magnitude, jlong iterations))
258 tty->print_cr("reservedSpaceSize=" JLONG_FORMAT ", magnitude=" JLONG_FORMAT ", "
259 "iterations=" JLONG_FORMAT "\n", reserved_space_size, magnitude,
260 iterations);
261 if (reserved_space_size < 0 || magnitude < 0 || iterations < 0) {
262 tty->print_cr("One of variables printed above is negative. Can't proceed.\n");
263 return 1;
264 }
265
266 // sizeof(size_t) depends on whether OS is 32bit or 64bit. sizeof(jlong) is
267 // always 8 byte. That's why we should avoid overflow in case of 32bit platform.
268 if (sizeof(size_t) < sizeof(jlong)) {
269 jlong size_t_max_value = (jlong) SIZE_T_MAX_VALUE;
270 if (reserved_space_size > size_t_max_value || magnitude > size_t_max_value
271 || iterations > size_t_max_value) {
272 tty->print_cr("One of variables printed above overflows size_t. Can't proceed.\n");
273 return 2;
274 }
275 }
276
277 return wb_stress_virtual_space_resize((size_t) reserved_space_size,
278 (size_t) magnitude, (size_t) iterations);
279 WB_END
280
281 static const jint serial_code = 1;
282 static const jint parallel_code = 2;
283 static const jint cms_code = 4;
284 static const jint g1_code = 8;
285
286 WB_ENTRY(jint, WB_CurrentGC(JNIEnv* env, jobject o, jobject obj))
287 if (UseSerialGC) {
288 return serial_code;
289 } else if (UseParallelGC || UseParallelOldGC) {
290 return parallel_code;
291 } if (UseConcMarkSweepGC) {
292 return cms_code;
293 } else if (UseG1GC) {
294 return g1_code;
295 }
296 ShouldNotReachHere();
297 return 0;
298 WB_END
299
300 WB_ENTRY(jint, WB_AllSupportedGC(JNIEnv* env, jobject o, jobject obj))
301 #if INCLUDE_ALL_GCS
302 return serial_code | parallel_code | cms_code | g1_code;
303 #else
304 return serial_code;
305 #endif // INCLUDE_ALL_GCS
306 WB_END
307
308 WB_ENTRY(jboolean, WB_GCSelectedByErgo(JNIEnv* env, jobject o, jobject obj))
309 if (UseSerialGC) {
310 return FLAG_IS_ERGO(UseSerialGC);
311 } else if (UseParallelGC) {
312 return FLAG_IS_ERGO(UseParallelGC);
313 } else if (UseParallelOldGC) {
314 return FLAG_IS_ERGO(UseParallelOldGC);
315 } else if (UseConcMarkSweepGC) {
316 return FLAG_IS_ERGO(UseConcMarkSweepGC);
317 } else if (UseG1GC) {
318 return FLAG_IS_ERGO(UseG1GC);
319 }
320 ShouldNotReachHere();
321 return false;
322 WB_END
323
324 WB_ENTRY(jboolean, WB_isObjectInOldGen(JNIEnv* env, jobject o, jobject obj))
325 oop p = JNIHandles::resolve(obj);
326 #if INCLUDE_ALL_GCS
327 if (UseG1GC) {
328 G1CollectedHeap* g1 = G1CollectedHeap::heap();
329 const HeapRegion* hr = g1->heap_region_containing(p);
330 if (hr == NULL) {
331 return false;
332 }
333 return !(hr->is_young());
334 } else if (UseParallelGC) {
335 ParallelScavengeHeap* psh = ParallelScavengeHeap::heap();
336 return !psh->is_in_young(p);
337 }
338 #endif // INCLUDE_ALL_GCS
339 GenCollectedHeap* gch = GenCollectedHeap::heap();
340 return !gch->is_in_young(p);
341 WB_END
342
343 WB_ENTRY(jlong, WB_GetObjectSize(JNIEnv* env, jobject o, jobject obj))
344 oop p = JNIHandles::resolve(obj);
345 return p->size() * HeapWordSize;
346 WB_END
347
348 WB_ENTRY(jlong, WB_GetHeapSpaceAlignment(JNIEnv* env, jobject o))
349 size_t alignment = Universe::heap()->collector_policy()->space_alignment();
350 return (jlong)alignment;
351 WB_END
352
353 WB_ENTRY(jlong, WB_GetHeapAlignment(JNIEnv* env, jobject o))
354 size_t alignment = Universe::heap()->collector_policy()->heap_alignment();
355 return (jlong)alignment;
356 WB_END
357
358 WB_ENTRY(jboolean, WB_SupportsConcurrentGCPhaseControl(JNIEnv* env, jobject o))
359 return Universe::heap()->supports_concurrent_phase_control();
360 WB_END
361
362 WB_ENTRY(jboolean, WB_RequestConcurrentGCPhase(JNIEnv* env, jobject o, jstring name))
363 Handle h_name(THREAD, JNIHandles::resolve(name));
364 ResourceMark rm;
365 const char* c_name = java_lang_String::as_utf8_string(h_name());
366 return Universe::heap()->request_concurrent_phase(c_name);
367 WB_END
368
369 #if INCLUDE_ALL_GCS
370 WB_ENTRY(jboolean, WB_G1IsHumongous(JNIEnv* env, jobject o, jobject obj))
371 G1CollectedHeap* g1 = G1CollectedHeap::heap();
372 oop result = JNIHandles::resolve(obj);
373 const HeapRegion* hr = g1->heap_region_containing(result);
374 return hr->is_humongous();
375 WB_END
376
377 WB_ENTRY(jboolean, WB_G1BelongsToHumongousRegion(JNIEnv* env, jobject o, jlong addr))
378 G1CollectedHeap* g1 = G1CollectedHeap::heap();
379 const HeapRegion* hr = g1->heap_region_containing((void*) addr);
380 return hr->is_humongous();
381 WB_END
382
383 WB_ENTRY(jboolean, WB_G1BelongsToFreeRegion(JNIEnv* env, jobject o, jlong addr))
384 G1CollectedHeap* g1 = G1CollectedHeap::heap();
385 const HeapRegion* hr = g1->heap_region_containing((void*) addr);
386 return hr->is_free();
387 WB_END
388
389 WB_ENTRY(jlong, WB_G1NumMaxRegions(JNIEnv* env, jobject o))
390 G1CollectedHeap* g1 = G1CollectedHeap::heap();
391 size_t nr = g1->max_regions();
392 return (jlong)nr;
393 WB_END
394
395 WB_ENTRY(jlong, WB_G1NumFreeRegions(JNIEnv* env, jobject o))
396 G1CollectedHeap* g1 = G1CollectedHeap::heap();
397 size_t nr = g1->num_free_regions();
398 return (jlong)nr;
399 WB_END
400
401 WB_ENTRY(jboolean, WB_G1InConcurrentMark(JNIEnv* env, jobject o))
402 G1CollectedHeap* g1h = G1CollectedHeap::heap();
403 return g1h->concurrent_mark()->cmThread()->during_cycle();
404 WB_END
405
406 WB_ENTRY(jboolean, WB_G1StartMarkCycle(JNIEnv* env, jobject o))
407 G1CollectedHeap* g1h = G1CollectedHeap::heap();
408 if (!g1h->concurrent_mark()->cmThread()->during_cycle()) {
409 g1h->collect(GCCause::_wb_conc_mark);
410 return true;
411 }
412 return false;
413 WB_END
414
415 WB_ENTRY(jint, WB_G1RegionSize(JNIEnv* env, jobject o))
416 return (jint)HeapRegion::GrainBytes;
417 WB_END
418
419 WB_ENTRY(jlong, WB_PSVirtualSpaceAlignment(JNIEnv* env, jobject o))
420 #if INCLUDE_ALL_GCS
421 if (UseParallelGC) {
422 return ParallelScavengeHeap::heap()->gens()->virtual_spaces()->alignment();
423 }
424 #endif // INCLUDE_ALL_GCS
425 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "WB_PSVirtualSpaceAlignment: Parallel GC is not enabled");
426 WB_END
427
428 WB_ENTRY(jlong, WB_PSHeapGenerationAlignment(JNIEnv* env, jobject o))
429 #if INCLUDE_ALL_GCS
430 if (UseParallelGC) {
431 return ParallelScavengeHeap::heap()->generation_alignment();
432 }
433 #endif // INCLUDE_ALL_GCS
434 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "WB_PSHeapGenerationAlignment: Parallel GC is not enabled");
435 WB_END
436
437 WB_ENTRY(jobject, WB_G1AuxiliaryMemoryUsage(JNIEnv* env))
438 ResourceMark rm(THREAD);
439 G1CollectedHeap* g1h = G1CollectedHeap::heap();
440 MemoryUsage usage = g1h->get_auxiliary_data_memory_usage();
441 Handle h = MemoryService::create_MemoryUsage_obj(usage, CHECK_NULL);
442 return JNIHandles::make_local(env, h());
443 WB_END
444
445 class OldRegionsLivenessClosure: public HeapRegionClosure {
446
447 private:
448 const int _liveness;
449 size_t _total_count;
450 size_t _total_memory;
451 size_t _total_memory_to_free;
452
453 public:
454 OldRegionsLivenessClosure(int liveness) :
455 _liveness(liveness),
456 _total_count(0),
457 _total_memory(0),
458 _total_memory_to_free(0) { }
459
460 size_t total_count() { return _total_count; }
461 size_t total_memory() { return _total_memory; }
462 size_t total_memory_to_free() { return _total_memory_to_free; }
463
464 bool doHeapRegion(HeapRegion* r) {
465 if (r->is_old()) {
466 size_t prev_live = r->marked_bytes();
467 size_t live = r->live_bytes();
468 size_t size = r->used();
469 size_t reg_size = HeapRegion::GrainBytes;
470 if (size > 0 && ((int)(live * 100 / size) < _liveness)) {
471 _total_memory += size;
472 ++_total_count;
473 if (size == reg_size) {
474 // we don't include non-full regions since they are unlikely included in mixed gc
475 // for testing purposes it's enough to have lowest estimation of total memory that is expected to be freed
476 _total_memory_to_free += size - prev_live;
477 }
478 }
479 }
480 return false;
481 }
482 };
483
484
485 WB_ENTRY(jlongArray, WB_G1GetMixedGCInfo(JNIEnv* env, jobject o, jint liveness))
486 if (!UseG1GC) {
487 THROW_MSG_NULL(vmSymbols::java_lang_RuntimeException(), "WB_G1GetMixedGCInfo: G1 is not enabled");
488 }
489 if (liveness < 0) {
490 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "liveness value should be non-negative");
491 }
492
493 G1CollectedHeap* g1h = G1CollectedHeap::heap();
494 OldRegionsLivenessClosure rli(liveness);
495 g1h->heap_region_iterate(&rli);
496
497 typeArrayOop result = oopFactory::new_longArray(3, CHECK_NULL);
498 result->long_at_put(0, rli.total_count());
499 result->long_at_put(1, rli.total_memory());
500 result->long_at_put(2, rli.total_memory_to_free());
501 return (jlongArray) JNIHandles::make_local(env, result);
502 WB_END
503
504
505
506 #endif // INCLUDE_ALL_GCS
507
508 #if INCLUDE_NMT
509 // Alloc memory using the test memory type so that we can use that to see if
510 // NMT picks it up correctly
511 WB_ENTRY(jlong, WB_NMTMalloc(JNIEnv* env, jobject o, jlong size))
512 jlong addr = 0;
513 addr = (jlong)(uintptr_t)os::malloc(size, mtTest);
514 return addr;
515 WB_END
516
517 // Alloc memory with pseudo call stack. The test can create psudo malloc
518 // allocation site to stress the malloc tracking.
519 WB_ENTRY(jlong, WB_NMTMallocWithPseudoStack(JNIEnv* env, jobject o, jlong size, jint pseudo_stack))
520 address pc = (address)(size_t)pseudo_stack;
521 NativeCallStack stack(&pc, 1);
522 return (jlong)(uintptr_t)os::malloc(size, mtTest, stack);
523 WB_END
524
525 // Free the memory allocated by NMTAllocTest
526 WB_ENTRY(void, WB_NMTFree(JNIEnv* env, jobject o, jlong mem))
527 os::free((void*)(uintptr_t)mem);
528 WB_END
529
530 WB_ENTRY(jlong, WB_NMTReserveMemory(JNIEnv* env, jobject o, jlong size))
531 jlong addr = 0;
532
533 addr = (jlong)(uintptr_t)os::reserve_memory(size);
534 MemTracker::record_virtual_memory_type((address)addr, mtTest);
535
536 return addr;
537 WB_END
538
539 WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
540 os::commit_memory((char *)(uintptr_t)addr, size, !ExecMem);
541 MemTracker::record_virtual_memory_type((address)(uintptr_t)addr, mtTest);
542 WB_END
543
544 WB_ENTRY(void, WB_NMTUncommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
545 os::uncommit_memory((char *)(uintptr_t)addr, size);
546 WB_END
547
548 WB_ENTRY(void, WB_NMTReleaseMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
549 os::release_memory((char *)(uintptr_t)addr, size);
550 WB_END
551
552 WB_ENTRY(jboolean, WB_NMTChangeTrackingLevel(JNIEnv* env))
553 // Test that we can downgrade NMT levels but not upgrade them.
554 if (MemTracker::tracking_level() == NMT_off) {
555 MemTracker::transition_to(NMT_off);
556 return MemTracker::tracking_level() == NMT_off;
557 } else {
558 assert(MemTracker::tracking_level() == NMT_detail, "Should start out as detail tracking");
559 MemTracker::transition_to(NMT_summary);
560 assert(MemTracker::tracking_level() == NMT_summary, "Should be summary now");
561
562 // Can't go to detail once NMT is set to summary.
563 MemTracker::transition_to(NMT_detail);
564 assert(MemTracker::tracking_level() == NMT_summary, "Should still be summary now");
565
566 // Shutdown sets tracking level to minimal.
567 MemTracker::shutdown();
568 assert(MemTracker::tracking_level() == NMT_minimal, "Should be minimal now");
569
570 // Once the tracking level is minimal, we cannot increase to summary.
571 // The code ignores this request instead of asserting because if the malloc site
572 // table overflows in another thread, it tries to change the code to summary.
573 MemTracker::transition_to(NMT_summary);
574 assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now");
575
576 // Really can never go up to detail, verify that the code would never do this.
577 MemTracker::transition_to(NMT_detail);
578 assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now");
579 return MemTracker::tracking_level() == NMT_minimal;
580 }
581 WB_END
582
583 WB_ENTRY(jint, WB_NMTGetHashSize(JNIEnv* env, jobject o))
584 int hash_size = MallocSiteTable::hash_buckets();
585 assert(hash_size > 0, "NMT hash_size should be > 0");
586 return (jint)hash_size;
587 WB_END
588 #endif // INCLUDE_NMT
589
590 static jmethodID reflected_method_to_jmid(JavaThread* thread, JNIEnv* env, jobject method) {
591 assert(method != NULL, "method should not be null");
592 ThreadToNativeFromVM ttn(thread);
593 return env->FromReflectedMethod(method);
594 }
595
596 // Deoptimizes all compiled frames and makes nmethods not entrant if it's requested
597 class VM_WhiteBoxDeoptimizeFrames : public VM_WhiteBoxOperation {
598 private:
599 int _result;
600 const bool _make_not_entrant;
601 public:
602 VM_WhiteBoxDeoptimizeFrames(bool make_not_entrant) :
603 _result(0), _make_not_entrant(make_not_entrant) { }
604 int result() const { return _result; }
605
606 void doit() {
607 for (JavaThread* t = Threads::first(); t != NULL; t = t->next()) {
608 if (t->has_last_Java_frame()) {
609 for (StackFrameStream fst(t, UseBiasedLocking); !fst.is_done(); fst.next()) {
610 frame* f = fst.current();
611 if (f->can_be_deoptimized() && !f->is_deoptimized_frame()) {
612 RegisterMap* reg_map = fst.register_map();
613 Deoptimization::deoptimize(t, *f, reg_map);
614 if (_make_not_entrant) {
615 CompiledMethod* cm = CodeCache::find_compiled(f->pc());
616 assert(cm != NULL, "sanity check");
617 cm->make_not_entrant();
618 }
619 ++_result;
620 }
621 }
622 }
623 }
624 }
625 };
626
627 WB_ENTRY(jint, WB_DeoptimizeFrames(JNIEnv* env, jobject o, jboolean make_not_entrant))
628 VM_WhiteBoxDeoptimizeFrames op(make_not_entrant == JNI_TRUE);
629 VMThread::execute(&op);
630 return op.result();
631 WB_END
632
633 WB_ENTRY(void, WB_DeoptimizeAll(JNIEnv* env, jobject o))
634 MutexLockerEx mu(Compile_lock);
635 CodeCache::mark_all_nmethods_for_deoptimization();
636 VM_Deoptimize op;
637 VMThread::execute(&op);
638 WB_END
639
640 WB_ENTRY(jint, WB_DeoptimizeMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
641 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
642 int result = 0;
643 CHECK_JNI_EXCEPTION_(env, result);
644 MutexLockerEx mu(Compile_lock);
645 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
646 if (is_osr) {
647 result += mh->mark_osr_nmethods();
648 } else if (mh->code() != NULL) {
649 mh->code()->mark_for_deoptimization();
650 ++result;
651 }
652 result += CodeCache::mark_for_deoptimization(mh());
653 if (result > 0) {
654 VM_Deoptimize op;
655 VMThread::execute(&op);
656 }
657 return result;
658 WB_END
659
660 WB_ENTRY(jboolean, WB_IsMethodCompiled(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
661 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
662 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
663 MutexLockerEx mu(Compile_lock);
664 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
665 CompiledMethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
666 if (code == NULL) {
667 return JNI_FALSE;
668 }
669 return (code->is_alive() && !code->is_marked_for_deoptimization());
670 WB_END
671
672 WB_ENTRY(jboolean, WB_IsMethodCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr))
673 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
674 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
675 MutexLockerEx mu(Compile_lock);
676 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
677 if (is_osr) {
678 return CompilationPolicy::can_be_osr_compiled(mh, comp_level);
679 } else {
680 return CompilationPolicy::can_be_compiled(mh, comp_level);
681 }
682 WB_END
683
684 WB_ENTRY(jboolean, WB_IsMethodQueuedForCompilation(JNIEnv* env, jobject o, jobject method))
685 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
686 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
687 MutexLockerEx mu(Compile_lock);
688 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
689 return mh->queued_for_compilation();
690 WB_END
691
692 WB_ENTRY(jboolean, WB_IsIntrinsicAvailable(JNIEnv* env, jobject o, jobject method, jobject compilation_context, jint compLevel))
693 if (compLevel < CompLevel_none || compLevel > MIN2((CompLevel) TieredStopAtLevel, CompLevel_highest_tier)) {
694 return false; // Intrinsic is not available on a non-existent compilation level.
695 }
696 jmethodID method_id, compilation_context_id;
697 method_id = reflected_method_to_jmid(thread, env, method);
698 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
699 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(method_id));
700
701 DirectiveSet* directive;
702 AbstractCompiler* comp = CompileBroker::compiler((int)compLevel);
703 assert(comp != NULL, "compiler not available");
704 if (compilation_context != NULL) {
705 compilation_context_id = reflected_method_to_jmid(thread, env, compilation_context);
706 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
707 methodHandle cch(THREAD, Method::checked_resolve_jmethod_id(compilation_context_id));
708 directive = DirectivesStack::getMatchingDirective(cch, comp);
709 } else {
710 // Calling with NULL matches default directive
711 directive = DirectivesStack::getDefaultDirective(comp);
712 }
713 bool result = comp->is_intrinsic_available(mh, directive);
714 DirectivesStack::release(directive);
715 return result;
716 WB_END
717
718 WB_ENTRY(jint, WB_GetMethodCompilationLevel(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
719 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
720 CHECK_JNI_EXCEPTION_(env, CompLevel_none);
721 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
722 CompiledMethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
723 return (code != NULL ? code->comp_level() : CompLevel_none);
724 WB_END
725
726 WB_ENTRY(void, WB_MakeMethodNotCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr))
727 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
728 CHECK_JNI_EXCEPTION(env);
729 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
730 if (is_osr) {
731 mh->set_not_osr_compilable(comp_level, true /* report */, "WhiteBox");
732 } else {
733 mh->set_not_compilable(comp_level, true /* report */, "WhiteBox");
734 }
735 WB_END
736
737 WB_ENTRY(jint, WB_GetMethodEntryBci(JNIEnv* env, jobject o, jobject method))
738 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
739 CHECK_JNI_EXCEPTION_(env, InvocationEntryBci);
740 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
741 CompiledMethod* code = mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false);
742 return (code != NULL && code->is_osr_method() ? code->osr_entry_bci() : InvocationEntryBci);
743 WB_END
744
745 WB_ENTRY(jboolean, WB_TestSetDontInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
746 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
747 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
748 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
749 bool result = mh->dont_inline();
750 mh->set_dont_inline(value == JNI_TRUE);
751 return result;
752 WB_END
753
754 WB_ENTRY(jint, WB_GetCompileQueueSize(JNIEnv* env, jobject o, jint comp_level))
755 if (comp_level == CompLevel_any) {
756 return CompileBroker::queue_size(CompLevel_full_optimization) /* C2 */ +
757 CompileBroker::queue_size(CompLevel_full_profile) /* C1 */;
758 } else {
759 return CompileBroker::queue_size(comp_level);
760 }
761 WB_END
762
763 WB_ENTRY(jboolean, WB_TestSetForceInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
764 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
765 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
766 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
767 bool result = mh->force_inline();
768 mh->set_force_inline(value == JNI_TRUE);
769 return result;
770 WB_END
771
772 bool WhiteBox::compile_method(Method* method, int comp_level, int bci, Thread* THREAD) {
773 // Screen for unavailable/bad comp level or null method
774 if (method == NULL || comp_level > TieredStopAtLevel ||
775 CompileBroker::compiler(comp_level) == NULL) {
776 return false;
777 }
778 methodHandle mh(THREAD, method);
779 nmethod* nm = CompileBroker::compile_method(mh, bci, comp_level, mh, mh->invocation_count(), CompileTask::Reason_Whitebox, THREAD);
780 MutexLockerEx mu(Compile_lock);
781 return (mh->queued_for_compilation() || nm != NULL);
782 }
783
784 WB_ENTRY(jboolean, WB_EnqueueMethodForCompilation(JNIEnv* env, jobject o, jobject method, jint comp_level, jint bci))
785 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
786 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
787 return WhiteBox::compile_method(Method::checked_resolve_jmethod_id(jmid), comp_level, bci, THREAD);
788 WB_END
789
790 WB_ENTRY(jboolean, WB_EnqueueInitializerForCompilation(JNIEnv* env, jobject o, jclass klass, jint comp_level))
791 instanceKlassHandle ikh(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
792 return WhiteBox::compile_method(ikh->class_initializer(), comp_level, InvocationEntryBci, THREAD);
793 WB_END
794
795 WB_ENTRY(jboolean, WB_ShouldPrintAssembly(JNIEnv* env, jobject o, jobject method, jint comp_level))
796 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
797 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
798
799 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
800 DirectiveSet* directive = DirectivesStack::getMatchingDirective(mh, CompileBroker::compiler(comp_level));
801 bool result = directive->PrintAssemblyOption;
802 DirectivesStack::release(directive);
803
804 return result;
805 WB_END
806
807 WB_ENTRY(jint, WB_MatchesInline(JNIEnv* env, jobject o, jobject method, jstring pattern))
808 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
809 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
810
811 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
812
813 ResourceMark rm;
814 const char* error_msg = NULL;
815 char* method_str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(pattern));
816 InlineMatcher* m = InlineMatcher::parse_inline_pattern(method_str, error_msg);
817
818 if (m == NULL) {
819 assert(error_msg != NULL, "Always have an error message");
820 tty->print_cr("Got error: %s", error_msg);
821 return -1; // Pattern failed
822 }
823
824 // Pattern works - now check if it matches
825 int result;
826 if (m->match(mh, InlineMatcher::force_inline)) {
827 result = 2; // Force inline match
828 } else if (m->match(mh, InlineMatcher::dont_inline)) {
829 result = 1; // Dont inline match
830 } else {
831 result = 0; // No match
832 }
833 delete m;
834 return result;
835 WB_END
836
837 WB_ENTRY(jint, WB_MatchesMethod(JNIEnv* env, jobject o, jobject method, jstring pattern))
838 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
839 CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
840
841 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
842
843 ResourceMark rm;
844 char* method_str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(pattern));
845
846 const char* error_msg = NULL;
847
848 BasicMatcher* m = BasicMatcher::parse_method_pattern(method_str, error_msg);
849 if (m == NULL) {
850 assert(error_msg != NULL, "Must have error_msg");
851 tty->print_cr("Got error: %s", error_msg);
852 return -1;
853 }
854
855 // Pattern works - now check if it matches
856 int result = m->matches(mh);
857 delete m;
858 assert(result == 0 || result == 1, "Result out of range");
859 return result;
860 WB_END
861
862 static AlwaysFalseClosure always_false;
863
864 WB_ENTRY(void, WB_ClearMethodState(JNIEnv* env, jobject o, jobject method))
865 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
866 CHECK_JNI_EXCEPTION(env);
867 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
868 MutexLockerEx mu(Compile_lock);
869 MethodData* mdo = mh->method_data();
870 MethodCounters* mcs = mh->method_counters();
871
872 if (mdo != NULL) {
873 mdo->init();
874 ResourceMark rm;
875 int arg_count = mdo->method()->size_of_parameters();
876 for (int i = 0; i < arg_count; i++) {
877 mdo->set_arg_modified(i, 0);
878 }
879 MutexLockerEx mu(mdo->extra_data_lock());
880 mdo->clean_method_data(&always_false);
881 }
882
883 mh->clear_not_c1_compilable();
884 mh->clear_not_c2_compilable();
885 mh->clear_not_c2_osr_compilable();
886 NOT_PRODUCT(mh->set_compiled_invocation_count(0));
887 if (mcs != NULL) {
888 mcs->backedge_counter()->init();
889 mcs->invocation_counter()->init();
890 mcs->set_interpreter_invocation_count(0);
891 mcs->set_interpreter_throwout_count(0);
892
893 #ifdef TIERED
894 mcs->set_rate(0.0F);
895 mh->set_prev_event_count(0);
896 mh->set_prev_time(0);
897 #endif
898 }
899 WB_END
900
901 template <typename T>
902 static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, Flag::Error (*TAt)(const char*, T*, bool, bool)) {
903 if (name == NULL) {
904 return false;
905 }
906 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
907 const char* flag_name = env->GetStringUTFChars(name, NULL);
908 CHECK_JNI_EXCEPTION_(env, false);
909 Flag::Error result = (*TAt)(flag_name, value, true, true);
910 env->ReleaseStringUTFChars(name, flag_name);
911 return (result == Flag::SUCCESS);
912 }
913
914 template <typename T>
915 static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, Flag::Error (*TAtPut)(const char*, T*, Flag::Flags)) {
916 if (name == NULL) {
917 return false;
918 }
919 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
920 const char* flag_name = env->GetStringUTFChars(name, NULL);
921 CHECK_JNI_EXCEPTION_(env, false);
922 Flag::Error result = (*TAtPut)(flag_name, value, Flag::INTERNAL);
923 env->ReleaseStringUTFChars(name, flag_name);
924 return (result == Flag::SUCCESS);
925 }
926
927 template <typename T>
928 static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {
929 ResourceMark rm(thread);
930 jclass clazz = env->FindClass(name->as_C_string());
931 CHECK_JNI_EXCEPTION_(env, NULL);
932 jmethodID methodID = env->GetStaticMethodID(clazz,
933 vmSymbols::valueOf_name()->as_C_string(),
934 sig->as_C_string());
935 CHECK_JNI_EXCEPTION_(env, NULL);
936 jobject result = env->CallStaticObjectMethod(clazz, methodID, value);
937 CHECK_JNI_EXCEPTION_(env, NULL);
938 return result;
939 }
940
941 static jobject booleanBox(JavaThread* thread, JNIEnv* env, jboolean value) {
942 return box(thread, env, vmSymbols::java_lang_Boolean(), vmSymbols::Boolean_valueOf_signature(), value);
943 }
944 static jobject integerBox(JavaThread* thread, JNIEnv* env, jint value) {
945 return box(thread, env, vmSymbols::java_lang_Integer(), vmSymbols::Integer_valueOf_signature(), value);
946 }
947 static jobject longBox(JavaThread* thread, JNIEnv* env, jlong value) {
948 return box(thread, env, vmSymbols::java_lang_Long(), vmSymbols::Long_valueOf_signature(), value);
949 }
950 /* static jobject floatBox(JavaThread* thread, JNIEnv* env, jfloat value) {
951 return box(thread, env, vmSymbols::java_lang_Float(), vmSymbols::Float_valueOf_signature(), value);
952 }*/
953 static jobject doubleBox(JavaThread* thread, JNIEnv* env, jdouble value) {
954 return box(thread, env, vmSymbols::java_lang_Double(), vmSymbols::Double_valueOf_signature(), value);
955 }
956
957 static Flag* getVMFlag(JavaThread* thread, JNIEnv* env, jstring name) {
958 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
959 const char* flag_name = env->GetStringUTFChars(name, NULL);
960 CHECK_JNI_EXCEPTION_(env, NULL);
961 Flag* result = Flag::find_flag(flag_name, strlen(flag_name), true, true);
962 env->ReleaseStringUTFChars(name, flag_name);
963 return result;
964 }
965
966 WB_ENTRY(jboolean, WB_IsConstantVMFlag(JNIEnv* env, jobject o, jstring name))
967 Flag* flag = getVMFlag(thread, env, name);
968 return (flag != NULL) && flag->is_constant_in_binary();
969 WB_END
970
971 WB_ENTRY(jboolean, WB_IsLockedVMFlag(JNIEnv* env, jobject o, jstring name))
972 Flag* flag = getVMFlag(thread, env, name);
973 return (flag != NULL) && !(flag->is_unlocked() || flag->is_unlocker());
974 WB_END
975
976 WB_ENTRY(jobject, WB_GetBooleanVMFlag(JNIEnv* env, jobject o, jstring name))
977 bool result;
978 if (GetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAt)) {
979 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
980 return booleanBox(thread, env, result);
981 }
982 return NULL;
983 WB_END
984
985 WB_ENTRY(jobject, WB_GetIntVMFlag(JNIEnv* env, jobject o, jstring name))
986 int result;
987 if (GetVMFlag <int> (thread, env, name, &result, &CommandLineFlags::intAt)) {
988 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
989 return longBox(thread, env, result);
990 }
991 return NULL;
992 WB_END
993
994 WB_ENTRY(jobject, WB_GetUintVMFlag(JNIEnv* env, jobject o, jstring name))
995 uint result;
996 if (GetVMFlag <uint> (thread, env, name, &result, &CommandLineFlags::uintAt)) {
997 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
998 return longBox(thread, env, result);
999 }
1000 return NULL;
1001 WB_END
1002
1003 WB_ENTRY(jobject, WB_GetIntxVMFlag(JNIEnv* env, jobject o, jstring name))
1004 intx result;
1005 if (GetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAt)) {
1006 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1007 return longBox(thread, env, result);
1008 }
1009 return NULL;
1010 WB_END
1011
1012 WB_ENTRY(jobject, WB_GetUintxVMFlag(JNIEnv* env, jobject o, jstring name))
1013 uintx result;
1014 if (GetVMFlag <uintx> (thread, env, name, &result, &CommandLineFlags::uintxAt)) {
1015 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1016 return longBox(thread, env, result);
1017 }
1018 return NULL;
1019 WB_END
1020
1021 WB_ENTRY(jobject, WB_GetUint64VMFlag(JNIEnv* env, jobject o, jstring name))
1022 uint64_t result;
1023 if (GetVMFlag <uint64_t> (thread, env, name, &result, &CommandLineFlags::uint64_tAt)) {
1024 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1025 return longBox(thread, env, result);
1026 }
1027 return NULL;
1028 WB_END
1029
1030 WB_ENTRY(jobject, WB_GetSizeTVMFlag(JNIEnv* env, jobject o, jstring name))
1031 uintx result;
1032 if (GetVMFlag <size_t> (thread, env, name, &result, &CommandLineFlags::size_tAt)) {
1033 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1034 return longBox(thread, env, result);
1035 }
1036 return NULL;
1037 WB_END
1038
1039 WB_ENTRY(jobject, WB_GetDoubleVMFlag(JNIEnv* env, jobject o, jstring name))
1040 double result;
1041 if (GetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAt)) {
1042 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1043 return doubleBox(thread, env, result);
1044 }
1045 return NULL;
1046 WB_END
1047
1048 WB_ENTRY(jstring, WB_GetStringVMFlag(JNIEnv* env, jobject o, jstring name))
1049 ccstr ccstrResult;
1050 if (GetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAt)) {
1051 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1052 jstring result = env->NewStringUTF(ccstrResult);
1053 CHECK_JNI_EXCEPTION_(env, NULL);
1054 return result;
1055 }
1056 return NULL;
1057 WB_END
1058
1059 WB_ENTRY(void, WB_SetBooleanVMFlag(JNIEnv* env, jobject o, jstring name, jboolean value))
1060 bool result = value == JNI_TRUE ? true : false;
1061 SetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAtPut);
1062 WB_END
1063
1064 WB_ENTRY(void, WB_SetIntVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1065 int result = value;
1066 SetVMFlag <int> (thread, env, name, &result, &CommandLineFlags::intAtPut);
1067 WB_END
1068
1069 WB_ENTRY(void, WB_SetUintVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1070 uint result = value;
1071 SetVMFlag <uint> (thread, env, name, &result, &CommandLineFlags::uintAtPut);
1072 WB_END
1073
1074 WB_ENTRY(void, WB_SetIntxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1075 intx result = value;
1076 SetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAtPut);
1077 WB_END
1078
1079 WB_ENTRY(void, WB_SetUintxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1080 uintx result = value;
1081 SetVMFlag <uintx> (thread, env, name, &result, &CommandLineFlags::uintxAtPut);
1082 WB_END
1083
1084 WB_ENTRY(void, WB_SetUint64VMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1085 uint64_t result = value;
1086 SetVMFlag <uint64_t> (thread, env, name, &result, &CommandLineFlags::uint64_tAtPut);
1087 WB_END
1088
1089 WB_ENTRY(void, WB_SetSizeTVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
1090 size_t result = value;
1091 SetVMFlag <size_t> (thread, env, name, &result, &CommandLineFlags::size_tAtPut);
1092 WB_END
1093
1094 WB_ENTRY(void, WB_SetDoubleVMFlag(JNIEnv* env, jobject o, jstring name, jdouble value))
1095 double result = value;
1096 SetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAtPut);
1097 WB_END
1098
1099 WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value))
1100 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1101 const char* ccstrValue;
1102 if (value == NULL) {
1103 ccstrValue = NULL;
1104 }
1105 else {
1106 ccstrValue = env->GetStringUTFChars(value, NULL);
1107 CHECK_JNI_EXCEPTION(env);
1108 }
1109 ccstr ccstrResult = ccstrValue;
1110 bool needFree;
1111 {
1112 ThreadInVMfromNative ttvfn(thread); // back to VM
1113 needFree = SetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAtPut);
1114 }
1115 if (value != NULL) {
1116 env->ReleaseStringUTFChars(value, ccstrValue);
1117 }
1118 if (needFree) {
1119 FREE_C_HEAP_ARRAY(char, ccstrResult);
1120 }
1121 WB_END
1122
1123 WB_ENTRY(void, WB_LockCompilation(JNIEnv* env, jobject o, jlong timeout))
1124 WhiteBox::compilation_locked = true;
1125 WB_END
1126
1127 WB_ENTRY(void, WB_UnlockCompilation(JNIEnv* env, jobject o))
1128 MonitorLockerEx mo(Compilation_lock, Mutex::_no_safepoint_check_flag);
1129 WhiteBox::compilation_locked = false;
1130 mo.notify_all();
1131 WB_END
1132
1133 WB_ENTRY(void, WB_ForceNMethodSweep(JNIEnv* env, jobject o))
1134 // Force a code cache sweep and block until it finished
1135 NMethodSweeper::force_sweep();
1136 WB_END
1137
1138 WB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString))
1139 ResourceMark rm(THREAD);
1140 int len;
1141 jchar* name = java_lang_String::as_unicode_string(JNIHandles::resolve(javaString), len, CHECK_false);
1142 return (StringTable::lookup(name, len) != NULL);
1143 WB_END
1144
1145 WB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o))
1146 Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(true);
1147 Universe::heap()->collect(GCCause::_wb_full_gc);
1148 #if INCLUDE_ALL_GCS
1149 if (UseG1GC) {
1150 // Needs to be cleared explicitly for G1
1151 Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(false);
1152 }
1153 #endif // INCLUDE_ALL_GCS
1154 WB_END
1155
1156 WB_ENTRY(void, WB_YoungGC(JNIEnv* env, jobject o))
1157 Universe::heap()->collect(GCCause::_wb_young_gc);
1158 WB_END
1159
1160 WB_ENTRY(void, WB_ReadReservedMemory(JNIEnv* env, jobject o))
1161 // static+volatile in order to force the read to happen
1162 // (not be eliminated by the compiler)
1163 static char c;
1164 static volatile char* p;
1165
1166 p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
1167 if (p == NULL) {
1168 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
1169 }
1170
1171 c = *p;
1172 WB_END
1173
1174 WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
1175 const char* features = VM_Version::features_string();
1176 ThreadToNativeFromVM ttn(thread);
1177 jstring features_string = env->NewStringUTF(features);
1178
1179 CHECK_JNI_EXCEPTION_(env, NULL);
1180
1181 return features_string;
1182 WB_END
1183
1184 int WhiteBox::get_blob_type(const CodeBlob* code) {
1185 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
1186 if (code->is_aot()) {
1187 return -1;
1188 }
1189 return CodeCache::get_code_heap(code)->code_blob_type();
1190 }
1191
1192 CodeHeap* WhiteBox::get_code_heap(int blob_type) {
1193 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
1194 return CodeCache::get_code_heap(blob_type);
1195 }
1196
1197 struct CodeBlobStub {
1198 CodeBlobStub(const CodeBlob* blob) :
1199 name(os::strdup(blob->name())),
1200 size(blob->size()),
1201 blob_type(WhiteBox::get_blob_type(blob)),
1202 address((jlong) blob) { }
1203 ~CodeBlobStub() { os::free((void*) name); }
1204 const char* const name;
1205 const jint size;
1206 const jint blob_type;
1207 const jlong address;
1208 };
1209
1210 static jobjectArray codeBlob2objectArray(JavaThread* thread, JNIEnv* env, CodeBlobStub* cb) {
1211 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
1212 CHECK_JNI_EXCEPTION_(env, NULL);
1213 jobjectArray result = env->NewObjectArray(4, clazz, NULL);
1214
1215 jstring name = env->NewStringUTF(cb->name);
1216 CHECK_JNI_EXCEPTION_(env, NULL);
1217 env->SetObjectArrayElement(result, 0, name);
1218
1219 jobject obj = integerBox(thread, env, cb->size);
1220 CHECK_JNI_EXCEPTION_(env, NULL);
1221 env->SetObjectArrayElement(result, 1, obj);
1222
1223 obj = integerBox(thread, env, cb->blob_type);
1224 CHECK_JNI_EXCEPTION_(env, NULL);
1225 env->SetObjectArrayElement(result, 2, obj);
1226
1227 obj = longBox(thread, env, cb->address);
1228 CHECK_JNI_EXCEPTION_(env, NULL);
1229 env->SetObjectArrayElement(result, 3, obj);
1230
1231 return result;
1232 }
1233
1234 WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
1235 ResourceMark rm(THREAD);
1236 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1237 CHECK_JNI_EXCEPTION_(env, NULL);
1238 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
1239 CompiledMethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
1240 jobjectArray result = NULL;
1241 if (code == NULL) {
1242 return result;
1243 }
1244 int comp_level = code->comp_level();
1245 int insts_size = comp_level == CompLevel_aot ? code->code_end() - code->code_begin() : code->insts_size();
1246
1247 ThreadToNativeFromVM ttn(thread);
1248 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
1249 CHECK_JNI_EXCEPTION_(env, NULL);
1250 result = env->NewObjectArray(5, clazz, NULL);
1251 if (result == NULL) {
1252 return result;
1253 }
1254
1255 CodeBlobStub stub(code);
1256 jobjectArray codeBlob = codeBlob2objectArray(thread, env, &stub);
1257 CHECK_JNI_EXCEPTION_(env, NULL);
1258 env->SetObjectArrayElement(result, 0, codeBlob);
1259
1260 jobject level = integerBox(thread, env, comp_level);
1261 CHECK_JNI_EXCEPTION_(env, NULL);
1262 env->SetObjectArrayElement(result, 1, level);
1263
1264 jbyteArray insts = env->NewByteArray(insts_size);
1265 CHECK_JNI_EXCEPTION_(env, NULL);
1266 env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
1267 env->SetObjectArrayElement(result, 2, insts);
1268
1269 jobject id = integerBox(thread, env, code->compile_id());
1270 CHECK_JNI_EXCEPTION_(env, NULL);
1271 env->SetObjectArrayElement(result, 3, id);
1272
1273 jobject entry_point = longBox(thread, env, (jlong) code->entry_point());
1274 CHECK_JNI_EXCEPTION_(env, NULL);
1275 env->SetObjectArrayElement(result, 4, entry_point);
1276
1277 return result;
1278 WB_END
1279
1280 CodeBlob* WhiteBox::allocate_code_blob(int size, int blob_type) {
1281 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
1282 BufferBlob* blob;
1283 int full_size = CodeBlob::align_code_offset(sizeof(BufferBlob));
1284 if (full_size < size) {
1285 full_size += round_to(size - full_size, oopSize);
1286 }
1287 {
1288 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
1289 blob = (BufferBlob*) CodeCache::allocate(full_size, blob_type);
1290 ::new (blob) BufferBlob("WB::DummyBlob", full_size);
1291 }
1292 // Track memory usage statistic after releasing CodeCache_lock
1293 MemoryService::track_code_cache_memory_usage();
1294 return blob;
1295 }
1296
1297 WB_ENTRY(jlong, WB_AllocateCodeBlob(JNIEnv* env, jobject o, jint size, jint blob_type))
1298 if (size < 0) {
1299 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1300 err_msg("WB_AllocateCodeBlob: size is negative: " INT32_FORMAT, size));
1301 }
1302 return (jlong) WhiteBox::allocate_code_blob(size, blob_type);
1303 WB_END
1304
1305 WB_ENTRY(void, WB_FreeCodeBlob(JNIEnv* env, jobject o, jlong addr))
1306 if (addr == 0) {
1307 return;
1308 }
1309 BufferBlob::free((BufferBlob*) addr);
1310 WB_END
1311
1312 WB_ENTRY(jobjectArray, WB_GetCodeHeapEntries(JNIEnv* env, jobject o, jint blob_type))
1313 ResourceMark rm;
1314 GrowableArray<CodeBlobStub*> blobs;
1315 {
1316 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
1317 CodeHeap* heap = WhiteBox::get_code_heap(blob_type);
1318 if (heap == NULL) {
1319 return NULL;
1320 }
1321 for (CodeBlob* cb = (CodeBlob*) heap->first();
1322 cb != NULL; cb = (CodeBlob*) heap->next(cb)) {
1323 CodeBlobStub* stub = NEW_RESOURCE_OBJ(CodeBlobStub);
1324 new (stub) CodeBlobStub(cb);
1325 blobs.append(stub);
1326 }
1327 }
1328 if (blobs.length() == 0) {
1329 return NULL;
1330 }
1331 ThreadToNativeFromVM ttn(thread);
1332 jobjectArray result = NULL;
1333 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
1334 CHECK_JNI_EXCEPTION_(env, NULL);
1335 result = env->NewObjectArray(blobs.length(), clazz, NULL);
1336 CHECK_JNI_EXCEPTION_(env, NULL);
1337 if (result == NULL) {
1338 return result;
1339 }
1340 int i = 0;
1341 for (GrowableArrayIterator<CodeBlobStub*> it = blobs.begin();
1342 it != blobs.end(); ++it) {
1343 jobjectArray obj = codeBlob2objectArray(thread, env, *it);
1344 CHECK_JNI_EXCEPTION_(env, NULL);
1345 env->SetObjectArrayElement(result, i, obj);
1346 CHECK_JNI_EXCEPTION_(env, NULL);
1347 ++i;
1348 }
1349 return result;
1350 WB_END
1351
1352 WB_ENTRY(jint, WB_GetCompilationActivityMode(JNIEnv* env, jobject o))
1353 return CompileBroker::get_compilation_activity_mode();
1354 WB_END
1355
1356 WB_ENTRY(jobjectArray, WB_GetCodeBlob(JNIEnv* env, jobject o, jlong addr))
1357 if (addr == 0) {
1358 THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(),
1359 "WB_GetCodeBlob: addr is null");
1360 }
1361 ThreadToNativeFromVM ttn(thread);
1362 CodeBlobStub stub((CodeBlob*) addr);
1363 return codeBlob2objectArray(thread, env, &stub);
1364 WB_END
1365
1366 WB_ENTRY(jlong, WB_GetMethodData(JNIEnv* env, jobject wv, jobject method))
1367 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1368 CHECK_JNI_EXCEPTION_(env, 0);
1369 methodHandle mh(thread, Method::checked_resolve_jmethod_id(jmid));
1370 return (jlong) mh->method_data();
1371 WB_END
1372
1373 WB_ENTRY(jlong, WB_GetThreadStackSize(JNIEnv* env, jobject o))
1374 return (jlong) Thread::current()->stack_size();
1375 WB_END
1376
1377 WB_ENTRY(jlong, WB_GetThreadRemainingStackSize(JNIEnv* env, jobject o))
1378 JavaThread* t = JavaThread::current();
1379 return (jlong) t->stack_available(os::current_stack_pointer()) - (jlong)JavaThread::stack_shadow_zone_size();
1380 WB_END
1381
1382
1383 int WhiteBox::array_bytes_to_length(size_t bytes) {
1384 return Array<u1>::bytes_to_length(bytes);
1385 }
1386
1387 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
1388 if (size < 0) {
1389 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1390 err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
1391 }
1392
1393 oop class_loader_oop = JNIHandles::resolve(class_loader);
1394 ClassLoaderData* cld = class_loader_oop != NULL
1395 ? java_lang_ClassLoader::loader_data(class_loader_oop)
1396 : ClassLoaderData::the_null_class_loader_data();
1397
1398 void* metadata = MetadataFactory::new_writeable_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread);
1399
1400 return (jlong)(uintptr_t)metadata;
1401 WB_END
1402
1403 WB_ENTRY(void, WB_FreeMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong addr, jlong size))
1404 oop class_loader_oop = JNIHandles::resolve(class_loader);
1405 ClassLoaderData* cld = class_loader_oop != NULL
1406 ? java_lang_ClassLoader::loader_data(class_loader_oop)
1407 : ClassLoaderData::the_null_class_loader_data();
1408
1409 MetadataFactory::free_array(cld, (Array<u1>*)(uintptr_t)addr);
1410 WB_END
1411
1412 WB_ENTRY(void, WB_DefineModule(JNIEnv* env, jobject o, jobject module, jstring version, jstring location,
1413 jobjectArray packages))
1414 Modules::define_module(module, version, location, packages, CHECK);
1415 WB_END
1416
1417 WB_ENTRY(void, WB_AddModuleExports(JNIEnv* env, jobject o, jobject from_module, jstring package, jobject to_module))
1418 Modules::add_module_exports_qualified(from_module, package, to_module, CHECK);
1419 WB_END
1420
1421 WB_ENTRY(void, WB_AddModuleExportsToAllUnnamed(JNIEnv* env, jobject o, jclass module, jstring package))
1422 Modules::add_module_exports_to_all_unnamed(module, package, CHECK);
1423 WB_END
1424
1425 WB_ENTRY(void, WB_AddModuleExportsToAll(JNIEnv* env, jobject o, jclass module, jstring package))
1426 Modules::add_module_exports(module, package, NULL, CHECK);
1427 WB_END
1428
1429 WB_ENTRY(void, WB_AddReadsModule(JNIEnv* env, jobject o, jobject from_module, jobject source_module))
1430 Modules::add_reads_module(from_module, source_module, CHECK);
1431 WB_END
1432
1433 WB_ENTRY(void, WB_AddModulePackage(JNIEnv* env, jobject o, jclass module, jstring package))
1434 Modules::add_module_package(module, package, CHECK);
1435 WB_END
1436
1437 WB_ENTRY(jobject, WB_GetModuleByPackageName(JNIEnv* env, jobject o, jobject loader, jstring package))
1438 return Modules::get_module_by_package_name(loader, package, THREAD);
1439 WB_END
1440
1441 WB_ENTRY(jlong, WB_IncMetaspaceCapacityUntilGC(JNIEnv* env, jobject wb, jlong inc))
1442 if (inc < 0) {
1443 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1444 err_msg("WB_IncMetaspaceCapacityUntilGC: inc is negative: " JLONG_FORMAT, inc));
1445 }
1446
1447 jlong max_size_t = (jlong) ((size_t) -1);
1448 if (inc > max_size_t) {
1449 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1450 err_msg("WB_IncMetaspaceCapacityUntilGC: inc does not fit in size_t: " JLONG_FORMAT, inc));
1451 }
1452
1453 size_t new_cap_until_GC = 0;
1454 size_t aligned_inc = align_size_down((size_t) inc, Metaspace::commit_alignment());
1455 bool success = MetaspaceGC::inc_capacity_until_GC(aligned_inc, &new_cap_until_GC);
1456 if (!success) {
1457 THROW_MSG_0(vmSymbols::java_lang_IllegalStateException(),
1458 "WB_IncMetaspaceCapacityUntilGC: could not increase capacity until GC "
1459 "due to contention with another thread");
1460 }
1461 return (jlong) new_cap_until_GC;
1462 WB_END
1463
1464 WB_ENTRY(jlong, WB_MetaspaceCapacityUntilGC(JNIEnv* env, jobject wb))
1465 return (jlong) MetaspaceGC::capacity_until_GC();
1466 WB_END
1467
1468 WB_ENTRY(jboolean, WB_MetaspaceShouldConcurrentCollect(JNIEnv* env, jobject wb))
1469 return MetaspaceGC::should_concurrent_collect();
1470 WB_END
1471
1472
1473 WB_ENTRY(void, WB_AssertMatchingSafepointCalls(JNIEnv* env, jobject o, jboolean mutexSafepointValue, jboolean attemptedNoSafepointValue))
1474 Monitor::SafepointCheckRequired sfpt_check_required = mutexSafepointValue ?
1475 Monitor::_safepoint_check_always :
1476 Monitor::_safepoint_check_never;
1477 MutexLockerEx ml(new Mutex(Mutex::leaf, "SFPT_Test_lock", true, sfpt_check_required),
1478 attemptedNoSafepointValue == JNI_TRUE);
1479 WB_END
1480
1481 WB_ENTRY(jboolean, WB_IsMonitorInflated(JNIEnv* env, jobject wb, jobject obj))
1482 oop obj_oop = JNIHandles::resolve(obj);
1483 return (jboolean) obj_oop->mark()->has_monitor();
1484 WB_END
1485
1486 WB_ENTRY(void, WB_ForceSafepoint(JNIEnv* env, jobject wb))
1487 VM_ForceSafepoint force_safepoint_op;
1488 VMThread::execute(&force_safepoint_op);
1489 WB_END
1490
1491 WB_ENTRY(jlong, WB_GetConstantPool(JNIEnv* env, jobject wb, jclass klass))
1492 instanceKlassHandle ikh(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1493 return (jlong) ikh->constants();
1494 WB_END
1495
1496 WB_ENTRY(jint, WB_GetConstantPoolCacheIndexTag(JNIEnv* env, jobject wb))
1497 return ConstantPool::CPCACHE_INDEX_TAG;
1498 WB_END
1499
1500 WB_ENTRY(jint, WB_GetConstantPoolCacheLength(JNIEnv* env, jobject wb, jclass klass))
1501 instanceKlassHandle ikh(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1502 ConstantPool* cp = ikh->constants();
1503 if (cp->cache() == NULL) {
1504 return -1;
1505 }
1506 return cp->cache()->length();
1507 WB_END
1508
1509 WB_ENTRY(jint, WB_ConstantPoolRemapInstructionOperandFromCache(JNIEnv* env, jobject wb, jclass klass, jint index))
1510 instanceKlassHandle ikh(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1511 ConstantPool* cp = ikh->constants();
1512 if (cp->cache() == NULL) {
1513 THROW_MSG_0(vmSymbols::java_lang_IllegalStateException(), "Constant pool does not have a cache");
1514 }
1515 jint cpci = index;
1516 jint cpciTag = ConstantPool::CPCACHE_INDEX_TAG;
1517 if (cpciTag > cpci || cpci >= cp->cache()->length() + cpciTag) {
1518 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Constant pool cache index is out of range");
1519 }
1520 jint cpi = cp->remap_instruction_operand_from_cache(cpci);
1521 return cpi;
1522 WB_END
1523
1524 WB_ENTRY(jint, WB_ConstantPoolEncodeIndyIndex(JNIEnv* env, jobject wb, jint index))
1525 return ConstantPool::encode_invokedynamic_index(index);
1526 WB_END
1527
1528 WB_ENTRY(void, WB_ClearInlineCaches(JNIEnv* env, jobject wb, jboolean preserve_static_stubs))
1529 VM_ClearICs clear_ics(preserve_static_stubs == JNI_TRUE);
1530 VMThread::execute(&clear_ics);
1531 WB_END
1532
1533 template <typename T>
1534 static bool GetMethodOption(JavaThread* thread, JNIEnv* env, jobject method, jstring name, T* value) {
1535 assert(value != NULL, "sanity");
1536 if (method == NULL || name == NULL) {
1537 return false;
1538 }
1539 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1540 CHECK_JNI_EXCEPTION_(env, false);
1541 methodHandle mh(thread, Method::checked_resolve_jmethod_id(jmid));
1542 // can't be in VM when we call JNI
1543 ThreadToNativeFromVM ttnfv(thread);
1544 const char* flag_name = env->GetStringUTFChars(name, NULL);
1545 CHECK_JNI_EXCEPTION_(env, false);
1546 bool result = CompilerOracle::has_option_value(mh, flag_name, *value);
1547 env->ReleaseStringUTFChars(name, flag_name);
1548 return result;
1549 }
1550
1551 WB_ENTRY(jobject, WB_GetMethodBooleaneOption(JNIEnv* env, jobject wb, jobject method, jstring name))
1552 bool result;
1553 if (GetMethodOption<bool> (thread, env, method, name, &result)) {
1554 // can't be in VM when we call JNI
1555 ThreadToNativeFromVM ttnfv(thread);
1556 return booleanBox(thread, env, result);
1557 }
1558 return NULL;
1559 WB_END
1560
1561 WB_ENTRY(jobject, WB_GetMethodIntxOption(JNIEnv* env, jobject wb, jobject method, jstring name))
1562 intx result;
1563 if (GetMethodOption <intx> (thread, env, method, name, &result)) {
1564 // can't be in VM when we call JNI
1565 ThreadToNativeFromVM ttnfv(thread);
1566 return longBox(thread, env, result);
1567 }
1568 return NULL;
1569 WB_END
1570
1571 WB_ENTRY(jobject, WB_GetMethodUintxOption(JNIEnv* env, jobject wb, jobject method, jstring name))
1572 uintx result;
1573 if (GetMethodOption <uintx> (thread, env, method, name, &result)) {
1574 // can't be in VM when we call JNI
1575 ThreadToNativeFromVM ttnfv(thread);
1576 return longBox(thread, env, result);
1577 }
1578 return NULL;
1579 WB_END
1580
1581 WB_ENTRY(jobject, WB_GetMethodDoubleOption(JNIEnv* env, jobject wb, jobject method, jstring name))
1582 double result;
1583 if (GetMethodOption <double> (thread, env, method, name, &result)) {
1584 // can't be in VM when we call JNI
1585 ThreadToNativeFromVM ttnfv(thread);
1586 return doubleBox(thread, env, result);
1587 }
1588 return NULL;
1589 WB_END
1590
1591 WB_ENTRY(jobject, WB_GetMethodStringOption(JNIEnv* env, jobject wb, jobject method, jstring name))
1592 ccstr ccstrResult;
1593 if (GetMethodOption <ccstr> (thread, env, method, name, &ccstrResult)) {
1594 // can't be in VM when we call JNI
1595 ThreadToNativeFromVM ttnfv(thread);
1596 jstring result = env->NewStringUTF(ccstrResult);
1597 CHECK_JNI_EXCEPTION_(env, NULL);
1598 return result;
1599 }
1600 return NULL;
1601 WB_END
1602
1603 WB_ENTRY(jboolean, WB_IsShared(JNIEnv* env, jobject wb, jobject obj))
1604 oop obj_oop = JNIHandles::resolve(obj);
1605 return MetaspaceShared::is_in_shared_space((void*)obj_oop);
1606 WB_END
1607
1608 WB_ENTRY(jboolean, WB_IsSharedClass(JNIEnv* env, jobject wb, jclass clazz))
1609 return (jboolean)MetaspaceShared::is_in_shared_space(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
1610 WB_END
1611
1612 WB_ENTRY(jboolean, WB_AreSharedStringsIgnored(JNIEnv* env))
1613 return StringTable::shared_string_ignored();
1614 WB_END
1615
1616 //Some convenience methods to deal with objects from java
1617 int WhiteBox::offset_for_field(const char* field_name, oop object,
1618 Symbol* signature_symbol) {
1619 assert(field_name != NULL && strlen(field_name) > 0, "Field name not valid");
1620 Thread* THREAD = Thread::current();
1621
1622 //Get the class of our object
1623 Klass* arg_klass = object->klass();
1624 //Turn it into an instance-klass
1625 InstanceKlass* ik = InstanceKlass::cast(arg_klass);
1626
1627 //Create symbols to look for in the class
1628 TempNewSymbol name_symbol = SymbolTable::lookup(field_name, (int) strlen(field_name),
1629 THREAD);
1630
1631 //To be filled in with an offset of the field we're looking for
1632 fieldDescriptor fd;
1633
1634 Klass* res = ik->find_field(name_symbol, signature_symbol, &fd);
1635 if (res == NULL) {
1636 tty->print_cr("Invalid layout of %s at %s", ik->external_name(),
1637 name_symbol->as_C_string());
1638 vm_exit_during_initialization("Invalid layout of preloaded class: use -Xlog:class+load=info to see the origin of the problem class");
1639 }
1640
1641 //fetch the field at the offset we've found
1642 int dest_offset = fd.offset();
1643
1644 return dest_offset;
1645 }
1646
1647
1648 const char* WhiteBox::lookup_jstring(const char* field_name, oop object) {
1649 int offset = offset_for_field(field_name, object,
1650 vmSymbols::string_signature());
1651 oop string = object->obj_field(offset);
1652 if (string == NULL) {
1653 return NULL;
1654 }
1655 const char* ret = java_lang_String::as_utf8_string(string);
1656 return ret;
1657 }
1658
1659 bool WhiteBox::lookup_bool(const char* field_name, oop object) {
1660 int offset =
1661 offset_for_field(field_name, object, vmSymbols::bool_signature());
1662 bool ret = (object->bool_field(offset) == JNI_TRUE);
1663 return ret;
1664 }
1665
1666 void WhiteBox::register_methods(JNIEnv* env, jclass wbclass, JavaThread* thread, JNINativeMethod* method_array, int method_count) {
1667 ResourceMark rm;
1668 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
1669
1670 // one by one registration natives for exception catching
1671 jclass no_such_method_error_klass = env->FindClass(vmSymbols::java_lang_NoSuchMethodError()->as_C_string());
1672 CHECK_JNI_EXCEPTION(env);
1673 for (int i = 0, n = method_count; i < n; ++i) {
1674 // Skip dummy entries
1675 if (method_array[i].fnPtr == NULL) continue;
1676 if (env->RegisterNatives(wbclass, &method_array[i], 1) != 0) {
1677 jthrowable throwable_obj = env->ExceptionOccurred();
1678 if (throwable_obj != NULL) {
1679 env->ExceptionClear();
1680 if (env->IsInstanceOf(throwable_obj, no_such_method_error_klass)) {
1681 // NoSuchMethodError is thrown when a method can't be found or a method is not native.
1682 // Ignoring the exception since it is not preventing use of other WhiteBox methods.
1683 tty->print_cr("Warning: 'NoSuchMethodError' on register of sun.hotspot.WhiteBox::%s%s",
1684 method_array[i].name, method_array[i].signature);
1685 }
1686 } else {
1687 // Registration failed unexpectedly.
1688 tty->print_cr("Warning: unexpected error on register of sun.hotspot.WhiteBox::%s%s. All methods will be unregistered",
1689 method_array[i].name, method_array[i].signature);
1690 env->UnregisterNatives(wbclass);
1691 break;
1692 }
1693 }
1694 }
1695 }
1696
1697 WB_ENTRY(jint, WB_AddCompilerDirective(JNIEnv* env, jobject o, jstring compDirect))
1698 // can't be in VM when we call JNI
1699 ThreadToNativeFromVM ttnfv(thread);
1700 const char* dir = env->GetStringUTFChars(compDirect, NULL);
1701 CHECK_JNI_EXCEPTION_(env, 0);
1702 int ret;
1703 {
1704 ThreadInVMfromNative ttvfn(thread); // back to VM
1705 ret = DirectivesParser::parse_string(dir, tty);
1706 }
1707 env->ReleaseStringUTFChars(compDirect, dir);
1708 // -1 for error parsing directive. Return 0 as number of directives added.
1709 if (ret == -1) {
1710 ret = 0;
1711 }
1712 return (jint) ret;
1713 WB_END
1714
1715 WB_ENTRY(void, WB_RemoveCompilerDirective(JNIEnv* env, jobject o, jint count))
1716 DirectivesStack::pop(count);
1717 WB_END
1718
1719 #define CC (char*)
1720
1721 static JNINativeMethod methods[] = {
1722 {CC"getObjectAddress0", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectAddress },
1723 {CC"getObjectSize0", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectSize },
1724 {CC"isObjectInOldGen0", CC"(Ljava/lang/Object;)Z", (void*)&WB_isObjectInOldGen },
1725 {CC"getHeapOopSize", CC"()I", (void*)&WB_GetHeapOopSize },
1726 {CC"getVMPageSize", CC"()I", (void*)&WB_GetVMPageSize },
1727 {CC"getVMAllocationGranularity", CC"()J", (void*)&WB_GetVMAllocationGranularity },
1728 {CC"getVMLargePageSize", CC"()J", (void*)&WB_GetVMLargePageSize},
1729 {CC"getHeapSpaceAlignment", CC"()J", (void*)&WB_GetHeapSpaceAlignment},
1730 {CC"getHeapAlignment", CC"()J", (void*)&WB_GetHeapAlignment},
1731 {CC"isClassAlive0", CC"(Ljava/lang/String;)Z", (void*)&WB_IsClassAlive },
1732 {CC"parseCommandLine0",
1733 CC"(Ljava/lang/String;C[Lsun/hotspot/parser/DiagnosticCommand;)[Ljava/lang/Object;",
1734 (void*) &WB_ParseCommandLine
1735 },
1736 {CC"addToBootstrapClassLoaderSearch0", CC"(Ljava/lang/String;)V",
1737 (void*)&WB_AddToBootstrapClassLoaderSearch},
1738 {CC"addToSystemClassLoaderSearch0", CC"(Ljava/lang/String;)V",
1739 (void*)&WB_AddToSystemClassLoaderSearch},
1740 {CC"getCompressedOopsMaxHeapSize", CC"()J",
1741 (void*)&WB_GetCompressedOopsMaxHeapSize},
1742 {CC"printHeapSizes", CC"()V", (void*)&WB_PrintHeapSizes },
1743 {CC"runMemoryUnitTests", CC"()V", (void*)&WB_RunMemoryUnitTests},
1744 {CC"readFromNoaccessArea",CC"()V", (void*)&WB_ReadFromNoaccessArea},
1745 {CC"stressVirtualSpaceResize",CC"(JJJ)I", (void*)&WB_StressVirtualSpaceResize},
1746 #if INCLUDE_ALL_GCS
1747 {CC"g1InConcurrentMark", CC"()Z", (void*)&WB_G1InConcurrentMark},
1748 {CC"g1IsHumongous0", CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous },
1749 {CC"g1BelongsToHumongousRegion0", CC"(J)Z", (void*)&WB_G1BelongsToHumongousRegion},
1750 {CC"g1BelongsToFreeRegion0", CC"(J)Z", (void*)&WB_G1BelongsToFreeRegion},
1751 {CC"g1NumMaxRegions", CC"()J", (void*)&WB_G1NumMaxRegions },
1752 {CC"g1NumFreeRegions", CC"()J", (void*)&WB_G1NumFreeRegions },
1753 {CC"g1RegionSize", CC"()I", (void*)&WB_G1RegionSize },
1754 {CC"g1StartConcMarkCycle", CC"()Z", (void*)&WB_G1StartMarkCycle },
1755 {CC"g1AuxiliaryMemoryUsage", CC"()Ljava/lang/management/MemoryUsage;",
1756 (void*)&WB_G1AuxiliaryMemoryUsage },
1757 {CC"psVirtualSpaceAlignment",CC"()J", (void*)&WB_PSVirtualSpaceAlignment},
1758 {CC"psHeapGenerationAlignment",CC"()J", (void*)&WB_PSHeapGenerationAlignment},
1759 {CC"g1GetMixedGCInfo", CC"(I)[J", (void*)&WB_G1GetMixedGCInfo },
1760 #endif // INCLUDE_ALL_GCS
1761 #if INCLUDE_NMT
1762 {CC"NMTMalloc", CC"(J)J", (void*)&WB_NMTMalloc },
1763 {CC"NMTMallocWithPseudoStack", CC"(JI)J", (void*)&WB_NMTMallocWithPseudoStack},
1764 {CC"NMTFree", CC"(J)V", (void*)&WB_NMTFree },
1765 {CC"NMTReserveMemory", CC"(J)J", (void*)&WB_NMTReserveMemory },
1766 {CC"NMTCommitMemory", CC"(JJ)V", (void*)&WB_NMTCommitMemory },
1767 {CC"NMTUncommitMemory", CC"(JJ)V", (void*)&WB_NMTUncommitMemory },
1768 {CC"NMTReleaseMemory", CC"(JJ)V", (void*)&WB_NMTReleaseMemory },
1769 {CC"NMTChangeTrackingLevel", CC"()Z", (void*)&WB_NMTChangeTrackingLevel},
1770 {CC"NMTGetHashSize", CC"()I", (void*)&WB_NMTGetHashSize },
1771 #endif // INCLUDE_NMT
1772 {CC"deoptimizeFrames", CC"(Z)I", (void*)&WB_DeoptimizeFrames },
1773 {CC"deoptimizeAll", CC"()V", (void*)&WB_DeoptimizeAll },
1774 {CC"deoptimizeMethod0", CC"(Ljava/lang/reflect/Executable;Z)I",
1775 (void*)&WB_DeoptimizeMethod },
1776 {CC"isMethodCompiled0", CC"(Ljava/lang/reflect/Executable;Z)Z",
1777 (void*)&WB_IsMethodCompiled },
1778 {CC"isMethodCompilable0", CC"(Ljava/lang/reflect/Executable;IZ)Z",
1779 (void*)&WB_IsMethodCompilable},
1780 {CC"isMethodQueuedForCompilation0",
1781 CC"(Ljava/lang/reflect/Executable;)Z", (void*)&WB_IsMethodQueuedForCompilation},
1782 {CC"isIntrinsicAvailable0",
1783 CC"(Ljava/lang/reflect/Executable;Ljava/lang/reflect/Executable;I)Z",
1784 (void*)&WB_IsIntrinsicAvailable},
1785 {CC"makeMethodNotCompilable0",
1786 CC"(Ljava/lang/reflect/Executable;IZ)V", (void*)&WB_MakeMethodNotCompilable},
1787 {CC"testSetDontInlineMethod0",
1788 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetDontInlineMethod},
1789 {CC"getMethodCompilationLevel0",
1790 CC"(Ljava/lang/reflect/Executable;Z)I", (void*)&WB_GetMethodCompilationLevel},
1791 {CC"getMethodEntryBci0",
1792 CC"(Ljava/lang/reflect/Executable;)I", (void*)&WB_GetMethodEntryBci},
1793 {CC"getCompileQueueSize",
1794 CC"(I)I", (void*)&WB_GetCompileQueueSize},
1795 {CC"testSetForceInlineMethod0",
1796 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetForceInlineMethod},
1797 {CC"enqueueMethodForCompilation0",
1798 CC"(Ljava/lang/reflect/Executable;II)Z", (void*)&WB_EnqueueMethodForCompilation},
1799 {CC"enqueueInitializerForCompilation0",
1800 CC"(Ljava/lang/Class;I)Z", (void*)&WB_EnqueueInitializerForCompilation},
1801 {CC"clearMethodState0",
1802 CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_ClearMethodState},
1803 {CC"lockCompilation", CC"()V", (void*)&WB_LockCompilation},
1804 {CC"unlockCompilation", CC"()V", (void*)&WB_UnlockCompilation},
1805 {CC"matchesMethod",
1806 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)I",
1807 (void*)&WB_MatchesMethod},
1808 {CC"matchesInline",
1809 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)I",
1810 (void*)&WB_MatchesInline},
1811 {CC"shouldPrintAssembly",
1812 CC"(Ljava/lang/reflect/Executable;I)Z",
1813 (void*)&WB_ShouldPrintAssembly},
1814
1815 {CC"isConstantVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsConstantVMFlag},
1816 {CC"isLockedVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsLockedVMFlag},
1817 {CC"setBooleanVMFlag", CC"(Ljava/lang/String;Z)V",(void*)&WB_SetBooleanVMFlag},
1818 {CC"setIntVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntVMFlag},
1819 {CC"setUintVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintVMFlag},
1820 {CC"setIntxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag},
1821 {CC"setUintxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag},
1822 {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
1823 {CC"setSizeTVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetSizeTVMFlag},
1824 {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag},
1825 {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V",
1826 (void*)&WB_SetStringVMFlag},
1827 {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
1828 (void*)&WB_GetBooleanVMFlag},
1829 {CC"getIntVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1830 (void*)&WB_GetIntVMFlag},
1831 {CC"getUintVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1832 (void*)&WB_GetUintVMFlag},
1833 {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1834 (void*)&WB_GetIntxVMFlag},
1835 {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1836 (void*)&WB_GetUintxVMFlag},
1837 {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1838 (void*)&WB_GetUint64VMFlag},
1839 {CC"getSizeTVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1840 (void*)&WB_GetSizeTVMFlag},
1841 {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;",
1842 (void*)&WB_GetDoubleVMFlag},
1843 {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;",
1844 (void*)&WB_GetStringVMFlag},
1845 {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
1846 {CC"fullGC", CC"()V", (void*)&WB_FullGC },
1847 {CC"youngGC", CC"()V", (void*)&WB_YoungGC },
1848 {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
1849 {CC"allocateMetaspace",
1850 CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
1851 {CC"freeMetaspace",
1852 CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
1853 {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
1854 {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
1855 {CC"metaspaceShouldConcurrentCollect", CC"()Z", (void*)&WB_MetaspaceShouldConcurrentCollect },
1856 {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
1857 {CC"getNMethod0", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
1858 (void*)&WB_GetNMethod },
1859 {CC"forceNMethodSweep", CC"()V", (void*)&WB_ForceNMethodSweep },
1860 {CC"allocateCodeBlob", CC"(II)J", (void*)&WB_AllocateCodeBlob },
1861 {CC"freeCodeBlob", CC"(J)V", (void*)&WB_FreeCodeBlob },
1862 {CC"getCodeHeapEntries", CC"(I)[Ljava/lang/Object;",(void*)&WB_GetCodeHeapEntries },
1863 {CC"getCompilationActivityMode",
1864 CC"()I", (void*)&WB_GetCompilationActivityMode},
1865 {CC"getMethodData0", CC"(Ljava/lang/reflect/Executable;)J",
1866 (void*)&WB_GetMethodData },
1867 {CC"getCodeBlob", CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob },
1868 {CC"getThreadStackSize", CC"()J", (void*)&WB_GetThreadStackSize },
1869 {CC"getThreadRemainingStackSize", CC"()J", (void*)&WB_GetThreadRemainingStackSize },
1870 {CC"DefineModule", CC"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
1871 (void*)&WB_DefineModule },
1872 {CC"AddModuleExports", CC"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V",
1873 (void*)&WB_AddModuleExports },
1874 {CC"AddReadsModule", CC"(Ljava/lang/Object;Ljava/lang/Object;)V",
1875 (void*)&WB_AddReadsModule },
1876 {CC"AddModulePackage", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
1877 (void*)&WB_AddModulePackage },
1878 {CC"GetModuleByPackageName", CC"(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;",
1879 (void*)&WB_GetModuleByPackageName },
1880 {CC"AddModuleExportsToAllUnnamed", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
1881 (void*)&WB_AddModuleExportsToAllUnnamed },
1882 {CC"AddModuleExportsToAll", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
1883 (void*)&WB_AddModuleExportsToAll },
1884 {CC"assertMatchingSafepointCalls", CC"(ZZ)V", (void*)&WB_AssertMatchingSafepointCalls },
1885 {CC"isMonitorInflated0", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated },
1886 {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint },
1887 {CC"getConstantPool0", CC"(Ljava/lang/Class;)J", (void*)&WB_GetConstantPool },
1888 {CC"getConstantPoolCacheIndexTag0", CC"()I", (void*)&WB_GetConstantPoolCacheIndexTag},
1889 {CC"getConstantPoolCacheLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_GetConstantPoolCacheLength},
1890 {CC"remapInstructionOperandFromCPCache0",
1891 CC"(Ljava/lang/Class;I)I", (void*)&WB_ConstantPoolRemapInstructionOperandFromCache},
1892 {CC"encodeConstantPoolIndyIndex0",
1893 CC"(I)I", (void*)&WB_ConstantPoolEncodeIndyIndex},
1894 {CC"getMethodBooleanOption",
1895 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Boolean;",
1896 (void*)&WB_GetMethodBooleaneOption},
1897 {CC"getMethodIntxOption",
1898 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
1899 (void*)&WB_GetMethodIntxOption},
1900 {CC"getMethodUintxOption",
1901 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
1902 (void*)&WB_GetMethodUintxOption},
1903 {CC"getMethodDoubleOption",
1904 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Double;",
1905 (void*)&WB_GetMethodDoubleOption},
1906 {CC"getMethodStringOption",
1907 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/String;",
1908 (void*)&WB_GetMethodStringOption},
1909 {CC"isShared", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsShared },
1910 {CC"isSharedClass", CC"(Ljava/lang/Class;)Z", (void*)&WB_IsSharedClass },
1911 {CC"areSharedStringsIgnored", CC"()Z", (void*)&WB_AreSharedStringsIgnored },
1912 {CC"clearInlineCaches0", CC"(Z)V", (void*)&WB_ClearInlineCaches },
1913 {CC"addCompilerDirective", CC"(Ljava/lang/String;)I",
1914 (void*)&WB_AddCompilerDirective },
1915 {CC"removeCompilerDirective", CC"(I)V", (void*)&WB_RemoveCompilerDirective },
1916 {CC"currentGC", CC"()I", (void*)&WB_CurrentGC},
1917 {CC"allSupportedGC", CC"()I", (void*)&WB_AllSupportedGC},
1918 {CC"gcSelectedByErgo", CC"()Z", (void*)&WB_GCSelectedByErgo},
1919 {CC"supportsConcurrentGCPhaseControl", CC"()Z", (void*)&WB_SupportsConcurrentGCPhaseControl},
1920 {CC"requestConcurrentGCPhase0", CC"(Ljava/lang/String;)Z",
1921 (void*)&WB_RequestConcurrentGCPhase},
1922 };
1923
1924 #undef CC
1925
1926 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
1927 {
1928 if (WhiteBoxAPI) {
1929 // Make sure that wbclass is loaded by the null classloader
1930 instanceKlassHandle ikh = instanceKlassHandle(JNIHandles::resolve(wbclass)->klass());
1931 Handle loader(THREAD, ikh->class_loader());
1932 if (loader.is_null()) {
1933 WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0]));
1934 WhiteBox::register_extended(env, wbclass, thread);
1935 WhiteBox::set_used();
1936 }
1937 }
1938 }
1939 JVM_END