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