23 */
24
25 #include "precompiled.hpp"
26
27 #include "memory/metadataFactory.hpp"
28 #include "memory/metaspaceShared.hpp"
29 #include "memory/iterator.hpp"
30 #include "memory/universe.hpp"
31 #include "oops/oop.inline.hpp"
32
33 #include "classfile/symbolTable.hpp"
34 #include "classfile/classLoaderData.hpp"
35
36 #include "prims/whitebox.hpp"
37 #include "prims/wbtestmethods/parserTests.hpp"
38
39 #include "runtime/arguments.hpp"
40 #include "runtime/interfaceSupport.hpp"
41 #include "runtime/os.hpp"
42 #include "utilities/array.hpp"
43 #include "utilities/debug.hpp"
44 #include "utilities/macros.hpp"
45 #include "utilities/exceptions.hpp"
46
47 #if INCLUDE_ALL_GCS
48 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
49 #include "gc_implementation/g1/concurrentMark.hpp"
50 #include "gc_implementation/g1/concurrentMarkThread.hpp"
51 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
52 #include "gc_implementation/g1/heapRegionRemSet.hpp"
53 #endif // INCLUDE_ALL_GCS
54
55 #if INCLUDE_NMT
56 #include "services/mallocSiteTable.hpp"
57 #include "services/memTracker.hpp"
58 #include "utilities/nativeCallStack.hpp"
59 #endif // INCLUDE_NMT
60
61 #include "compiler/compileBroker.hpp"
62 #include "jvmtifiles/jvmtiEnv.hpp"
636 WB_ENTRY(void, WB_MarkMethodProfiled(JNIEnv* env, jobject o, jobject method))
637 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
638 CHECK_JNI_EXCEPTION(env);
639 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
640
641 MethodData* mdo = mh->method_data();
642 if (mdo == NULL) {
643 Method::build_interpreter_method_data(mh, CHECK_AND_CLEAR);
644 mdo = mh->method_data();
645 }
646 mdo->init();
647 InvocationCounter* icnt = mdo->invocation_counter();
648 InvocationCounter* bcnt = mdo->backedge_counter();
649 // set i-counter according to AdvancedThresholdPolicy::is_method_profiled
650 // because SimpleThresholdPolicy::call_predicate_helper uses > in jdk8u, that's why we need to plus one.
651 icnt->set(InvocationCounter::wait_for_compile, Tier4MinInvocationThreshold + 1);
652 bcnt->set(InvocationCounter::wait_for_compile, Tier4CompileThreshold + 1);
653 WB_END
654
655 template <typename T>
656 static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAt)(const char*, T*)) {
657 if (name == NULL) {
658 return false;
659 }
660 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
661 const char* flag_name = env->GetStringUTFChars(name, NULL);
662 bool result = (*TAt)(flag_name, value);
663 env->ReleaseStringUTFChars(name, flag_name);
664 return result;
665 }
666
667 template <typename T>
668 static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAtPut)(const char*, T*, Flag::Flags)) {
669 if (name == NULL) {
670 return false;
671 }
672 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
673 const char* flag_name = env->GetStringUTFChars(name, NULL);
674 bool result = (*TAtPut)(flag_name, value, Flag::INTERNAL);
675 env->ReleaseStringUTFChars(name, flag_name);
676 return result;
677 }
678
679 template <typename T>
680 static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {
681 ResourceMark rm(thread);
682 jclass clazz = env->FindClass(name->as_C_string());
834 static volatile char* p;
835
836 p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
837 if (p == NULL) {
838 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
839 }
840
841 c = *p;
842 WB_END
843
844 WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
845 const char* cpu_features = VM_Version::cpu_features();
846 ThreadToNativeFromVM ttn(thread);
847 jstring features_string = env->NewStringUTF(cpu_features);
848
849 CHECK_JNI_EXCEPTION_(env, NULL);
850
851 return features_string;
852 WB_END
853
854
855 WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
856 ResourceMark rm(THREAD);
857 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
858 CHECK_JNI_EXCEPTION_(env, NULL);
859 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
860 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
861 jobjectArray result = NULL;
862 if (code == NULL) {
863 return result;
864 }
865 int insts_size = code->insts_size();
866
867 ThreadToNativeFromVM ttn(thread);
868 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
869 CHECK_JNI_EXCEPTION_(env, NULL);
870 result = env->NewObjectArray(3, clazz, NULL);
871 if (result == NULL) {
872 return result;
873 }
874
875 jobject level = integerBox(thread, env, code->comp_level());
876 CHECK_JNI_EXCEPTION_(env, NULL);
877 env->SetObjectArrayElement(result, 0, level);
878
879 jobject id = integerBox(thread, env, code->compile_id());
880 CHECK_JNI_EXCEPTION_(env, NULL);
881 env->SetObjectArrayElement(result, 1, id);
882
883 jbyteArray insts = env->NewByteArray(insts_size);
884 CHECK_JNI_EXCEPTION_(env, NULL);
885 env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
886 env->SetObjectArrayElement(result, 2, insts);
887
888 return result;
889 WB_END
890
891
892 int WhiteBox::array_bytes_to_length(size_t bytes) {
893 return Array<u1>::bytes_to_length(bytes);
894 }
895
896 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
897 if (size < 0) {
898 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
899 err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
900 }
901
902 oop class_loader_oop = JNIHandles::resolve(class_loader);
903 ClassLoaderData* cld = class_loader_oop != NULL
904 ? java_lang_ClassLoader::loader_data(class_loader_oop)
905 : ClassLoaderData::the_null_class_loader_data();
906
907 void* metadata = MetadataFactory::new_writeable_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread);
908
909 return (jlong)(uintptr_t)metadata;
910 WB_END
1150 {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
1151 {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag},
1152 {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V",
1153 (void*)&WB_SetStringVMFlag},
1154 {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
1155 (void*)&WB_GetBooleanVMFlag},
1156 {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1157 (void*)&WB_GetIntxVMFlag},
1158 {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1159 (void*)&WB_GetUintxVMFlag},
1160 {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1161 (void*)&WB_GetUint64VMFlag},
1162 {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;",
1163 (void*)&WB_GetDoubleVMFlag},
1164 {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;",
1165 (void*)&WB_GetStringVMFlag},
1166 {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
1167 {CC"fullGC", CC"()V", (void*)&WB_FullGC },
1168 {CC"youngGC", CC"()V", (void*)&WB_YoungGC },
1169 {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
1170 {CC"allocateMetaspace",
1171 CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
1172 {CC"freeMetaspace",
1173 CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
1174 {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
1175 {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
1176 {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
1177 {CC"getNMethod", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
1178 (void*)&WB_GetNMethod },
1179 {CC"isMonitorInflated", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated },
1180 {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint },
1181 {CC"checkLibSpecifiesNoexecstack", CC"(Ljava/lang/String;)Z",
1182 (void*)&WB_CheckLibSpecifiesNoexecstack},
1183 {CC"isContainerized", CC"()Z", (void*)&WB_IsContainerized },
1184 {CC"printOsInfo", CC"()V", (void*)&WB_PrintOsInfo },
1185 };
1186
1187 #undef CC
1188
1189 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
|
23 */
24
25 #include "precompiled.hpp"
26
27 #include "memory/metadataFactory.hpp"
28 #include "memory/metaspaceShared.hpp"
29 #include "memory/iterator.hpp"
30 #include "memory/universe.hpp"
31 #include "oops/oop.inline.hpp"
32
33 #include "classfile/symbolTable.hpp"
34 #include "classfile/classLoaderData.hpp"
35
36 #include "prims/whitebox.hpp"
37 #include "prims/wbtestmethods/parserTests.hpp"
38
39 #include "runtime/arguments.hpp"
40 #include "runtime/interfaceSupport.hpp"
41 #include "runtime/os.hpp"
42 #include "utilities/array.hpp"
43 #include "utilities/align.hpp"
44 #include "utilities/debug.hpp"
45 #include "utilities/macros.hpp"
46 #include "utilities/exceptions.hpp"
47
48 #if INCLUDE_ALL_GCS
49 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
50 #include "gc_implementation/g1/concurrentMark.hpp"
51 #include "gc_implementation/g1/concurrentMarkThread.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 "jvmtifiles/jvmtiEnv.hpp"
637 WB_ENTRY(void, WB_MarkMethodProfiled(JNIEnv* env, jobject o, jobject method))
638 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
639 CHECK_JNI_EXCEPTION(env);
640 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
641
642 MethodData* mdo = mh->method_data();
643 if (mdo == NULL) {
644 Method::build_interpreter_method_data(mh, CHECK_AND_CLEAR);
645 mdo = mh->method_data();
646 }
647 mdo->init();
648 InvocationCounter* icnt = mdo->invocation_counter();
649 InvocationCounter* bcnt = mdo->backedge_counter();
650 // set i-counter according to AdvancedThresholdPolicy::is_method_profiled
651 // because SimpleThresholdPolicy::call_predicate_helper uses > in jdk8u, that's why we need to plus one.
652 icnt->set(InvocationCounter::wait_for_compile, Tier4MinInvocationThreshold + 1);
653 bcnt->set(InvocationCounter::wait_for_compile, Tier4CompileThreshold + 1);
654 WB_END
655
656 template <typename T>
657 static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAt)(const char*, T*, bool, bool)) {
658 if (name == NULL) {
659 return false;
660 }
661 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
662 const char* flag_name = env->GetStringUTFChars(name, NULL);
663 bool result = (*TAt)(flag_name, value, true, true);
664 env->ReleaseStringUTFChars(name, flag_name);
665 return result;
666 }
667
668 template <typename T>
669 static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAtPut)(const char*, T*, Flag::Flags)) {
670 if (name == NULL) {
671 return false;
672 }
673 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
674 const char* flag_name = env->GetStringUTFChars(name, NULL);
675 bool result = (*TAtPut)(flag_name, value, Flag::INTERNAL);
676 env->ReleaseStringUTFChars(name, flag_name);
677 return result;
678 }
679
680 template <typename T>
681 static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {
682 ResourceMark rm(thread);
683 jclass clazz = env->FindClass(name->as_C_string());
835 static volatile char* p;
836
837 p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
838 if (p == NULL) {
839 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
840 }
841
842 c = *p;
843 WB_END
844
845 WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
846 const char* cpu_features = VM_Version::cpu_features();
847 ThreadToNativeFromVM ttn(thread);
848 jstring features_string = env->NewStringUTF(cpu_features);
849
850 CHECK_JNI_EXCEPTION_(env, NULL);
851
852 return features_string;
853 WB_END
854
855 int WhiteBox::get_blob_type(const CodeBlob* code) {
856 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
857 return CodeBlobType::All;;
858 }
859
860 struct CodeBlobStub {
861 CodeBlobStub(const CodeBlob* blob) :
862 name(os::strdup(blob->name())),
863 size(blob->size()),
864 blob_type(WhiteBox::get_blob_type(blob)),
865 address((jlong) blob) { }
866 ~CodeBlobStub() { os::free((void*) name); }
867 const char* const name;
868 const jint size;
869 const jint blob_type;
870 const jlong address;
871 };
872
873 static jobjectArray codeBlob2objectArray(JavaThread* thread, JNIEnv* env, CodeBlobStub* cb) {
874 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
875 CHECK_JNI_EXCEPTION_(env, NULL);
876 jobjectArray result = env->NewObjectArray(4, clazz, NULL);
877
878 jstring name = env->NewStringUTF(cb->name);
879 CHECK_JNI_EXCEPTION_(env, NULL);
880 env->SetObjectArrayElement(result, 0, name);
881
882 jobject obj = integerBox(thread, env, cb->size);
883 CHECK_JNI_EXCEPTION_(env, NULL);
884 env->SetObjectArrayElement(result, 1, obj);
885
886 obj = integerBox(thread, env, cb->blob_type);
887 CHECK_JNI_EXCEPTION_(env, NULL);
888 env->SetObjectArrayElement(result, 2, obj);
889
890 obj = longBox(thread, env, cb->address);
891 CHECK_JNI_EXCEPTION_(env, NULL);
892 env->SetObjectArrayElement(result, 3, obj);
893
894 return result;
895 }
896
897 WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
898 ResourceMark rm(THREAD);
899 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
900 CHECK_JNI_EXCEPTION_(env, NULL);
901 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
902 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
903 jobjectArray result = NULL;
904 if (code == NULL) {
905 return result;
906 }
907 int insts_size = code->insts_size();
908
909 ThreadToNativeFromVM ttn(thread);
910 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
911 CHECK_JNI_EXCEPTION_(env, NULL);
912 result = env->NewObjectArray(3, clazz, NULL);
913 if (result == NULL) {
914 return result;
915 }
916
917 jobject level = integerBox(thread, env, code->comp_level());
918 CHECK_JNI_EXCEPTION_(env, NULL);
919 env->SetObjectArrayElement(result, 0, level);
920
921 jobject id = integerBox(thread, env, code->compile_id());
922 CHECK_JNI_EXCEPTION_(env, NULL);
923 env->SetObjectArrayElement(result, 1, id);
924
925 jbyteArray insts = env->NewByteArray(insts_size);
926 CHECK_JNI_EXCEPTION_(env, NULL);
927 env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
928 env->SetObjectArrayElement(result, 2, insts);
929
930 return result;
931 WB_END
932
933 CodeBlob* WhiteBox::allocate_code_blob(int size, int blob_type) {
934 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
935 BufferBlob* blob;
936 int full_size = CodeBlob::align_code_offset(sizeof(BufferBlob));
937 if (full_size < size) {
938 full_size += align_up(size - full_size, oopSize);
939 }
940 {
941 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
942 blob = (BufferBlob*) CodeCache::allocate(full_size);
943 ::new (blob) BufferBlob("WB::DummyBlob", full_size);
944 }
945 // Track memory usage statistic after releasing CodeCache_lock
946 MemoryService::track_code_cache_memory_usage();
947 return blob;
948 }
949
950 WB_ENTRY(jlong, WB_AllocateCodeBlob(JNIEnv* env, jobject o, jint size, jint blob_type))
951 if (size < 0) {
952 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
953 err_msg("WB_AllocateCodeBlob: size is negative: " INT32_FORMAT, size));
954 }
955 return (jlong) WhiteBox::allocate_code_blob(size, blob_type);
956 WB_END
957
958 WB_ENTRY(void, WB_FreeCodeBlob(JNIEnv* env, jobject o, jlong addr))
959 if (addr == 0) {
960 return;
961 }
962 BufferBlob::free((BufferBlob*) addr);
963 WB_END
964
965 WB_ENTRY(jobjectArray, WB_GetCodeBlob(JNIEnv* env, jobject o, jlong addr))
966 if (addr == 0) {
967 THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(),
968 "WB_GetCodeBlob: addr is null");
969 }
970 ThreadToNativeFromVM ttn(thread);
971 CodeBlobStub stub((CodeBlob*) addr);
972 return codeBlob2objectArray(thread, env, &stub);
973 WB_END
974
975 int WhiteBox::array_bytes_to_length(size_t bytes) {
976 return Array<u1>::bytes_to_length(bytes);
977 }
978
979 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
980 if (size < 0) {
981 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
982 err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
983 }
984
985 oop class_loader_oop = JNIHandles::resolve(class_loader);
986 ClassLoaderData* cld = class_loader_oop != NULL
987 ? java_lang_ClassLoader::loader_data(class_loader_oop)
988 : ClassLoaderData::the_null_class_loader_data();
989
990 void* metadata = MetadataFactory::new_writeable_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread);
991
992 return (jlong)(uintptr_t)metadata;
993 WB_END
1233 {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
1234 {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag},
1235 {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V",
1236 (void*)&WB_SetStringVMFlag},
1237 {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
1238 (void*)&WB_GetBooleanVMFlag},
1239 {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1240 (void*)&WB_GetIntxVMFlag},
1241 {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1242 (void*)&WB_GetUintxVMFlag},
1243 {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1244 (void*)&WB_GetUint64VMFlag},
1245 {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;",
1246 (void*)&WB_GetDoubleVMFlag},
1247 {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;",
1248 (void*)&WB_GetStringVMFlag},
1249 {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
1250 {CC"fullGC", CC"()V", (void*)&WB_FullGC },
1251 {CC"youngGC", CC"()V", (void*)&WB_YoungGC },
1252 {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
1253 {CC"allocateCodeBlob", CC"(II)J", (void*)&WB_AllocateCodeBlob },
1254 {CC"freeCodeBlob", CC"(J)V", (void*)&WB_FreeCodeBlob },
1255 {CC"getCodeBlob", CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob },
1256 {CC"allocateMetaspace",
1257 CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
1258 {CC"freeMetaspace",
1259 CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
1260 {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
1261 {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
1262 {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
1263 {CC"getNMethod", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
1264 (void*)&WB_GetNMethod },
1265 {CC"isMonitorInflated", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated },
1266 {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint },
1267 {CC"checkLibSpecifiesNoexecstack", CC"(Ljava/lang/String;)Z",
1268 (void*)&WB_CheckLibSpecifiesNoexecstack},
1269 {CC"isContainerized", CC"()Z", (void*)&WB_IsContainerized },
1270 {CC"printOsInfo", CC"()V", (void*)&WB_PrintOsInfo },
1271 };
1272
1273 #undef CC
1274
1275 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
|