67 args.push_long((jlong) (address) method());
68 JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedJavaMethodImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::method_fromMetaspace_signature(), &args, CHECK_NULL);
69
70 return (oop)result.get_jobject();
71 }
72 return NULL;
73 }
74
75 oop CompilerToVM::get_jvmci_type(KlassHandle klass, TRAPS) {
76 if (klass() != NULL) {
77 JavaValue result(T_OBJECT);
78 JavaCallArguments args;
79 args.push_oop(klass->java_mirror());
80 JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedObjectTypeImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::klass_fromMetaspace_signature(), &args, CHECK_NULL);
81
82 return (oop)result.get_jobject();
83 }
84 return NULL;
85 }
86
87 extern "C" {
88 extern VMStructEntry* gHotSpotVMStructs;
89 extern uint64_t gHotSpotVMStructEntryTypeNameOffset;
90 extern uint64_t gHotSpotVMStructEntryFieldNameOffset;
91 extern uint64_t gHotSpotVMStructEntryTypeStringOffset;
92 extern uint64_t gHotSpotVMStructEntryIsStaticOffset;
93 extern uint64_t gHotSpotVMStructEntryOffsetOffset;
94 extern uint64_t gHotSpotVMStructEntryAddressOffset;
95 extern uint64_t gHotSpotVMStructEntryArrayStride;
96
97 extern VMTypeEntry* gHotSpotVMTypes;
98 extern uint64_t gHotSpotVMTypeEntryTypeNameOffset;
99 extern uint64_t gHotSpotVMTypeEntrySuperclassNameOffset;
100 extern uint64_t gHotSpotVMTypeEntryIsOopTypeOffset;
101 extern uint64_t gHotSpotVMTypeEntryIsIntegerTypeOffset;
102 extern uint64_t gHotSpotVMTypeEntryIsUnsignedOffset;
103 extern uint64_t gHotSpotVMTypeEntrySizeOffset;
104 extern uint64_t gHotSpotVMTypeEntryArrayStride;
105
106 extern VMIntConstantEntry* gHotSpotVMIntConstants;
521 LinkInfo link_info(cp, index, CHECK_0);
522 LinkResolver::resolve_field(fd, link_info, Bytecodes::java_code(code), false, CHECK_0);
523 typeArrayOop info = (typeArrayOop) JNIHandles::resolve(info_handle);
524 assert(info != NULL && info->length() == 2, "must be");
525 info->long_at_put(0, (jlong) fd.access_flags().as_int());
526 info->long_at_put(1, (jlong) fd.offset());
527 oop field_holder = CompilerToVM::get_jvmci_type(fd.field_holder(), CHECK_NULL);
528 return JNIHandles::make_local(THREAD, field_holder);
529 C2V_END
530
531 C2V_VMENTRY(jint, getVtableIndexForInterfaceMethod, (JNIEnv *, jobject, jobject jvmci_type, jobject jvmci_method))
532 ResourceMark rm;
533 Klass* klass = CompilerToVM::asKlass(jvmci_type);
534 Method* method = CompilerToVM::asMethod(jvmci_method);
535 if (klass->is_interface()) {
536 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Interface %s should be handled in Java code", klass->external_name()));
537 }
538 if (!method->method_holder()->is_interface()) {
539 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Method %s is not held by an interface, this case should be handled in Java code", method->name_and_sig_as_C_string()));
540 }
541 if (!InstanceKlass::cast(klass)->is_initialized()) {
542 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Class %s must be initialized", klass->external_name()));
543 }
544 return LinkResolver::vtable_index_of_interface_method(klass, method);
545 C2V_END
546
547 C2V_VMENTRY(jobject, resolveMethod, (JNIEnv *, jobject, jobject receiver_jvmci_type, jobject jvmci_method, jobject caller_jvmci_type))
548 Klass* recv_klass = CompilerToVM::asKlass(receiver_jvmci_type);
549 Klass* caller_klass = CompilerToVM::asKlass(caller_jvmci_type);
550 Method* method = CompilerToVM::asMethod(jvmci_method);
551
552 if (recv_klass->oop_is_array() || (InstanceKlass::cast(recv_klass)->is_linked())) {
553 Klass* holder_klass = method->method_holder();
554 Symbol* method_name = method->name();
555 Symbol* method_signature = method->signature();
556
557 if (holder_klass->is_interface()) {
558 // do link-time resolution to check all access rules.
559 LinkInfo link_info(holder_klass, method_name, method_signature, caller_klass, true);
560 methodHandle resolved_method = LinkResolver::linktime_resolve_interface_method_or_null(link_info);
561 if (resolved_method.is_null() || resolved_method->is_private()) {
562 return NULL;
653 TraceTime install_time("installCode", JVMCICompiler::codeInstallTimer());
654 CodeInstaller installer;
655 JVMCIEnv::CodeInstallResult result = installer.install(compiler, target_handle, compiled_code_handle, cb, installed_code_handle, speculation_log_handle);
656
657 if (PrintCodeCacheOnCompilation) {
658 stringStream s;
659 // Dump code cache into a buffer before locking the tty,
660 {
661 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
662 CodeCache::print_summary(&s, false);
663 }
664 ttyLocker ttyl;
665 tty->print_raw_cr(s.as_string());
666 }
667
668 if (result != JVMCIEnv::ok) {
669 assert(cb == NULL, "should be");
670 } else {
671 if (!installed_code_handle.is_null()) {
672 assert(installed_code_handle->is_a(InstalledCode::klass()), "wrong type");
673 InstalledCode::set_address(installed_code_handle, (jlong) cb);
674 InstalledCode::set_version(installed_code_handle, InstalledCode::version(installed_code_handle) + 1);
675 if (installed_code_handle->is_a(HotSpotInstalledCode::klass())) {
676 HotSpotInstalledCode::set_size(installed_code_handle, cb->size());
677 HotSpotInstalledCode::set_codeStart(installed_code_handle, (jlong) cb->code_begin());
678 HotSpotInstalledCode::set_codeSize(installed_code_handle, cb->code_size());
679 }
680 nmethod* nm = cb->as_nmethod_or_null();
681 if (nm != NULL && installed_code_handle->is_scavengable()) {
682 assert(nm->detect_scavenge_root_oops(), "nm should be scavengable if installed_code is scavengable");
683 if (!UseG1GC) {
684 assert(nm->on_scavenge_root_list(), "nm should be on scavengable list");
685 }
686 }
687 }
688 }
689 return result;
690 C2V_END
691
692 C2V_VMENTRY(jint, getMetadata, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject metadata))
693 ResourceMark rm;
694 HandleMark hm;
765 if (installed_code_handle->is_a(HotSpotInstalledCode::klass())) {
766 stats->_nmethods_size += HotSpotInstalledCode::size(installed_code_handle);
767 stats->_nmethods_code_size += HotSpotInstalledCode::codeSize(installed_code_handle);
768 }
769
770 if (CITimeEach) {
771 methodHandle method = CompilerToVM::asMethod(hotspot_method);
772 float bytes_per_sec = 1.0 * processedBytecodes / timer.seconds();
773 tty->print_cr("%3d seconds: %f bytes/sec: %f (bytes %d)",
774 id, timer.seconds(), bytes_per_sec, processedBytecodes);
775 }
776 C2V_END
777
778 C2V_VMENTRY(void, resetCompilationStatistics, (JNIEnv *jniEnv, jobject))
779 JVMCICompiler* compiler = JVMCICompiler::instance(CHECK);
780 CompilerStatistics* stats = compiler->stats();
781 stats->_standard.reset();
782 stats->_osr.reset();
783 C2V_END
784
785 C2V_VMENTRY(jobject, disassembleCodeBlob, (JNIEnv *jniEnv, jobject, jlong codeBlob))
786 ResourceMark rm;
787 HandleMark hm;
788
789 CodeBlob* cb = (CodeBlob*) (address) codeBlob;
790 if (cb == NULL) {
791 return NULL;
792 }
793
794 // We don't want the stringStream buffer to resize during disassembly as it
795 // uses scoped resource memory. If a nested function called during disassembly uses
796 // a ResourceMark and the buffer expands within the scope of the mark,
797 // the buffer becomes garbage when that scope is exited. Experience shows that
798 // the disassembled code is typically about 10x the code size so a fixed buffer
799 // sized to 20x code size plus a fixed amount for header info should be sufficient.
800 int bufferSize = cb->code_size() * 20 + 1024;
801 char* buffer = NEW_RESOURCE_ARRAY(char, bufferSize);
802 stringStream st(buffer, bufferSize);
803 if (cb->is_nmethod()) {
804 nmethod* nm = (nmethod*) cb;
805 if (!nm->is_alive()) {
806 return NULL;
807 }
808 Disassembler::decode(nm, &st);
919 mcs->clear_counters();
920 }
921 NOT_PRODUCT(method->set_compiled_invocation_count(0));
922
923 nmethod* code = method->code();
924 if (code != NULL) {
925 code->make_not_entrant();
926 }
927
928 MethodData* method_data = method->method_data();
929 if (method_data == NULL) {
930 ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
931 method_data = MethodData::allocate(loader_data, method, CHECK);
932 method->set_method_data(method_data);
933 } else {
934 method_data->initialize();
935 }
936 C2V_END
937
938
939 C2V_VMENTRY(void, invalidateInstalledCode, (JNIEnv*, jobject, jobject hotspotInstalledCode))
940 jlong nativeMethod = InstalledCode::address(hotspotInstalledCode);
941 nmethod* m = (nmethod*)nativeMethod;
942 if (m != NULL && !m->is_not_entrant()) {
943 m->mark_for_deoptimization();
944 VM_Deoptimize op;
945 VMThread::execute(&op);
946 }
947 InstalledCode::set_address(hotspotInstalledCode, 0);
948 C2V_END
949
950 C2V_VMENTRY(jobject, readUncompressedOop, (JNIEnv*, jobject, jlong addr))
951 oop ret = oopDesc::load_decode_heap_oop((oop*)(address)addr);
952 return JNIHandles::make_local(THREAD, ret);
953 C2V_END
954
955 C2V_VMENTRY(jlongArray, collectCounters, (JNIEnv*, jobject))
956 typeArrayOop arrayOop = oopFactory::new_longArray(JVMCICounterSize, CHECK_NULL);
957 JavaThread::collect_counters(arrayOop);
958 return (jlongArray) JNIHandles::make_local(THREAD, arrayOop);
959 C2V_END
960
961 C2V_VMENTRY(int, allocateCompileId, (JNIEnv*, jobject, jobject jvmci_method, int entry_bci))
962 HandleMark hm;
963 ResourceMark rm;
964 if (JNIHandles::resolve(jvmci_method) == NULL) {
965 THROW_0(vmSymbols::java_lang_NullPointerException());
966 }
967 Method* method = CompilerToVM::asMethod(jvmci_method);
974
975 C2V_VMENTRY(jboolean, isMature, (JNIEnv*, jobject, jlong metaspace_method_data))
976 MethodData* mdo = CompilerToVM::asMethodData(metaspace_method_data);
977 return mdo != NULL && mdo->is_mature();
978 C2V_END
979
980 C2V_VMENTRY(jboolean, hasCompiledCodeForOSR, (JNIEnv*, jobject, jobject jvmci_method, int entry_bci, int comp_level))
981 Method* method = CompilerToVM::asMethod(jvmci_method);
982 return method->lookup_osr_nmethod_for(entry_bci, comp_level, true) != NULL;
983 C2V_END
984
985 C2V_VMENTRY(jobject, getSymbol, (JNIEnv*, jobject, jlong symbol))
986 Handle sym = java_lang_String::create_from_symbol((Symbol*)(address)symbol, CHECK_NULL);
987 return JNIHandles::make_local(THREAD, sym());
988 C2V_END
989
990 bool matches(jobjectArray methods, Method* method) {
991 objArrayOop methods_oop = (objArrayOop) JNIHandles::resolve(methods);
992
993 for (int i = 0; i < methods_oop->length(); i++) {
994 if (CompilerToVM::asMethod(methods_oop->obj_at(i)) == method) {
995 return true;
996 }
997 }
998 return false;
999 }
1000
1001 C2V_VMENTRY(jobject, getNextStackFrame, (JNIEnv*, jobject compilerToVM, jobject hs_frame, jobjectArray methods, jint initialSkip))
1002 ResourceMark rm;
1003
1004 if (!thread->has_last_Java_frame()) return NULL;
1005 Handle result = HotSpotStackFrameReference::klass()->allocate_instance(thread);
1006 HotSpotStackFrameReference::klass()->initialize(thread);
1007
1008 StackFrameStream fst(thread);
1009 if (hs_frame != NULL) {
1010 // look for the correct stack frame if one is given
1011 intptr_t* stack_pointer = (intptr_t*) HotSpotStackFrameReference::stackPointer(hs_frame);
1012 while (fst.current()->sp() != stack_pointer && !fst.is_done()) {
1013 fst.next();
1014 }
1267 // Check if offset and length are non negative.
1268 if (offset < 0 || length < 0) {
1269 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
1270 }
1271 // Check if the range is valid.
1272 if ((((unsigned int) length + (unsigned int) offset) > (unsigned int) array->length())) {
1273 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
1274 }
1275 while (length > 0) {
1276 jbyte* start = array->byte_at_addr(offset);
1277 tty->write((char*) start, MIN2(length, O_BUFLEN));
1278 length -= O_BUFLEN;
1279 offset += O_BUFLEN;
1280 }
1281 C2V_END
1282
1283 C2V_VMENTRY(void, flushDebugOutput, (JNIEnv*, jobject))
1284 tty->flush();
1285 C2V_END
1286
1287
1288 #define CC (char*) /*cast a literal from (const char*)*/
1289 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &(c2v_ ## f))
1290
1291 #define SPECULATION_LOG "Ljdk/vm/ci/meta/SpeculationLog;"
1292 #define STRING "Ljava/lang/String;"
1293 #define OBJECT "Ljava/lang/Object;"
1294 #define CLASS "Ljava/lang/Class;"
1295 #define STACK_TRACE_ELEMENT "Ljava/lang/StackTraceElement;"
1296 #define INSTALLED_CODE "Ljdk/vm/ci/code/InstalledCode;"
1297 #define TARGET_DESCRIPTION "Ljdk/vm/ci/code/TargetDescription;"
1298 #define RESOLVED_METHOD "Ljdk/vm/ci/meta/ResolvedJavaMethod;"
1299 #define HS_RESOLVED_METHOD "Ljdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl;"
1300 #define HS_RESOLVED_KLASS "Ljdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl;"
1301 #define HS_CONSTANT_POOL "Ljdk/vm/ci/hotspot/HotSpotConstantPool;"
1302 #define HS_COMPILED_CODE "Ljdk/vm/ci/hotspot/HotSpotCompiledCode;"
1303 #define HS_METADATA "Ljdk/vm/ci/hotspot/HotSpotMetaData;"
1304 #define HS_STACK_FRAME_REF "Ljdk/vm/ci/hotspot/HotSpotStackFrameReference;"
1305 #define METASPACE_METHOD_DATA "J"
1306
1307 JNINativeMethod CompilerToVM::methods[] = {
1308 {CC"getBytecode", CC"("HS_RESOLVED_METHOD")[B", FN_PTR(getBytecode)},
1309 {CC"getExceptionTableStart", CC"("HS_RESOLVED_METHOD")J", FN_PTR(getExceptionTableStart)},
1310 {CC"getExceptionTableLength", CC"("HS_RESOLVED_METHOD")I", FN_PTR(getExceptionTableLength)},
1311 {CC"findUniqueConcreteMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD")"HS_RESOLVED_METHOD, FN_PTR(findUniqueConcreteMethod)},
1312 {CC"getImplementor", CC"("HS_RESOLVED_KLASS")"HS_RESOLVED_KLASS, FN_PTR(getImplementor)},
1313 {CC"getStackTraceElement", CC"("HS_RESOLVED_METHOD"I)"STACK_TRACE_ELEMENT, FN_PTR(getStackTraceElement)},
1314 {CC"methodIsIgnoredBySecurityStackWalk", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(methodIsIgnoredBySecurityStackWalk)},
1315 {CC"doNotInlineOrCompile", CC"("HS_RESOLVED_METHOD")V", FN_PTR(doNotInlineOrCompile)},
1316 {CC"canInlineMethod", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(canInlineMethod)},
1317 {CC"shouldInlineMethod", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(shouldInlineMethod)},
1318 {CC"lookupType", CC"("STRING CLASS"Z)"HS_RESOLVED_KLASS, FN_PTR(lookupType)},
1319 {CC"lookupNameInPool", CC"("HS_CONSTANT_POOL"I)"STRING, FN_PTR(lookupNameInPool)},
1320 {CC"lookupNameAndTypeRefIndexInPool", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(lookupNameAndTypeRefIndexInPool)},
1321 {CC"lookupSignatureInPool", CC"("HS_CONSTANT_POOL"I)"STRING, FN_PTR(lookupSignatureInPool)},
1322 {CC"lookupKlassRefIndexInPool", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(lookupKlassRefIndexInPool)},
1323 {CC"lookupKlassInPool", CC"("HS_CONSTANT_POOL"I)Ljava/lang/Object;", FN_PTR(lookupKlassInPool)},
1324 {CC"lookupAppendixInPool", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(lookupAppendixInPool)},
1325 {CC"lookupMethodInPool", CC"("HS_CONSTANT_POOL"IB)"HS_RESOLVED_METHOD, FN_PTR(lookupMethodInPool)},
1326 {CC"constantPoolRemapInstructionOperandFromCache", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(constantPoolRemapInstructionOperandFromCache)},
1327 {CC"resolveConstantInPool", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(resolveConstantInPool)},
1328 {CC"resolvePossiblyCachedConstantInPool", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(resolvePossiblyCachedConstantInPool)},
1329 {CC"resolveTypeInPool", CC"("HS_CONSTANT_POOL"I)"HS_RESOLVED_KLASS, FN_PTR(resolveTypeInPool)},
1330 {CC"resolveFieldInPool", CC"("HS_CONSTANT_POOL"IB[J)"HS_RESOLVED_KLASS, FN_PTR(resolveFieldInPool)},
1331 {CC"resolveInvokeDynamicInPool", CC"("HS_CONSTANT_POOL"I)V", FN_PTR(resolveInvokeDynamicInPool)},
1332 {CC"resolveInvokeHandleInPool", CC"("HS_CONSTANT_POOL"I)V", FN_PTR(resolveInvokeHandleInPool)},
1333 {CC"resolveMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD HS_RESOLVED_KLASS")"HS_RESOLVED_METHOD, FN_PTR(resolveMethod)},
1334 {CC"getVtableIndexForInterfaceMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD")I", FN_PTR(getVtableIndexForInterfaceMethod)},
1335 {CC"getClassInitializer", CC"("HS_RESOLVED_KLASS")"HS_RESOLVED_METHOD, FN_PTR(getClassInitializer)},
1336 {CC"hasFinalizableSubclass", CC"("HS_RESOLVED_KLASS")Z", FN_PTR(hasFinalizableSubclass)},
1337 {CC"getMaxCallTargetOffset", CC"(J)J", FN_PTR(getMaxCallTargetOffset)},
1338 {CC"getResolvedJavaMethodAtSlot", CC"("CLASS"I)"HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethodAtSlot)},
1339 {CC"getResolvedJavaMethod", CC"(Ljava/lang/Object;J)"HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethod)},
1340 {CC"getConstantPool", CC"(Ljava/lang/Object;J)"HS_CONSTANT_POOL, FN_PTR(getConstantPool)},
1341 {CC"getResolvedJavaType", CC"(Ljava/lang/Object;JZ)"HS_RESOLVED_KLASS, FN_PTR(getResolvedJavaType)},
1342 {CC"initializeConfiguration", CC"()J", FN_PTR(initializeConfiguration)},
1343 {CC"installCode", CC"("TARGET_DESCRIPTION HS_COMPILED_CODE INSTALLED_CODE SPECULATION_LOG")I", FN_PTR(installCode)},
1344 {CC"getMetadata", CC"("TARGET_DESCRIPTION HS_COMPILED_CODE HS_METADATA")I", FN_PTR(getMetadata)},
1345 {CC"notifyCompilationStatistics", CC"(I"HS_RESOLVED_METHOD"ZIJJ"INSTALLED_CODE")V", FN_PTR(notifyCompilationStatistics)},
1346 {CC"resetCompilationStatistics", CC"()V", FN_PTR(resetCompilationStatistics)},
1347 {CC"disassembleCodeBlob", CC"(J)"STRING, FN_PTR(disassembleCodeBlob)},
1348 {CC"executeInstalledCode", CC"(["OBJECT INSTALLED_CODE")"OBJECT, FN_PTR(executeInstalledCode)},
1349 {CC"getLineNumberTable", CC"("HS_RESOLVED_METHOD")[J", FN_PTR(getLineNumberTable)},
1350 {CC"getLocalVariableTableStart", CC"("HS_RESOLVED_METHOD")J", FN_PTR(getLocalVariableTableStart)},
1351 {CC"getLocalVariableTableLength", CC"("HS_RESOLVED_METHOD")I", FN_PTR(getLocalVariableTableLength)},
1352 {CC"reprofile", CC"("HS_RESOLVED_METHOD")V", FN_PTR(reprofile)},
1353 {CC"invalidateInstalledCode", CC"("INSTALLED_CODE")V", FN_PTR(invalidateInstalledCode)},
1354 {CC"readUncompressedOop", CC"(J)"OBJECT, FN_PTR(readUncompressedOop)},
1355 {CC"collectCounters", CC"()[J", FN_PTR(collectCounters)},
1356 {CC"allocateCompileId", CC"("HS_RESOLVED_METHOD"I)I", FN_PTR(allocateCompileId)},
1357 {CC"isMature", CC"("METASPACE_METHOD_DATA")Z", FN_PTR(isMature)},
1358 {CC"hasCompiledCodeForOSR", CC"("HS_RESOLVED_METHOD"II)Z", FN_PTR(hasCompiledCodeForOSR)},
1359 {CC"getSymbol", CC"(J)"STRING, FN_PTR(getSymbol)},
1360 {CC"getNextStackFrame", CC"("HS_STACK_FRAME_REF "["HS_RESOLVED_METHOD"I)"HS_STACK_FRAME_REF, FN_PTR(getNextStackFrame)},
1361 {CC"materializeVirtualObjects", CC"("HS_STACK_FRAME_REF"Z)V", FN_PTR(materializeVirtualObjects)},
1362 {CC"shouldDebugNonSafepoints", CC"()Z", FN_PTR(shouldDebugNonSafepoints)},
1363 {CC"writeDebugOutput", CC"([BII)V", FN_PTR(writeDebugOutput)},
1364 {CC"flushDebugOutput", CC"()V", FN_PTR(flushDebugOutput)},
1365 };
1366
1367 int CompilerToVM::methods_count() {
1368 return sizeof(methods) / sizeof(JNINativeMethod);
1369 }
1370
|
67 args.push_long((jlong) (address) method());
68 JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedJavaMethodImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::method_fromMetaspace_signature(), &args, CHECK_NULL);
69
70 return (oop)result.get_jobject();
71 }
72 return NULL;
73 }
74
75 oop CompilerToVM::get_jvmci_type(KlassHandle klass, TRAPS) {
76 if (klass() != NULL) {
77 JavaValue result(T_OBJECT);
78 JavaCallArguments args;
79 args.push_oop(klass->java_mirror());
80 JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedObjectTypeImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::klass_fromMetaspace_signature(), &args, CHECK_NULL);
81
82 return (oop)result.get_jobject();
83 }
84 return NULL;
85 }
86
87 void CompilerToVM::invalidate_installed_code(Handle installedCode, TRAPS) {
88 if (installedCode() == NULL) {
89 THROW(vmSymbols::java_lang_NullPointerException());
90 }
91 jlong nativeMethod = InstalledCode::address(installedCode);
92 nmethod* nm = (nmethod*)nativeMethod;
93 assert(nm == NULL || nm->jvmci_installed_code() == installedCode(), "sanity check");
94 if (nm != NULL && nm->is_alive()) {
95 // The nmethod state machinery maintains the link between the
96 // HotSpotInstalledCode and nmethod* so as long as the nmethod appears to be
97 // alive assume there is work to do and deoptimize the nmethod.
98 nm->mark_for_deoptimization();
99 VM_Deoptimize op;
100 VMThread::execute(&op);
101 }
102 InstalledCode::set_address(installedCode, 0);
103 }
104
105 extern "C" {
106 extern VMStructEntry* gHotSpotVMStructs;
107 extern uint64_t gHotSpotVMStructEntryTypeNameOffset;
108 extern uint64_t gHotSpotVMStructEntryFieldNameOffset;
109 extern uint64_t gHotSpotVMStructEntryTypeStringOffset;
110 extern uint64_t gHotSpotVMStructEntryIsStaticOffset;
111 extern uint64_t gHotSpotVMStructEntryOffsetOffset;
112 extern uint64_t gHotSpotVMStructEntryAddressOffset;
113 extern uint64_t gHotSpotVMStructEntryArrayStride;
114
115 extern VMTypeEntry* gHotSpotVMTypes;
116 extern uint64_t gHotSpotVMTypeEntryTypeNameOffset;
117 extern uint64_t gHotSpotVMTypeEntrySuperclassNameOffset;
118 extern uint64_t gHotSpotVMTypeEntryIsOopTypeOffset;
119 extern uint64_t gHotSpotVMTypeEntryIsIntegerTypeOffset;
120 extern uint64_t gHotSpotVMTypeEntryIsUnsignedOffset;
121 extern uint64_t gHotSpotVMTypeEntrySizeOffset;
122 extern uint64_t gHotSpotVMTypeEntryArrayStride;
123
124 extern VMIntConstantEntry* gHotSpotVMIntConstants;
539 LinkInfo link_info(cp, index, CHECK_0);
540 LinkResolver::resolve_field(fd, link_info, Bytecodes::java_code(code), false, CHECK_0);
541 typeArrayOop info = (typeArrayOop) JNIHandles::resolve(info_handle);
542 assert(info != NULL && info->length() == 2, "must be");
543 info->long_at_put(0, (jlong) fd.access_flags().as_int());
544 info->long_at_put(1, (jlong) fd.offset());
545 oop field_holder = CompilerToVM::get_jvmci_type(fd.field_holder(), CHECK_NULL);
546 return JNIHandles::make_local(THREAD, field_holder);
547 C2V_END
548
549 C2V_VMENTRY(jint, getVtableIndexForInterfaceMethod, (JNIEnv *, jobject, jobject jvmci_type, jobject jvmci_method))
550 ResourceMark rm;
551 Klass* klass = CompilerToVM::asKlass(jvmci_type);
552 Method* method = CompilerToVM::asMethod(jvmci_method);
553 if (klass->is_interface()) {
554 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Interface %s should be handled in Java code", klass->external_name()));
555 }
556 if (!method->method_holder()->is_interface()) {
557 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Method %s is not held by an interface, this case should be handled in Java code", method->name_and_sig_as_C_string()));
558 }
559 if (!InstanceKlass::cast(klass)->is_linked()) {
560 THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Class %s must be linked", klass->external_name()));
561 }
562 return LinkResolver::vtable_index_of_interface_method(klass, method);
563 C2V_END
564
565 C2V_VMENTRY(jobject, resolveMethod, (JNIEnv *, jobject, jobject receiver_jvmci_type, jobject jvmci_method, jobject caller_jvmci_type))
566 Klass* recv_klass = CompilerToVM::asKlass(receiver_jvmci_type);
567 Klass* caller_klass = CompilerToVM::asKlass(caller_jvmci_type);
568 Method* method = CompilerToVM::asMethod(jvmci_method);
569
570 if (recv_klass->oop_is_array() || (InstanceKlass::cast(recv_klass)->is_linked())) {
571 Klass* holder_klass = method->method_holder();
572 Symbol* method_name = method->name();
573 Symbol* method_signature = method->signature();
574
575 if (holder_klass->is_interface()) {
576 // do link-time resolution to check all access rules.
577 LinkInfo link_info(holder_klass, method_name, method_signature, caller_klass, true);
578 methodHandle resolved_method = LinkResolver::linktime_resolve_interface_method_or_null(link_info);
579 if (resolved_method.is_null() || resolved_method->is_private()) {
580 return NULL;
671 TraceTime install_time("installCode", JVMCICompiler::codeInstallTimer());
672 CodeInstaller installer;
673 JVMCIEnv::CodeInstallResult result = installer.install(compiler, target_handle, compiled_code_handle, cb, installed_code_handle, speculation_log_handle);
674
675 if (PrintCodeCacheOnCompilation) {
676 stringStream s;
677 // Dump code cache into a buffer before locking the tty,
678 {
679 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
680 CodeCache::print_summary(&s, false);
681 }
682 ttyLocker ttyl;
683 tty->print_raw_cr(s.as_string());
684 }
685
686 if (result != JVMCIEnv::ok) {
687 assert(cb == NULL, "should be");
688 } else {
689 if (!installed_code_handle.is_null()) {
690 assert(installed_code_handle->is_a(InstalledCode::klass()), "wrong type");
691 CompilerToVM::invalidate_installed_code(installed_code_handle, CHECK_0);
692 InstalledCode::set_address(installed_code_handle, (jlong) cb);
693 if (cb->is_nmethod()) {
694 InstalledCode::set_entryPoint(installed_code_handle, (jlong) cb->as_nmethod_or_null()->verified_entry_point());
695 } else {
696 InstalledCode::set_entryPoint(installed_code_handle, (jlong) cb->code_begin());
697 }
698 if (installed_code_handle->is_a(HotSpotInstalledCode::klass())) {
699 HotSpotInstalledCode::set_size(installed_code_handle, cb->size());
700 HotSpotInstalledCode::set_codeStart(installed_code_handle, (jlong) cb->code_begin());
701 HotSpotInstalledCode::set_codeSize(installed_code_handle, cb->code_size());
702 }
703 nmethod* nm = cb->as_nmethod_or_null();
704 if (nm != NULL && installed_code_handle->is_scavengable()) {
705 assert(nm->detect_scavenge_root_oops(), "nm should be scavengable if installed_code is scavengable");
706 if (!UseG1GC) {
707 assert(nm->on_scavenge_root_list(), "nm should be on scavengable list");
708 }
709 }
710 }
711 }
712 return result;
713 C2V_END
714
715 C2V_VMENTRY(jint, getMetadata, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject metadata))
716 ResourceMark rm;
717 HandleMark hm;
788 if (installed_code_handle->is_a(HotSpotInstalledCode::klass())) {
789 stats->_nmethods_size += HotSpotInstalledCode::size(installed_code_handle);
790 stats->_nmethods_code_size += HotSpotInstalledCode::codeSize(installed_code_handle);
791 }
792
793 if (CITimeEach) {
794 methodHandle method = CompilerToVM::asMethod(hotspot_method);
795 float bytes_per_sec = 1.0 * processedBytecodes / timer.seconds();
796 tty->print_cr("%3d seconds: %f bytes/sec: %f (bytes %d)",
797 id, timer.seconds(), bytes_per_sec, processedBytecodes);
798 }
799 C2V_END
800
801 C2V_VMENTRY(void, resetCompilationStatistics, (JNIEnv *jniEnv, jobject))
802 JVMCICompiler* compiler = JVMCICompiler::instance(CHECK);
803 CompilerStatistics* stats = compiler->stats();
804 stats->_standard.reset();
805 stats->_osr.reset();
806 C2V_END
807
808 C2V_VMENTRY(jobject, disassembleCodeBlob, (JNIEnv *jniEnv, jobject, jobject installedCode))
809 ResourceMark rm;
810 HandleMark hm;
811
812 if (installedCode == NULL) {
813 THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(), "installedCode is null");
814 }
815
816 jlong codeBlob = InstalledCode::address(installedCode);
817 if (codeBlob == 0L) {
818 return NULL;
819 }
820
821 CodeBlob* cb = (CodeBlob*) (address) codeBlob;
822 if (cb == NULL) {
823 return NULL;
824 }
825
826 // We don't want the stringStream buffer to resize during disassembly as it
827 // uses scoped resource memory. If a nested function called during disassembly uses
828 // a ResourceMark and the buffer expands within the scope of the mark,
829 // the buffer becomes garbage when that scope is exited. Experience shows that
830 // the disassembled code is typically about 10x the code size so a fixed buffer
831 // sized to 20x code size plus a fixed amount for header info should be sufficient.
832 int bufferSize = cb->code_size() * 20 + 1024;
833 char* buffer = NEW_RESOURCE_ARRAY(char, bufferSize);
834 stringStream st(buffer, bufferSize);
835 if (cb->is_nmethod()) {
836 nmethod* nm = (nmethod*) cb;
837 if (!nm->is_alive()) {
838 return NULL;
839 }
840 Disassembler::decode(nm, &st);
951 mcs->clear_counters();
952 }
953 NOT_PRODUCT(method->set_compiled_invocation_count(0));
954
955 nmethod* code = method->code();
956 if (code != NULL) {
957 code->make_not_entrant();
958 }
959
960 MethodData* method_data = method->method_data();
961 if (method_data == NULL) {
962 ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
963 method_data = MethodData::allocate(loader_data, method, CHECK);
964 method->set_method_data(method_data);
965 } else {
966 method_data->initialize();
967 }
968 C2V_END
969
970
971 C2V_VMENTRY(void, invalidateInstalledCode, (JNIEnv*, jobject, jobject installed_code))
972 Handle installed_code_handle = JNIHandles::resolve(installed_code);
973 CompilerToVM::invalidate_installed_code(installed_code_handle, CHECK);
974 C2V_END
975
976 C2V_VMENTRY(jobject, readUncompressedOop, (JNIEnv*, jobject, jlong addr))
977 oop ret = oopDesc::load_decode_heap_oop((oop*)(address)addr);
978 return JNIHandles::make_local(THREAD, ret);
979 C2V_END
980
981 C2V_VMENTRY(jlongArray, collectCounters, (JNIEnv*, jobject))
982 typeArrayOop arrayOop = oopFactory::new_longArray(JVMCICounterSize, CHECK_NULL);
983 JavaThread::collect_counters(arrayOop);
984 return (jlongArray) JNIHandles::make_local(THREAD, arrayOop);
985 C2V_END
986
987 C2V_VMENTRY(int, allocateCompileId, (JNIEnv*, jobject, jobject jvmci_method, int entry_bci))
988 HandleMark hm;
989 ResourceMark rm;
990 if (JNIHandles::resolve(jvmci_method) == NULL) {
991 THROW_0(vmSymbols::java_lang_NullPointerException());
992 }
993 Method* method = CompilerToVM::asMethod(jvmci_method);
1000
1001 C2V_VMENTRY(jboolean, isMature, (JNIEnv*, jobject, jlong metaspace_method_data))
1002 MethodData* mdo = CompilerToVM::asMethodData(metaspace_method_data);
1003 return mdo != NULL && mdo->is_mature();
1004 C2V_END
1005
1006 C2V_VMENTRY(jboolean, hasCompiledCodeForOSR, (JNIEnv*, jobject, jobject jvmci_method, int entry_bci, int comp_level))
1007 Method* method = CompilerToVM::asMethod(jvmci_method);
1008 return method->lookup_osr_nmethod_for(entry_bci, comp_level, true) != NULL;
1009 C2V_END
1010
1011 C2V_VMENTRY(jobject, getSymbol, (JNIEnv*, jobject, jlong symbol))
1012 Handle sym = java_lang_String::create_from_symbol((Symbol*)(address)symbol, CHECK_NULL);
1013 return JNIHandles::make_local(THREAD, sym());
1014 C2V_END
1015
1016 bool matches(jobjectArray methods, Method* method) {
1017 objArrayOop methods_oop = (objArrayOop) JNIHandles::resolve(methods);
1018
1019 for (int i = 0; i < methods_oop->length(); i++) {
1020 oop resolved = methods_oop->obj_at(i);
1021 if (resolved->is_a(HotSpotResolvedJavaMethodImpl::klass()) && CompilerToVM::asMethod(resolved) == method) {
1022 return true;
1023 }
1024 }
1025 return false;
1026 }
1027
1028 C2V_VMENTRY(jobject, getNextStackFrame, (JNIEnv*, jobject compilerToVM, jobject hs_frame, jobjectArray methods, jint initialSkip))
1029 ResourceMark rm;
1030
1031 if (!thread->has_last_Java_frame()) return NULL;
1032 Handle result = HotSpotStackFrameReference::klass()->allocate_instance(thread);
1033 HotSpotStackFrameReference::klass()->initialize(thread);
1034
1035 StackFrameStream fst(thread);
1036 if (hs_frame != NULL) {
1037 // look for the correct stack frame if one is given
1038 intptr_t* stack_pointer = (intptr_t*) HotSpotStackFrameReference::stackPointer(hs_frame);
1039 while (fst.current()->sp() != stack_pointer && !fst.is_done()) {
1040 fst.next();
1041 }
1294 // Check if offset and length are non negative.
1295 if (offset < 0 || length < 0) {
1296 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
1297 }
1298 // Check if the range is valid.
1299 if ((((unsigned int) length + (unsigned int) offset) > (unsigned int) array->length())) {
1300 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
1301 }
1302 while (length > 0) {
1303 jbyte* start = array->byte_at_addr(offset);
1304 tty->write((char*) start, MIN2(length, O_BUFLEN));
1305 length -= O_BUFLEN;
1306 offset += O_BUFLEN;
1307 }
1308 C2V_END
1309
1310 C2V_VMENTRY(void, flushDebugOutput, (JNIEnv*, jobject))
1311 tty->flush();
1312 C2V_END
1313
1314 C2V_VMENTRY(int, methodDataProfileDataSize, (JNIEnv*, jobject, jlong metaspace_method_data, jint position))
1315 ResourceMark rm;
1316 MethodData* mdo = CompilerToVM::asMethodData(metaspace_method_data);
1317 ProfileData* profile_data = mdo->data_at(position);
1318 if (mdo->is_valid(profile_data)) {
1319 return profile_data->size_in_bytes();
1320 }
1321 DataLayout* data = mdo->extra_data_base();
1322 DataLayout* end = mdo->extra_data_limit();
1323 for (;; data = mdo->next_extra(data)) {
1324 assert(data < end, "moved past end of extra data");
1325 profile_data = data->data_in();
1326 if (mdo->dp_to_di(profile_data->dp()) == position) {
1327 return profile_data->size_in_bytes();
1328 }
1329 }
1330 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), err_msg("Invalid profile data position %d", position));
1331 C2V_END
1332
1333
1334 #define CC (char*) /*cast a literal from (const char*)*/
1335 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &(c2v_ ## f))
1336
1337 #define STRING "Ljava/lang/String;"
1338 #define OBJECT "Ljava/lang/Object;"
1339 #define CLASS "Ljava/lang/Class;"
1340 #define STACK_TRACE_ELEMENT "Ljava/lang/StackTraceElement;"
1341 #define INSTALLED_CODE "Ljdk/vm/ci/code/InstalledCode;"
1342 #define TARGET_DESCRIPTION "Ljdk/vm/ci/code/TargetDescription;"
1343 #define RESOLVED_METHOD "Ljdk/vm/ci/meta/ResolvedJavaMethod;"
1344 #define HS_RESOLVED_METHOD "Ljdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl;"
1345 #define HS_RESOLVED_KLASS "Ljdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl;"
1346 #define HS_CONSTANT_POOL "Ljdk/vm/ci/hotspot/HotSpotConstantPool;"
1347 #define HS_COMPILED_CODE "Ljdk/vm/ci/hotspot/HotSpotCompiledCode;"
1348 #define HS_CONFIG "Ljdk/vm/ci/hotspot/HotSpotVMConfig;"
1349 #define HS_METADATA "Ljdk/vm/ci/hotspot/HotSpotMetaData;"
1350 #define HS_STACK_FRAME_REF "Ljdk/vm/ci/hotspot/HotSpotStackFrameReference;"
1351 #define HS_SPECULATION_LOG "Ljdk/vm/ci/hotspot/HotSpotSpeculationLog;"
1352 #define METASPACE_METHOD_DATA "J"
1353
1354 JNINativeMethod CompilerToVM::methods[] = {
1355 {CC"getBytecode", CC"("HS_RESOLVED_METHOD")[B", FN_PTR(getBytecode)},
1356 {CC"getExceptionTableStart", CC"("HS_RESOLVED_METHOD")J", FN_PTR(getExceptionTableStart)},
1357 {CC"getExceptionTableLength", CC"("HS_RESOLVED_METHOD")I", FN_PTR(getExceptionTableLength)},
1358 {CC"findUniqueConcreteMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD")"HS_RESOLVED_METHOD, FN_PTR(findUniqueConcreteMethod)},
1359 {CC"getImplementor", CC"("HS_RESOLVED_KLASS")"HS_RESOLVED_KLASS, FN_PTR(getImplementor)},
1360 {CC"getStackTraceElement", CC"("HS_RESOLVED_METHOD"I)"STACK_TRACE_ELEMENT, FN_PTR(getStackTraceElement)},
1361 {CC"methodIsIgnoredBySecurityStackWalk", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(methodIsIgnoredBySecurityStackWalk)},
1362 {CC"doNotInlineOrCompile", CC"("HS_RESOLVED_METHOD")V", FN_PTR(doNotInlineOrCompile)},
1363 {CC"canInlineMethod", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(canInlineMethod)},
1364 {CC"shouldInlineMethod", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(shouldInlineMethod)},
1365 {CC"lookupType", CC"("STRING CLASS"Z)"HS_RESOLVED_KLASS, FN_PTR(lookupType)},
1366 {CC"lookupNameInPool", CC"("HS_CONSTANT_POOL"I)"STRING, FN_PTR(lookupNameInPool)},
1367 {CC"lookupNameAndTypeRefIndexInPool", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(lookupNameAndTypeRefIndexInPool)},
1368 {CC"lookupSignatureInPool", CC"("HS_CONSTANT_POOL"I)"STRING, FN_PTR(lookupSignatureInPool)},
1369 {CC"lookupKlassRefIndexInPool", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(lookupKlassRefIndexInPool)},
1370 {CC"lookupKlassInPool", CC"("HS_CONSTANT_POOL"I)Ljava/lang/Object;", FN_PTR(lookupKlassInPool)},
1371 {CC"lookupAppendixInPool", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(lookupAppendixInPool)},
1372 {CC"lookupMethodInPool", CC"("HS_CONSTANT_POOL"IB)"HS_RESOLVED_METHOD, FN_PTR(lookupMethodInPool)},
1373 {CC"constantPoolRemapInstructionOperandFromCache", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(constantPoolRemapInstructionOperandFromCache)},
1374 {CC"resolveConstantInPool", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(resolveConstantInPool)},
1375 {CC"resolvePossiblyCachedConstantInPool", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(resolvePossiblyCachedConstantInPool)},
1376 {CC"resolveTypeInPool", CC"("HS_CONSTANT_POOL"I)"HS_RESOLVED_KLASS, FN_PTR(resolveTypeInPool)},
1377 {CC"resolveFieldInPool", CC"("HS_CONSTANT_POOL"IB[J)"HS_RESOLVED_KLASS, FN_PTR(resolveFieldInPool)},
1378 {CC"resolveInvokeDynamicInPool", CC"("HS_CONSTANT_POOL"I)V", FN_PTR(resolveInvokeDynamicInPool)},
1379 {CC"resolveInvokeHandleInPool", CC"("HS_CONSTANT_POOL"I)V", FN_PTR(resolveInvokeHandleInPool)},
1380 {CC"resolveMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD HS_RESOLVED_KLASS")"HS_RESOLVED_METHOD, FN_PTR(resolveMethod)},
1381 {CC"getVtableIndexForInterfaceMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD")I", FN_PTR(getVtableIndexForInterfaceMethod)},
1382 {CC"getClassInitializer", CC"("HS_RESOLVED_KLASS")"HS_RESOLVED_METHOD, FN_PTR(getClassInitializer)},
1383 {CC"hasFinalizableSubclass", CC"("HS_RESOLVED_KLASS")Z", FN_PTR(hasFinalizableSubclass)},
1384 {CC"getMaxCallTargetOffset", CC"(J)J", FN_PTR(getMaxCallTargetOffset)},
1385 {CC"getResolvedJavaMethodAtSlot", CC"("CLASS"I)"HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethodAtSlot)},
1386 {CC"getResolvedJavaMethod", CC"(Ljava/lang/Object;J)"HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethod)},
1387 {CC"getConstantPool", CC"(Ljava/lang/Object;J)"HS_CONSTANT_POOL, FN_PTR(getConstantPool)},
1388 {CC"getResolvedJavaType", CC"(Ljava/lang/Object;JZ)"HS_RESOLVED_KLASS, FN_PTR(getResolvedJavaType)},
1389 {CC"initializeConfiguration", CC"("HS_CONFIG")J", FN_PTR(initializeConfiguration)},
1390 {CC"installCode", CC"("TARGET_DESCRIPTION HS_COMPILED_CODE INSTALLED_CODE HS_SPECULATION_LOG")I", FN_PTR(installCode)},
1391 {CC"getMetadata", CC"("TARGET_DESCRIPTION HS_COMPILED_CODE HS_METADATA")I", FN_PTR(getMetadata)},
1392 {CC"notifyCompilationStatistics", CC"(I"HS_RESOLVED_METHOD"ZIJJ"INSTALLED_CODE")V", FN_PTR(notifyCompilationStatistics)},
1393 {CC"resetCompilationStatistics", CC"()V", FN_PTR(resetCompilationStatistics)},
1394 {CC"disassembleCodeBlob", CC"("INSTALLED_CODE")"STRING, FN_PTR(disassembleCodeBlob)},
1395 {CC"executeInstalledCode", CC"(["OBJECT INSTALLED_CODE")"OBJECT, FN_PTR(executeInstalledCode)},
1396 {CC"getLineNumberTable", CC"("HS_RESOLVED_METHOD")[J", FN_PTR(getLineNumberTable)},
1397 {CC"getLocalVariableTableStart", CC"("HS_RESOLVED_METHOD")J", FN_PTR(getLocalVariableTableStart)},
1398 {CC"getLocalVariableTableLength", CC"("HS_RESOLVED_METHOD")I", FN_PTR(getLocalVariableTableLength)},
1399 {CC"reprofile", CC"("HS_RESOLVED_METHOD")V", FN_PTR(reprofile)},
1400 {CC"invalidateInstalledCode", CC"("INSTALLED_CODE")V", FN_PTR(invalidateInstalledCode)},
1401 {CC"readUncompressedOop", CC"(J)"OBJECT, FN_PTR(readUncompressedOop)},
1402 {CC"collectCounters", CC"()[J", FN_PTR(collectCounters)},
1403 {CC"allocateCompileId", CC"("HS_RESOLVED_METHOD"I)I", FN_PTR(allocateCompileId)},
1404 {CC"isMature", CC"("METASPACE_METHOD_DATA")Z", FN_PTR(isMature)},
1405 {CC"hasCompiledCodeForOSR", CC"("HS_RESOLVED_METHOD"II)Z", FN_PTR(hasCompiledCodeForOSR)},
1406 {CC"getSymbol", CC"(J)"STRING, FN_PTR(getSymbol)},
1407 {CC"getNextStackFrame", CC"("HS_STACK_FRAME_REF "["RESOLVED_METHOD"I)"HS_STACK_FRAME_REF, FN_PTR(getNextStackFrame)},
1408 {CC"materializeVirtualObjects", CC"("HS_STACK_FRAME_REF"Z)V", FN_PTR(materializeVirtualObjects)},
1409 {CC"shouldDebugNonSafepoints", CC"()Z", FN_PTR(shouldDebugNonSafepoints)},
1410 {CC"writeDebugOutput", CC"([BII)V", FN_PTR(writeDebugOutput)},
1411 {CC"flushDebugOutput", CC"()V", FN_PTR(flushDebugOutput)},
1412 {CC"methodDataProfileDataSize", CC"(JI)I", FN_PTR(methodDataProfileDataSize)},
1413 };
1414
1415 int CompilerToVM::methods_count() {
1416 return sizeof(methods) / sizeof(JNINativeMethod);
1417 }
1418
|