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