22 *
23 */
24
25 #include "precompiled.hpp"
26
27 #include "memory/metadataFactory.hpp"
28 #include "memory/metaspaceShared.hpp"
29 #include "memory/universe.hpp"
30 #include "oops/oop.inline.hpp"
31
32 #include "classfile/symbolTable.hpp"
33 #include "classfile/classLoaderData.hpp"
34
35 #include "prims/whitebox.hpp"
36 #include "prims/wbtestmethods/parserTests.hpp"
37
38 #include "runtime/arguments.hpp"
39 #include "runtime/interfaceSupport.hpp"
40 #include "runtime/os.hpp"
41 #include "utilities/array.hpp"
42 #include "utilities/debug.hpp"
43 #include "utilities/macros.hpp"
44 #include "utilities/exceptions.hpp"
45
46 #if INCLUDE_ALL_GCS
47 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
48 #include "gc_implementation/g1/concurrentMark.hpp"
49 #include "gc_implementation/g1/concurrentMarkThread.hpp"
50 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
51 #include "gc_implementation/g1/heapRegionRemSet.hpp"
52 #endif // INCLUDE_ALL_GCS
53
54 #if INCLUDE_NMT
55 #include "services/mallocSiteTable.hpp"
56 #include "services/memTracker.hpp"
57 #include "utilities/nativeCallStack.hpp"
58 #endif // INCLUDE_NMT
59
60 #include "compiler/compileBroker.hpp"
61 #include "jvmtifiles/jvmtiEnv.hpp"
614
615 mh->clear_not_c1_compilable();
616 mh->clear_not_c2_compilable();
617 mh->clear_not_c2_osr_compilable();
618 NOT_PRODUCT(mh->set_compiled_invocation_count(0));
619 if (mcs != NULL) {
620 mcs->backedge_counter()->init();
621 mcs->invocation_counter()->init();
622 mcs->set_interpreter_invocation_count(0);
623 mcs->set_interpreter_throwout_count(0);
624
625 #ifdef TIERED
626 mcs->set_rate(0.0F);
627 mh->set_prev_event_count(0);
628 mh->set_prev_time(0);
629 #endif
630 }
631 WB_END
632
633 template <typename T>
634 static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAt)(const char*, T*)) {
635 if (name == NULL) {
636 return false;
637 }
638 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
639 const char* flag_name = env->GetStringUTFChars(name, NULL);
640 bool result = (*TAt)(flag_name, value);
641 env->ReleaseStringUTFChars(name, flag_name);
642 return result;
643 }
644
645 template <typename T>
646 static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAtPut)(const char*, T*, Flag::Flags)) {
647 if (name == NULL) {
648 return false;
649 }
650 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
651 const char* flag_name = env->GetStringUTFChars(name, NULL);
652 bool result = (*TAtPut)(flag_name, value, Flag::INTERNAL);
653 env->ReleaseStringUTFChars(name, flag_name);
654 return result;
655 }
656
657 template <typename T>
658 static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {
659 ResourceMark rm(thread);
660 jclass clazz = env->FindClass(name->as_C_string());
812 static volatile char* p;
813
814 p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
815 if (p == NULL) {
816 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
817 }
818
819 c = *p;
820 WB_END
821
822 WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
823 const char* cpu_features = VM_Version::cpu_features();
824 ThreadToNativeFromVM ttn(thread);
825 jstring features_string = env->NewStringUTF(cpu_features);
826
827 CHECK_JNI_EXCEPTION_(env, NULL);
828
829 return features_string;
830 WB_END
831
832
833 WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
834 ResourceMark rm(THREAD);
835 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
836 CHECK_JNI_EXCEPTION_(env, NULL);
837 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
838 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
839 jobjectArray result = NULL;
840 if (code == NULL) {
841 return result;
842 }
843 int insts_size = code->insts_size();
844
845 ThreadToNativeFromVM ttn(thread);
846 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
847 CHECK_JNI_EXCEPTION_(env, NULL);
848 result = env->NewObjectArray(2, clazz, NULL);
849 if (result == NULL) {
850 return result;
851 }
852
853 jobject obj = integerBox(thread, env, code->comp_level());
854 CHECK_JNI_EXCEPTION_(env, NULL);
855 env->SetObjectArrayElement(result, 0, obj);
856
857 jbyteArray insts = env->NewByteArray(insts_size);
858 CHECK_JNI_EXCEPTION_(env, NULL);
859 env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
860 env->SetObjectArrayElement(result, 1, insts);
861
862 return result;
863 WB_END
864
865
866 int WhiteBox::array_bytes_to_length(size_t bytes) {
867 return Array<u1>::bytes_to_length(bytes);
868 }
869
870 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
871 if (size < 0) {
872 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
873 err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
874 }
875
876 oop class_loader_oop = JNIHandles::resolve(class_loader);
877 ClassLoaderData* cld = class_loader_oop != NULL
878 ? java_lang_ClassLoader::loader_data(class_loader_oop)
879 : ClassLoaderData::the_null_class_loader_data();
880
881 void* metadata = MetadataFactory::new_writeable_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread);
882
883 return (jlong)(uintptr_t)metadata;
884 WB_END
1121 {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
1122 {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag},
1123 {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V",
1124 (void*)&WB_SetStringVMFlag},
1125 {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
1126 (void*)&WB_GetBooleanVMFlag},
1127 {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1128 (void*)&WB_GetIntxVMFlag},
1129 {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1130 (void*)&WB_GetUintxVMFlag},
1131 {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1132 (void*)&WB_GetUint64VMFlag},
1133 {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;",
1134 (void*)&WB_GetDoubleVMFlag},
1135 {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;",
1136 (void*)&WB_GetStringVMFlag},
1137 {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
1138 {CC"fullGC", CC"()V", (void*)&WB_FullGC },
1139 {CC"youngGC", CC"()V", (void*)&WB_YoungGC },
1140 {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
1141 {CC"allocateMetaspace",
1142 CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
1143 {CC"freeMetaspace",
1144 CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
1145 {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
1146 {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
1147 {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
1148 {CC"getNMethod", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
1149 (void*)&WB_GetNMethod },
1150 {CC"isMonitorInflated", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated },
1151 {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint },
1152 {CC"checkLibSpecifiesNoexecstack", CC"(Ljava/lang/String;)Z",
1153 (void*)&WB_CheckLibSpecifiesNoexecstack},
1154 {CC"isContainerized", CC"()Z", (void*)&WB_IsContainerized },
1155 {CC"printOsInfo", CC"()V", (void*)&WB_PrintOsInfo },
1156 };
1157
1158 #undef CC
1159
1160 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
|
22 *
23 */
24
25 #include "precompiled.hpp"
26
27 #include "memory/metadataFactory.hpp"
28 #include "memory/metaspaceShared.hpp"
29 #include "memory/universe.hpp"
30 #include "oops/oop.inline.hpp"
31
32 #include "classfile/symbolTable.hpp"
33 #include "classfile/classLoaderData.hpp"
34
35 #include "prims/whitebox.hpp"
36 #include "prims/wbtestmethods/parserTests.hpp"
37
38 #include "runtime/arguments.hpp"
39 #include "runtime/interfaceSupport.hpp"
40 #include "runtime/os.hpp"
41 #include "utilities/array.hpp"
42 #include "utilities/align.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"
615
616 mh->clear_not_c1_compilable();
617 mh->clear_not_c2_compilable();
618 mh->clear_not_c2_osr_compilable();
619 NOT_PRODUCT(mh->set_compiled_invocation_count(0));
620 if (mcs != NULL) {
621 mcs->backedge_counter()->init();
622 mcs->invocation_counter()->init();
623 mcs->set_interpreter_invocation_count(0);
624 mcs->set_interpreter_throwout_count(0);
625
626 #ifdef TIERED
627 mcs->set_rate(0.0F);
628 mh->set_prev_event_count(0);
629 mh->set_prev_time(0);
630 #endif
631 }
632 WB_END
633
634 template <typename T>
635 static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAt)(const char*, T*, bool, bool)) {
636 if (name == NULL) {
637 return false;
638 }
639 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
640 const char* flag_name = env->GetStringUTFChars(name, NULL);
641 bool result = (*TAt)(flag_name, value, true, true);
642 env->ReleaseStringUTFChars(name, flag_name);
643 return result;
644 }
645
646 template <typename T>
647 static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAtPut)(const char*, T*, Flag::Flags)) {
648 if (name == NULL) {
649 return false;
650 }
651 ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
652 const char* flag_name = env->GetStringUTFChars(name, NULL);
653 bool result = (*TAtPut)(flag_name, value, Flag::INTERNAL);
654 env->ReleaseStringUTFChars(name, flag_name);
655 return result;
656 }
657
658 template <typename T>
659 static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {
660 ResourceMark rm(thread);
661 jclass clazz = env->FindClass(name->as_C_string());
813 static volatile char* p;
814
815 p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
816 if (p == NULL) {
817 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
818 }
819
820 c = *p;
821 WB_END
822
823 WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
824 const char* cpu_features = VM_Version::cpu_features();
825 ThreadToNativeFromVM ttn(thread);
826 jstring features_string = env->NewStringUTF(cpu_features);
827
828 CHECK_JNI_EXCEPTION_(env, NULL);
829
830 return features_string;
831 WB_END
832
833 int WhiteBox::get_blob_type(const CodeBlob* code) {
834 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
835 return CodeBlobType::All;;
836 }
837
838 struct CodeBlobStub {
839 CodeBlobStub(const CodeBlob* blob) :
840 name(os::strdup(blob->name())),
841 size(blob->size()),
842 blob_type(WhiteBox::get_blob_type(blob)),
843 address((jlong) blob) { }
844 ~CodeBlobStub() { os::free((void*) name); }
845 const char* const name;
846 const jint size;
847 const jint blob_type;
848 const jlong address;
849 };
850
851 static jobjectArray codeBlob2objectArray(JavaThread* thread, JNIEnv* env, CodeBlobStub* cb) {
852 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
853 CHECK_JNI_EXCEPTION_(env, NULL);
854 jobjectArray result = env->NewObjectArray(4, clazz, NULL);
855
856 jstring name = env->NewStringUTF(cb->name);
857 CHECK_JNI_EXCEPTION_(env, NULL);
858 env->SetObjectArrayElement(result, 0, name);
859
860 jobject obj = integerBox(thread, env, cb->size);
861 CHECK_JNI_EXCEPTION_(env, NULL);
862 env->SetObjectArrayElement(result, 1, obj);
863
864 obj = integerBox(thread, env, cb->blob_type);
865 CHECK_JNI_EXCEPTION_(env, NULL);
866 env->SetObjectArrayElement(result, 2, obj);
867
868 obj = longBox(thread, env, cb->address);
869 CHECK_JNI_EXCEPTION_(env, NULL);
870 env->SetObjectArrayElement(result, 3, obj);
871
872 return result;
873 }
874
875 WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
876 ResourceMark rm(THREAD);
877 jmethodID jmid = reflected_method_to_jmid(thread, env, method);
878 CHECK_JNI_EXCEPTION_(env, NULL);
879 methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
880 nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
881 jobjectArray result = NULL;
882 if (code == NULL) {
883 return result;
884 }
885 int insts_size = code->insts_size();
886
887 ThreadToNativeFromVM ttn(thread);
888 jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
889 CHECK_JNI_EXCEPTION_(env, NULL);
890 result = env->NewObjectArray(2, clazz, NULL);
891 if (result == NULL) {
892 return result;
893 }
894
895 jobject obj = integerBox(thread, env, code->comp_level());
896 CHECK_JNI_EXCEPTION_(env, NULL);
897 env->SetObjectArrayElement(result, 0, obj);
898
899 jbyteArray insts = env->NewByteArray(insts_size);
900 CHECK_JNI_EXCEPTION_(env, NULL);
901 env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
902 env->SetObjectArrayElement(result, 1, insts);
903
904 return result;
905 WB_END
906
907 CodeBlob* WhiteBox::allocate_code_blob(int size, int blob_type) {
908 guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
909 BufferBlob* blob;
910 int full_size = CodeBlob::align_code_offset(sizeof(BufferBlob));
911 if (full_size < size) {
912 full_size += align_up(size - full_size, oopSize);
913 }
914 {
915 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
916 blob = (BufferBlob*) CodeCache::allocate(full_size);
917 ::new (blob) BufferBlob("WB::DummyBlob", full_size);
918 }
919 // Track memory usage statistic after releasing CodeCache_lock
920 MemoryService::track_code_cache_memory_usage();
921 return blob;
922 }
923
924 WB_ENTRY(jlong, WB_AllocateCodeBlob(JNIEnv* env, jobject o, jint size, jint blob_type))
925 if (size < 0) {
926 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
927 err_msg("WB_AllocateCodeBlob: size is negative: " INT32_FORMAT, size));
928 }
929 return (jlong) WhiteBox::allocate_code_blob(size, blob_type);
930 WB_END
931
932 WB_ENTRY(void, WB_FreeCodeBlob(JNIEnv* env, jobject o, jlong addr))
933 if (addr == 0) {
934 return;
935 }
936 BufferBlob::free((BufferBlob*) addr);
937 WB_END
938
939 WB_ENTRY(jobjectArray, WB_GetCodeBlob(JNIEnv* env, jobject o, jlong addr))
940 if (addr == 0) {
941 THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(),
942 "WB_GetCodeBlob: addr is null");
943 }
944 ThreadToNativeFromVM ttn(thread);
945 CodeBlobStub stub((CodeBlob*) addr);
946 return codeBlob2objectArray(thread, env, &stub);
947 WB_END
948
949 int WhiteBox::array_bytes_to_length(size_t bytes) {
950 return Array<u1>::bytes_to_length(bytes);
951 }
952
953 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
954 if (size < 0) {
955 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
956 err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
957 }
958
959 oop class_loader_oop = JNIHandles::resolve(class_loader);
960 ClassLoaderData* cld = class_loader_oop != NULL
961 ? java_lang_ClassLoader::loader_data(class_loader_oop)
962 : ClassLoaderData::the_null_class_loader_data();
963
964 void* metadata = MetadataFactory::new_writeable_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread);
965
966 return (jlong)(uintptr_t)metadata;
967 WB_END
1204 {CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
1205 {CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag},
1206 {CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V",
1207 (void*)&WB_SetStringVMFlag},
1208 {CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
1209 (void*)&WB_GetBooleanVMFlag},
1210 {CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1211 (void*)&WB_GetIntxVMFlag},
1212 {CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1213 (void*)&WB_GetUintxVMFlag},
1214 {CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
1215 (void*)&WB_GetUint64VMFlag},
1216 {CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;",
1217 (void*)&WB_GetDoubleVMFlag},
1218 {CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;",
1219 (void*)&WB_GetStringVMFlag},
1220 {CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
1221 {CC"fullGC", CC"()V", (void*)&WB_FullGC },
1222 {CC"youngGC", CC"()V", (void*)&WB_YoungGC },
1223 {CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
1224 {CC"allocateCodeBlob", CC"(II)J", (void*)&WB_AllocateCodeBlob },
1225 {CC"freeCodeBlob", CC"(J)V", (void*)&WB_FreeCodeBlob },
1226 {CC"getCodeBlob", CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob },
1227 {CC"allocateMetaspace",
1228 CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
1229 {CC"freeMetaspace",
1230 CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
1231 {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
1232 {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
1233 {CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
1234 {CC"getNMethod", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
1235 (void*)&WB_GetNMethod },
1236 {CC"isMonitorInflated", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated },
1237 {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint },
1238 {CC"checkLibSpecifiesNoexecstack", CC"(Ljava/lang/String;)Z",
1239 (void*)&WB_CheckLibSpecifiesNoexecstack},
1240 {CC"isContainerized", CC"()Z", (void*)&WB_IsContainerized },
1241 {CC"printOsInfo", CC"()V", (void*)&WB_PrintOsInfo },
1242 };
1243
1244 #undef CC
1245
1246 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
|