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 "code/codeCache.hpp"
28 #include "memory/metadataFactory.hpp"
29 #include "memory/universe.hpp"
30 #include "oops/oop.inline.hpp"
31
32 #include "classfile/stringTable.hpp"
33 #include "classfile/classLoaderData.hpp"
34
35 #include "prims/whitebox.hpp"
36 #include "prims/wbtestmethods/parserTests.hpp"
37
38 #include "runtime/thread.hpp"
39 #include "runtime/arguments.hpp"
40 #include "runtime/interfaceSupport.hpp"
41 #include "runtime/os.hpp"
42 #include "runtime/vm_version.hpp"
43
44 #include "utilities/array.hpp"
45 #include "utilities/debug.hpp"
46 #include "utilities/macros.hpp"
47 #include "utilities/exceptions.hpp"
48
49 #if INCLUDE_ALL_GCS
50 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
51 #include "gc_implementation/g1/concurrentMark.hpp"
52 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
53 #include "gc_implementation/g1/heapRegionRemSet.hpp"
54 #endif // INCLUDE_ALL_GCS
55
56 #if INCLUDE_NMT
57 #include "services/mallocSiteTable.hpp"
58 #include "services/memTracker.hpp"
59 #include "utilities/nativeCallStack.hpp"
60 #endif // INCLUDE_NMT
61
62 #include "compiler/compileBroker.hpp"
63 #include "runtime/compilationPolicy.hpp"
64
65 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
66
67 #define SIZE_T_MAX_VALUE ((size_t) -1)
68
69 bool WhiteBox::_used = false;
70
71 WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj))
72 return (jlong)(void*)JNIHandles::resolve(obj);
73 WB_END
74
75 WB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o))
76 return heapOopSize;
77 WB_END
78
79
80 class WBIsKlassAliveClosure : public KlassClosure {
81 Symbol* _name;
82 bool _found;
83 public:
84 WBIsKlassAliveClosure(Symbol* name) : _name(name), _found(false) {}
85
86 void do_klass(Klass* k) {
87 if (_found) return;
88 Symbol* ksym = k->name();
89 if (ksym->fast_compare(_name) == 0) {
291 WB_ENTRY(jlong, WB_NMTMallocWithPseudoStack(JNIEnv* env, jobject o, jlong size, jint pseudo_stack))
292 address pc = (address)(size_t)pseudo_stack;
293 NativeCallStack stack(&pc, 1);
294 return (jlong)os::malloc(size, mtTest, stack);
295 WB_END
296
297 // Free the memory allocated by NMTAllocTest
298 WB_ENTRY(void, WB_NMTFree(JNIEnv* env, jobject o, jlong mem))
299 os::free((void*)(uintptr_t)mem, mtTest);
300 WB_END
301
302 WB_ENTRY(jlong, WB_NMTReserveMemory(JNIEnv* env, jobject o, jlong size))
303 jlong addr = 0;
304
305 addr = (jlong)(uintptr_t)os::reserve_memory(size);
306 MemTracker::record_virtual_memory_type((address)addr, mtTest);
307
308 return addr;
309 WB_END
310
311
312 WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
313 os::commit_memory((char *)(uintptr_t)addr, size, !ExecMem);
314 MemTracker::record_virtual_memory_type((address)(uintptr_t)addr, mtTest);
315 WB_END
316
317 WB_ENTRY(void, WB_NMTUncommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
318 os::uncommit_memory((char *)(uintptr_t)addr, size);
319 WB_END
320
321 WB_ENTRY(void, WB_NMTReleaseMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
322 os::release_memory((char *)(uintptr_t)addr, size);
323 WB_END
324
325 WB_ENTRY(jboolean, WB_NMTIsDetailSupported(JNIEnv* env))
326 return MemTracker::tracking_level() == NMT_detail;
327 WB_END
328
329 WB_ENTRY(void, WB_NMTOverflowHashBucket(JNIEnv* env, jobject o, jlong num))
330 address pc = (address)1;
331 for (jlong index = 0; index < num; index ++) {
714 WB_END
715
716 WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value))
717 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
718 const char* ccstrValue = (value == NULL) ? NULL : env->GetStringUTFChars(value, NULL);
719 ccstr ccstrResult = ccstrValue;
720 bool needFree;
721 {
722 ThreadInVMfromNative ttvfn(thread); // back to VM
723 needFree = SetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAtPut);
724 }
725 if (value != NULL) {
726 env->ReleaseStringUTFChars(value, ccstrValue);
727 }
728 if (needFree) {
729 FREE_C_HEAP_ARRAY(char, ccstrResult, mtInternal);
730 }
731 WB_END
732
733
734 WB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString))
735 ResourceMark rm(THREAD);
736 int len;
737 jchar* name = java_lang_String::as_unicode_string(JNIHandles::resolve(javaString), len, CHECK_false);
738 return (StringTable::lookup(name, len) != NULL);
739 WB_END
740
741 WB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o))
742 Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(true);
743 Universe::heap()->collect(GCCause::_last_ditch_collection);
744 #if INCLUDE_ALL_GCS
745 if (UseG1GC) {
746 // Needs to be cleared explicitly for G1
747 Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(false);
748 }
749 #endif // INCLUDE_ALL_GCS
750 WB_END
751
752 WB_ENTRY(void, WB_YoungGC(JNIEnv* env, jobject o))
753 Universe::heap()->collect(GCCause::_wb_young_gc);
760 static volatile char* p;
761
762 p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
763 if (p == NULL) {
764 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
765 }
766
767 c = *p;
768 WB_END
769
770 WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
771 const char* cpu_features = VM_Version::cpu_features();
772 ThreadToNativeFromVM ttn(thread);
773 jstring features_string = env->NewStringUTF(cpu_features);
774
775 CHECK_JNI_EXCEPTION_(env, NULL);
776
777 return features_string;
778 WB_END
779
780
781 WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
782 ResourceMark rm(THREAD);
783 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
784 CHECK_JNI_EXCEPTION_(env, NULL);
785 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
786 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
787 jobjectArray result = NULL;
788 if (code == NULL) {
789 return result;
790 }
791 int insts_size = code->insts_size();
792
793 ThreadToNativeFromVM ttn(thread);
794 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
795 CHECK_JNI_EXCEPTION_(env, NULL);
796 result = env->NewObjectArray(3, clazz, NULL);
797 if (result == NULL) {
798 return result;
799 }
800
801 jobject level = integerBox(thread, env, code->comp_level());
802 CHECK_JNI_EXCEPTION_(env, NULL);
803 env->SetObjectArrayElement(result, 0, level);
804
805 jbyteArray insts = env->NewByteArray(insts_size);
806 CHECK_JNI_EXCEPTION_(env, NULL);
807 env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
808 env->SetObjectArrayElement(result, 1, insts);
809
810 jobject id = integerBox(thread, env, code->compile_id());
811 CHECK_JNI_EXCEPTION_(env, NULL);
812 env->SetObjectArrayElement(result, 2, id);
813
814 return result;
815 WB_END
816
817 WB_ENTRY(jlong, WB_GetThreadStackSize(JNIEnv* env, jobject o))
818 return (jlong) Thread::current()->stack_size();
819 WB_END
820
821 WB_ENTRY(jlong, WB_GetThreadRemainingStackSize(JNIEnv* env, jobject o))
822 JavaThread* t = JavaThread::current();
823 return (jlong) t->stack_available(os::current_stack_pointer()) - (jlong) StackShadowPages * os::vm_page_size();
824 WB_END
825
826 int WhiteBox::array_bytes_to_length(size_t bytes) {
827 return Array<u1>::bytes_to_length(bytes);
828 }
829
830 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
831 if (size < 0) {
832 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
833 err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
834 }
835
836 oop class_loader_oop = JNIHandles::resolve(class_loader);
1004 {CC"isMethodCompilable", CC"(Ljava/lang/reflect/Executable;IZ)Z",
1005 (void*)&WB_IsMethodCompilable},
1006 {CC"isMethodQueuedForCompilation",
1007 CC"(Ljava/lang/reflect/Executable;)Z", (void*)&WB_IsMethodQueuedForCompilation},
1008 {CC"makeMethodNotCompilable",
1009 CC"(Ljava/lang/reflect/Executable;IZ)V", (void*)&WB_MakeMethodNotCompilable},
1010 {CC"testSetDontInlineMethod",
1011 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetDontInlineMethod},
1012 {CC"getMethodCompilationLevel",
1013 CC"(Ljava/lang/reflect/Executable;Z)I", (void*)&WB_GetMethodCompilationLevel},
1014 {CC"getMethodEntryBci",
1015 CC"(Ljava/lang/reflect/Executable;)I", (void*)&WB_GetMethodEntryBci},
1016 {CC"getCompileQueueSize",
1017 CC"(I)I", (void*)&WB_GetCompileQueueSize},
1018 {CC"testSetForceInlineMethod",
1019 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetForceInlineMethod},
1020 {CC"enqueueMethodForCompilation",
1021 CC"(Ljava/lang/reflect/Executable;II)Z", (void*)&WB_EnqueueMethodForCompilation},
1022 {CC"clearMethodState",
1023 CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_ClearMethodState},
1024 {CC"isConstantVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsConstantVMFlag},
1025 {CC"isLockedVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsLockedVMFlag},
1026 {CC"setBooleanVMFlag", CC"(Ljava/lang/String;Z)V",(void*)&WB_SetBooleanVMFlag},
1027 {CC"setIntxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag},
1028 {CC"setUintxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag},
1029 {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
1030 {CC"setSizeTVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetSizeTVMFlag},
1031 {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag},
1032 {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V",
1033 (void*)&WB_SetStringVMFlag},
1034 {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
1035 (void*)&WB_GetBooleanVMFlag},
1036 {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1037 (void*)&WB_GetIntxVMFlag},
1038 {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1039 (void*)&WB_GetUintxVMFlag},
1040 {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1041 (void*)&WB_GetUint64VMFlag},
1042 {CC"getSizeTVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1043 (void*)&WB_GetSizeTVMFlag},
1044 {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;",
1045 (void*)&WB_GetDoubleVMFlag},
1046 {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;",
1047 (void*)&WB_GetStringVMFlag},
1048 {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
1049 {CC"fullGC", CC"()V", (void*)&WB_FullGC },
1050 {CC"youngGC", CC"()V", (void*)&WB_YoungGC },
1051 {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
1052 {CC"allocateMetaspace",
1053 CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
1054 {CC"freeMetaspace",
1055 CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
1056 {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
1057 {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
1058 {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
1059 {CC"getNMethod", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
1060 (void*)&WB_GetNMethod },
1061 {CC"getThreadStackSize", CC"()J", (void*)&WB_GetThreadStackSize },
1062 {CC"getThreadRemainingStackSize", CC"()J", (void*)&WB_GetThreadRemainingStackSize },
1063 };
1064
1065 #undef CC
1066
1067 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
1068 {
1069 if (WhiteBoxAPI) {
1070 // Make sure that wbclass is loaded by the null classloader
1071 instanceKlassHandle ikh = instanceKlassHandle(JNIHandles::resolve(wbclass)->klass());
1072 Handle loader(ikh->class_loader());
1073 if (loader.is_null()) {
1074 WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0]));
1075 WhiteBox::register_extended(env, wbclass, thread);
1076 WhiteBox::set_used();
1077 }
1078 }
1079 }
1080 JVM_END
|
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 "code/codeCache.hpp"
28 #include "memory/metadataFactory.hpp"
29 #include "memory/universe.hpp"
30 #include "oops/oop.inline.hpp"
31
32 #include "classfile/stringTable.hpp"
33 #include "classfile/classLoaderData.hpp"
34
35 #include "prims/whitebox.hpp"
36 #include "prims/wbtestmethods/parserTests.hpp"
37
38 #include "runtime/thread.hpp"
39 #include "runtime/arguments.hpp"
40 #include "runtime/deoptimization.hpp"
41 #include "runtime/interfaceSupport.hpp"
42 #include "runtime/os.hpp"
43 #include "runtime/vm_version.hpp"
44 #include "runtime/sweeper.hpp"
45
46 #include "utilities/array.hpp"
47 #include "utilities/debug.hpp"
48 #include "utilities/macros.hpp"
49 #include "utilities/exceptions.hpp"
50
51 #if INCLUDE_ALL_GCS
52 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
53 #include "gc_implementation/g1/concurrentMark.hpp"
54 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
55 #include "gc_implementation/g1/heapRegionRemSet.hpp"
56 #endif // INCLUDE_ALL_GCS
57
58 #if INCLUDE_NMT
59 #include "services/mallocSiteTable.hpp"
60 #include "services/memTracker.hpp"
61 #include "utilities/nativeCallStack.hpp"
62 #endif // INCLUDE_NMT
63
64 #include "compiler/compileBroker.hpp"
65 #include "runtime/compilationPolicy.hpp"
66
67 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
68
69 #define SIZE_T_MAX_VALUE ((size_t) -1)
70
71 bool WhiteBox::_used = false;
72 volatile bool WhiteBox::compilation_locked = false;
73
74 WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj))
75 return (jlong)(void*)JNIHandles::resolve(obj);
76 WB_END
77
78 WB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o))
79 return heapOopSize;
80 WB_END
81
82
83 class WBIsKlassAliveClosure : public KlassClosure {
84 Symbol* _name;
85 bool _found;
86 public:
87 WBIsKlassAliveClosure(Symbol* name) : _name(name), _found(false) {}
88
89 void do_klass(Klass* k) {
90 if (_found) return;
91 Symbol* ksym = k->name();
92 if (ksym->fast_compare(_name) == 0) {
294 WB_ENTRY(jlong, WB_NMTMallocWithPseudoStack(JNIEnv* env, jobject o, jlong size, jint pseudo_stack))
295 address pc = (address)(size_t)pseudo_stack;
296 NativeCallStack stack(&pc, 1);
297 return (jlong)os::malloc(size, mtTest, stack);
298 WB_END
299
300 // Free the memory allocated by NMTAllocTest
301 WB_ENTRY(void, WB_NMTFree(JNIEnv* env, jobject o, jlong mem))
302 os::free((void*)(uintptr_t)mem, mtTest);
303 WB_END
304
305 WB_ENTRY(jlong, WB_NMTReserveMemory(JNIEnv* env, jobject o, jlong size))
306 jlong addr = 0;
307
308 addr = (jlong)(uintptr_t)os::reserve_memory(size);
309 MemTracker::record_virtual_memory_type((address)addr, mtTest);
310
311 return addr;
312 WB_END
313
314 WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
315 os::commit_memory((char *)(uintptr_t)addr, size, !ExecMem);
316 MemTracker::record_virtual_memory_type((address)(uintptr_t)addr, mtTest);
317 WB_END
318
319 WB_ENTRY(void, WB_NMTUncommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
320 os::uncommit_memory((char *)(uintptr_t)addr, size);
321 WB_END
322
323 WB_ENTRY(void, WB_NMTReleaseMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
324 os::release_memory((char *)(uintptr_t)addr, size);
325 WB_END
326
327 WB_ENTRY(jboolean, WB_NMTIsDetailSupported(JNIEnv* env))
328 return MemTracker::tracking_level() == NMT_detail;
329 WB_END
330
331 WB_ENTRY(void, WB_NMTOverflowHashBucket(JNIEnv* env, jobject o, jlong num))
332 address pc = (address)1;
333 for (jlong index = 0; index < num; index ++) {
716 WB_END
717
718 WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value))
719 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
720 const char* ccstrValue = (value == NULL) ? NULL : env->GetStringUTFChars(value, NULL);
721 ccstr ccstrResult = ccstrValue;
722 bool needFree;
723 {
724 ThreadInVMfromNative ttvfn(thread); // back to VM
725 needFree = SetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAtPut);
726 }
727 if (value != NULL) {
728 env->ReleaseStringUTFChars(value, ccstrValue);
729 }
730 if (needFree) {
731 FREE_C_HEAP_ARRAY(char, ccstrResult, mtInternal);
732 }
733 WB_END
734
735
736 WB_ENTRY(void, WB_LockCompilation(JNIEnv* env, jobject o, jlong timeout))
737 WhiteBox::compilation_locked = true;
738 WB_END
739
740 WB_ENTRY(void, WB_UnlockCompilation(JNIEnv* env, jobject o))
741 MonitorLockerEx mo(Compilation_lock, Mutex::_no_safepoint_check_flag);
742 WhiteBox::compilation_locked = false;
743 mo.notify_all();
744 WB_END
745
746 void WhiteBox::force_sweep() {
747 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to enabled");
748 {
749 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
750 NMethodSweeper::_should_sweep = true;
751 }
752 NMethodSweeper::possibly_sweep();
753 }
754
755 WB_ENTRY(void, WB_ForceNMethodSweep(JNIEnv* env, jobject o))
756 WhiteBox::force_sweep();
757 WB_END
758
759 WB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString))
760 ResourceMark rm(THREAD);
761 int len;
762 jchar* name = java_lang_String::as_unicode_string(JNIHandles::resolve(javaString), len, CHECK_false);
763 return (StringTable::lookup(name, len) != NULL);
764 WB_END
765
766 WB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o))
767 Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(true);
768 Universe::heap()->collect(GCCause::_last_ditch_collection);
769 #if INCLUDE_ALL_GCS
770 if (UseG1GC) {
771 // Needs to be cleared explicitly for G1
772 Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(false);
773 }
774 #endif // INCLUDE_ALL_GCS
775 WB_END
776
777 WB_ENTRY(void, WB_YoungGC(JNIEnv* env, jobject o))
778 Universe::heap()->collect(GCCause::_wb_young_gc);
785 static volatile char* p;
786
787 p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
788 if (p == NULL) {
789 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
790 }
791
792 c = *p;
793 WB_END
794
795 WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
796 const char* cpu_features = VM_Version::cpu_features();
797 ThreadToNativeFromVM ttn(thread);
798 jstring features_string = env->NewStringUTF(cpu_features);
799
800 CHECK_JNI_EXCEPTION_(env, NULL);
801
802 return features_string;
803 WB_END
804
805 int WhiteBox::get_blob_type(const CodeBlob* code) {
806 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to enabled");
807 return CodeCache::get_code_heap(code)->code_blob_type();
808 }
809
810 CodeHeap* WhiteBox::get_code_heap(int blob_type) {
811 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to enabled");
812 return CodeCache::get_code_heap(blob_type);
813 }
814
815 static jobjectArray codeBlob2objectArray(JavaThread* thread, JNIEnv* env, CodeBlob* cb) {
816 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
817 CHECK_JNI_EXCEPTION_(env, NULL);
818 jobjectArray result = env->NewObjectArray(3, clazz, NULL);
819
820 jstring name = env->NewStringUTF(cb->name());
821 CHECK_JNI_EXCEPTION_(env, NULL);
822 env->SetObjectArrayElement(result, 0, name);
823
824 jobject obj = integerBox(thread, env, cb->size());
825 CHECK_JNI_EXCEPTION_(env, NULL);
826 env->SetObjectArrayElement(result, 1, obj);
827
828 obj = integerBox(thread, env, WhiteBox::get_blob_type(cb));
829 CHECK_JNI_EXCEPTION_(env, NULL);
830 env->SetObjectArrayElement(result, 2, obj);
831
832 return result;
833 }
834
835 WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
836 ResourceMark rm(THREAD);
837 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
838 CHECK_JNI_EXCEPTION_(env, NULL);
839 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
840 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
841 jobjectArray result = NULL;
842 if (code == NULL) {
843 return result;
844 }
845 int insts_size = code->insts_size();
846
847 ThreadToNativeFromVM ttn(thread);
848 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
849 CHECK_JNI_EXCEPTION_(env, NULL);
850 result = env->NewObjectArray(4, clazz, NULL);
851 if (result == NULL) {
852 return result;
853 }
854
855 jobjectArray codeBlob = codeBlob2objectArray(thread, env, code);
856 env->SetObjectArrayElement(result, 0, codeBlob);
857
858 jobject level = integerBox(thread, env, code->comp_level());
859 CHECK_JNI_EXCEPTION_(env, NULL);
860 env->SetObjectArrayElement(result, 1, level);
861
862 jbyteArray insts = env->NewByteArray(insts_size);
863 CHECK_JNI_EXCEPTION_(env, NULL);
864 env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
865 env->SetObjectArrayElement(result, 2, insts);
866
867 jobject id = integerBox(thread, env, code->compile_id());
868 CHECK_JNI_EXCEPTION_(env, NULL);
869 env->SetObjectArrayElement(result, 3, id);
870
871 return result;
872 WB_END
873
874 CodeBlob* WhiteBox::allocateCodeHeap(int size, int blob_type) {
875 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to enabled");
876 BufferBlob* blob;
877 int full_size = CodeBlob::align_code_offset(sizeof(BufferBlob));
878 if (full_size < size) {
879 full_size += round_to(size - full_size, oopSize);
880 }
881 {
882 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
883 blob = (BufferBlob*) CodeCache::allocate(full_size, blob_type);
884 }
885 // Track memory usage statistic after releasing CodeCache_lock
886 MemoryService::track_code_cache_memory_usage();
887 new (blob) BufferBlob("WB::DummyBlob", full_size);
888 return blob;
889 }
890
891 WB_ENTRY(jlong, WB_AllocateCodeHeap(JNIEnv* env, jobject o, jint size, jint blob_type))
892 return (jlong) WhiteBox::allocateCodeHeap(size, blob_type);
893 WB_END
894
895 WB_ENTRY(void, WB_FreeCodeHeap(JNIEnv* env, jobject o, jlong addr))
896 BufferBlob::free((BufferBlob*) addr);
897 WB_END
898
899 WB_ENTRY(jobjectArray, WB_GetCodeHeapEntries(JNIEnv* env, jobject o, jint blob_type))
900 ResourceMark rm;
901 GrowableArray<CodeBlob*> blobs;
902 {
903 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
904 CodeHeap* heap = WhiteBox::get_code_heap(blob_type);
905 if (heap == NULL) {
906 return NULL;
907 }
908 for (CodeBlob* cb = (CodeBlob*) heap->first();
909 cb != NULL; cb = (CodeBlob*) heap->next(cb)) {
910 blobs.append(cb);
911 }
912 }
913 ThreadToNativeFromVM ttn(thread);
914 jobjectArray result = NULL;
915 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
916 CHECK_JNI_EXCEPTION_(env, NULL);
917 result = env->NewObjectArray(blobs.length(), clazz, NULL);
918 if (result == NULL) {
919 return result;
920 }
921 int i = 0;
922 for (GrowableArrayIterator<CodeBlob*> it = blobs.begin();
923 it != blobs.end(); ++it) {
924 jobjectArray obj = codeBlob2objectArray(thread, env, *it);
925 env->SetObjectArrayElement(result, i, obj);
926 ++i;
927 }
928 return result;
929 WB_END
930
931 WB_ENTRY(jlong, WB_GetThreadStackSize(JNIEnv* env, jobject o))
932 return (jlong) Thread::current()->stack_size();
933 WB_END
934
935 WB_ENTRY(jlong, WB_GetThreadRemainingStackSize(JNIEnv* env, jobject o))
936 JavaThread* t = JavaThread::current();
937 return (jlong) t->stack_available(os::current_stack_pointer()) - (jlong) StackShadowPages * os::vm_page_size();
938 WB_END
939
940 int WhiteBox::array_bytes_to_length(size_t bytes) {
941 return Array<u1>::bytes_to_length(bytes);
942 }
943
944 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
945 if (size < 0) {
946 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
947 err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
948 }
949
950 oop class_loader_oop = JNIHandles::resolve(class_loader);
1118 {CC"isMethodCompilable", CC"(Ljava/lang/reflect/Executable;IZ)Z",
1119 (void*)&WB_IsMethodCompilable},
1120 {CC"isMethodQueuedForCompilation",
1121 CC"(Ljava/lang/reflect/Executable;)Z", (void*)&WB_IsMethodQueuedForCompilation},
1122 {CC"makeMethodNotCompilable",
1123 CC"(Ljava/lang/reflect/Executable;IZ)V", (void*)&WB_MakeMethodNotCompilable},
1124 {CC"testSetDontInlineMethod",
1125 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetDontInlineMethod},
1126 {CC"getMethodCompilationLevel",
1127 CC"(Ljava/lang/reflect/Executable;Z)I", (void*)&WB_GetMethodCompilationLevel},
1128 {CC"getMethodEntryBci",
1129 CC"(Ljava/lang/reflect/Executable;)I", (void*)&WB_GetMethodEntryBci},
1130 {CC"getCompileQueueSize",
1131 CC"(I)I", (void*)&WB_GetCompileQueueSize},
1132 {CC"testSetForceInlineMethod",
1133 CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetForceInlineMethod},
1134 {CC"enqueueMethodForCompilation",
1135 CC"(Ljava/lang/reflect/Executable;II)Z", (void*)&WB_EnqueueMethodForCompilation},
1136 {CC"clearMethodState",
1137 CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_ClearMethodState},
1138 {CC"lockCompilation", CC"()V", (void*)&WB_LockCompilation},
1139 {CC"unlockCompilation", CC"()V", (void*)&WB_UnlockCompilation},
1140 {CC"isConstantVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsConstantVMFlag},
1141 {CC"isLockedVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsLockedVMFlag},
1142 {CC"setBooleanVMFlag", CC"(Ljava/lang/String;Z)V",(void*)&WB_SetBooleanVMFlag},
1143 {CC"setIntxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag},
1144 {CC"setUintxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag},
1145 {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
1146 {CC"setSizeTVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetSizeTVMFlag},
1147 {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag},
1148 {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V",
1149 (void*)&WB_SetStringVMFlag},
1150 {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
1151 (void*)&WB_GetBooleanVMFlag},
1152 {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1153 (void*)&WB_GetIntxVMFlag},
1154 {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1155 (void*)&WB_GetUintxVMFlag},
1156 {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1157 (void*)&WB_GetUint64VMFlag},
1158 {CC"getSizeTVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1159 (void*)&WB_GetSizeTVMFlag},
1160 {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;",
1161 (void*)&WB_GetDoubleVMFlag},
1162 {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;",
1163 (void*)&WB_GetStringVMFlag},
1164 {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
1165 {CC"fullGC", CC"()V", (void*)&WB_FullGC },
1166 {CC"youngGC", CC"()V", (void*)&WB_YoungGC },
1167 {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
1168 {CC"allocateMetaspace",
1169 CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
1170 {CC"freeMetaspace",
1171 CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
1172 {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
1173 {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
1174 {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
1175 {CC"getNMethod", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
1176 (void*)&WB_GetNMethod },
1177 {CC"forceNMethodSweep", CC"()V", (void*)&WB_ForceNMethodSweep },
1178 {CC"allocateCodeHeap", CC"(II)J", (void*)&WB_AllocateCodeHeap },
1179 {CC"freeCodeHeap", CC"(J)V", (void*)&WB_FreeCodeHeap },
1180 {CC"getCodeHeapEntries", CC"(I)[Ljava/lang/Object;",(void*)&WB_GetCodeHeapEntries },
1181 {CC"getThreadStackSize", CC"()J", (void*)&WB_GetThreadStackSize },
1182 {CC"getThreadRemainingStackSize", CC"()J", (void*)&WB_GetThreadRemainingStackSize },
1183 };
1184
1185 #undef CC
1186
1187 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
1188 {
1189 if (WhiteBoxAPI) {
1190 // Make sure that wbclass is loaded by the null classloader
1191 instanceKlassHandle ikh = instanceKlassHandle(JNIHandles::resolve(wbclass)->klass());
1192 Handle loader(ikh->class_loader());
1193 if (loader.is_null()) {
1194 WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0]));
1195 WhiteBox::register_extended(env, wbclass, thread);
1196 WhiteBox::set_used();
1197 }
1198 }
1199 }
1200 JVM_END
|