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