10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 #include "classfile/classLoaderData.inline.hpp"
25 #include "classfile/javaClasses.inline.hpp"
26 #include "classfile/stringTable.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/systemDictionary.hpp"
29 #include "classfile/vmClasses.hpp"
30 #include "code/scopeDesc.hpp"
31 #include "compiler/compileBroker.hpp"
32 #include "compiler/compilerEvent.hpp"
33 #include "compiler/compilerOracle.hpp"
34 #include "compiler/disassembler.hpp"
35 #include "compiler/oopMap.hpp"
36 #include "interpreter/bytecodeStream.hpp"
37 #include "interpreter/linkResolver.hpp"
38 #include "interpreter/oopMapCache.hpp"
39 #include "jfr/jfrEvents.hpp"
40 #include "jvmci/jvmciCodeInstaller.hpp"
41 #include "jvmci/jvmciCompilerToVM.hpp"
42 #include "jvmci/jvmciRuntime.hpp"
43 #include "logging/log.hpp"
44 #include "logging/logTag.hpp"
45 #include "memory/oopFactory.hpp"
46 #include "memory/universe.hpp"
47 #include "oops/constantPool.inline.hpp"
48 #include "oops/instanceKlass.inline.hpp"
49 #include "oops/instanceMirrorKlass.hpp"
1189 if (PrintCodeCacheOnCompilation) {
1190 stringStream s;
1191 // Dump code cache into a buffer before locking the tty,
1192 {
1193 MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
1194 CodeCache::print_summary(&s, false);
1195 }
1196 ttyLocker ttyl;
1197 tty->print_raw_cr(s.freeze());
1198 }
1199
1200 if (result != JVMCI::ok) {
1201 assert(cb == nullptr, "should be");
1202 } else {
1203 stats->on_install(cb);
1204 if (installed_code_handle.is_non_null()) {
1205 if (cb->is_nmethod()) {
1206 assert(JVMCIENV->isa_HotSpotNmethod(installed_code_handle), "wrong type");
1207 // Clear the link to an old nmethod first
1208 JVMCIObject nmethod_mirror = installed_code_handle;
1209 JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, true, JVMCI_CHECK_0);
1210 } else {
1211 assert(JVMCIENV->isa_InstalledCode(installed_code_handle), "wrong type");
1212 }
1213 // Initialize the link to the new code blob
1214 JVMCIENV->initialize_installed_code(installed_code_handle, cb, JVMCI_CHECK_0);
1215 }
1216 }
1217 return result;
1218 C2V_END
1219
1220 C2V_VMENTRY(void, resetCompilationStatistics, (JNIEnv* env, jobject))
1221 JVMCICompiler* compiler = JVMCICompiler::instance(true, CHECK);
1222 CompilerStatistics* stats = compiler->stats();
1223 stats->_standard.reset();
1224 stats->_osr.reset();
1225 C2V_END
1226
1227 C2V_VMENTRY_NULL(jobject, disassembleCodeBlob, (JNIEnv* env, jobject, jobject installedCode))
1228 HandleMark hm(THREAD);
1229
1230 if (installedCode == nullptr) {
1231 JVMCI_THROW_MSG_NULL(NullPointerException, "installedCode is null");
1232 }
1233
1234 JVMCIObject installedCodeObject = JVMCIENV->wrap(installedCode);
1235 CodeBlob* cb = JVMCIENV->get_code_blob(installedCodeObject);
1236 if (cb == nullptr) {
1237 return nullptr;
1238 }
1239
1365 if (method_data == nullptr) {
1366 method->build_profiling_method_data(method, CHECK_NULL);
1367 method_data = method->method_data();
1368 if (method_data == nullptr) {
1369 THROW_MSG_NULL(vmSymbols::java_lang_OutOfMemoryError(), "cannot allocate MethodData")
1370 }
1371 }
1372 return method_data;
1373 }
1374
1375 C2V_VMENTRY(void, reprofile, (JNIEnv* env, jobject, ARGUMENT_PAIR(method)))
1376 methodHandle method(THREAD, UNPACK_PAIR(Method, method));
1377 MethodCounters* mcs = method->method_counters();
1378 if (mcs != nullptr) {
1379 mcs->clear_counters();
1380 }
1381 NOT_PRODUCT(method->set_compiled_invocation_count(0));
1382
1383 nmethod* code = method->code();
1384 if (code != nullptr) {
1385 code->make_not_entrant("JVMCI reprofile");
1386 }
1387
1388 MethodData* method_data = method->method_data();
1389 if (method_data == nullptr) {
1390 method_data = get_profiling_method_data(method, CHECK);
1391 } else {
1392 CompilerThreadCanCallJava canCallJava(THREAD, true);
1393 method_data->reinitialize();
1394 }
1395 C2V_END
1396
1397
1398 C2V_VMENTRY(void, invalidateHotSpotNmethod, (JNIEnv* env, jobject, jobject hs_nmethod, jboolean deoptimize))
1399 JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod);
1400 JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, deoptimize, JVMCI_CHECK);
1401 C2V_END
1402
1403 C2V_VMENTRY_NULL(jlongArray, collectCounters, (JNIEnv* env, jobject))
1404 // Returns a zero length array if counters aren't enabled
1405 JVMCIPrimitiveArray array = JVMCIENV->new_longArray(JVMCICounterSize, JVMCI_CHECK_NULL);
1406 if (JVMCICounterSize > 0) {
1407 jlong* temp_array = NEW_RESOURCE_ARRAY(jlong, JVMCICounterSize);
1408 JavaThread::collect_counters(temp_array, JVMCICounterSize);
1409 JVMCIENV->copy_longs_from(temp_array, array, 0, JVMCICounterSize);
1410 }
1411 return (jlongArray) JVMCIENV->get_jobject(array);
1412 C2V_END
1413
1414 C2V_VMENTRY_0(jint, getCountersSize, (JNIEnv* env, jobject))
1415 return (jint) JVMCICounterSize;
1416 C2V_END
1417
1418 C2V_VMENTRY_0(jboolean, setCountersSize, (JNIEnv* env, jobject, jint new_size))
1419 return JavaThread::resize_all_jvmci_counters(new_size);
1420 C2V_END
1805 }
1806
1807 requireInHotSpot("materializeVirtualObjects", JVMCI_CHECK);
1808
1809 JVMCIENV->HotSpotStackFrameReference_initialize(JVMCI_CHECK);
1810
1811 // look for the given stack frame
1812 StackFrameStream fst(thread, false /* update */, true /* process_frames */);
1813 intptr_t* stack_pointer = (intptr_t*) JVMCIENV->get_HotSpotStackFrameReference_stackPointer(hs_frame);
1814 while (fst.current()->id() != stack_pointer && !fst.is_done()) {
1815 fst.next();
1816 }
1817 if (fst.current()->id() != stack_pointer) {
1818 JVMCI_THROW_MSG(IllegalStateException, "stack frame not found");
1819 }
1820
1821 if (invalidate) {
1822 if (!fst.current()->is_compiled_frame()) {
1823 JVMCI_THROW_MSG(IllegalStateException, "compiled stack frame expected");
1824 }
1825 fst.current()->cb()->as_nmethod()->make_not_entrant("JVMCI materialize virtual objects");
1826 }
1827 Deoptimization::deoptimize(thread, *fst.current(), Deoptimization::Reason_none);
1828 // look for the frame again as it has been updated by deopt (pc, deopt state...)
1829 StackFrameStream fstAfterDeopt(thread, true /* update */, true /* process_frames */);
1830 while (fstAfterDeopt.current()->id() != stack_pointer && !fstAfterDeopt.is_done()) {
1831 fstAfterDeopt.next();
1832 }
1833 if (fstAfterDeopt.current()->id() != stack_pointer) {
1834 JVMCI_THROW_MSG(IllegalStateException, "stack frame not found after deopt");
1835 }
1836
1837 vframe* vf = vframe::new_vframe(fstAfterDeopt.current(), fstAfterDeopt.register_map(), thread);
1838 if (!vf->is_compiled_frame()) {
1839 JVMCI_THROW_MSG(IllegalStateException, "compiled stack frame expected");
1840 }
1841
1842 GrowableArray<compiledVFrame*>* virtualFrames = new GrowableArray<compiledVFrame*>(10);
1843 while (true) {
1844 assert(vf->is_compiled_frame(), "Wrong frame type");
1845 virtualFrames->push(compiledVFrame::cast(vf));
3334 {CC "getUncachedStringInPool", CC "(" HS_CONSTANT_POOL2 "I)" JAVACONSTANT, FN_PTR(getUncachedStringInPool)},
3335 {CC "resolveTypeInPool", CC "(" HS_CONSTANT_POOL2 "I)" HS_KLASS, FN_PTR(resolveTypeInPool)},
3336 {CC "resolveFieldInPool", CC "(" HS_CONSTANT_POOL2 "I" HS_METHOD2 "B[I)" HS_KLASS, FN_PTR(resolveFieldInPool)},
3337 {CC "decodeFieldIndexToCPIndex", CC "(" HS_CONSTANT_POOL2 "I)I", FN_PTR(decodeFieldIndexToCPIndex)},
3338 {CC "decodeMethodIndexToCPIndex", CC "(" HS_CONSTANT_POOL2 "I)I", FN_PTR(decodeMethodIndexToCPIndex)},
3339 {CC "decodeIndyIndexToCPIndex", CC "(" HS_CONSTANT_POOL2 "IZ)I", FN_PTR(decodeIndyIndexToCPIndex)},
3340 {CC "resolveInvokeHandleInPool", CC "(" HS_CONSTANT_POOL2 "I)V", FN_PTR(resolveInvokeHandleInPool)},
3341 {CC "isResolvedInvokeHandleInPool", CC "(" HS_CONSTANT_POOL2 "II)I", FN_PTR(isResolvedInvokeHandleInPool)},
3342 {CC "resolveMethod", CC "(" HS_KLASS2 HS_METHOD2 HS_KLASS2 ")" HS_METHOD, FN_PTR(resolveMethod)},
3343 {CC "getSignaturePolymorphicHolders", CC "()[" STRING, FN_PTR(getSignaturePolymorphicHolders)},
3344 {CC "getVtableIndexForInterfaceMethod", CC "(" HS_KLASS2 HS_METHOD2 ")I", FN_PTR(getVtableIndexForInterfaceMethod)},
3345 {CC "getClassInitializer", CC "(" HS_KLASS2 ")" HS_METHOD, FN_PTR(getClassInitializer)},
3346 {CC "hasFinalizableSubclass", CC "(" HS_KLASS2 ")Z", FN_PTR(hasFinalizableSubclass)},
3347 {CC "getMaxCallTargetOffset", CC "(J)J", FN_PTR(getMaxCallTargetOffset)},
3348 {CC "asResolvedJavaMethod", CC "(" EXECUTABLE ")" HS_METHOD, FN_PTR(asResolvedJavaMethod)},
3349 {CC "getResolvedJavaMethod", CC "(" OBJECTCONSTANT "J)" HS_METHOD, FN_PTR(getResolvedJavaMethod)},
3350 {CC "getConstantPool", CC "(" OBJECT "JZ)" HS_CONSTANT_POOL, FN_PTR(getConstantPool)},
3351 {CC "getResolvedJavaType0", CC "(Ljava/lang/Object;JZ)" HS_KLASS, FN_PTR(getResolvedJavaType0)},
3352 {CC "readConfiguration", CC "()[" OBJECT, FN_PTR(readConfiguration)},
3353 {CC "installCode0", CC "(JJZ" HS_COMPILED_CODE "[" OBJECT INSTALLED_CODE "J[B)I", FN_PTR(installCode0)},
3354 {CC "getInstallCodeFlags", CC "()I", FN_PTR(getInstallCodeFlags)},
3355 {CC "resetCompilationStatistics", CC "()V", FN_PTR(resetCompilationStatistics)},
3356 {CC "disassembleCodeBlob", CC "(" INSTALLED_CODE ")" STRING, FN_PTR(disassembleCodeBlob)},
3357 {CC "executeHotSpotNmethod", CC "([" OBJECT HS_NMETHOD ")" OBJECT, FN_PTR(executeHotSpotNmethod)},
3358 {CC "getLineNumberTable", CC "(" HS_METHOD2 ")[J", FN_PTR(getLineNumberTable)},
3359 {CC "getLocalVariableTableStart", CC "(" HS_METHOD2 ")J", FN_PTR(getLocalVariableTableStart)},
3360 {CC "getLocalVariableTableLength", CC "(" HS_METHOD2 ")I", FN_PTR(getLocalVariableTableLength)},
3361 {CC "reprofile", CC "(" HS_METHOD2 ")V", FN_PTR(reprofile)},
3362 {CC "invalidateHotSpotNmethod", CC "(" HS_NMETHOD "Z)V", FN_PTR(invalidateHotSpotNmethod)},
3363 {CC "collectCounters", CC "()[J", FN_PTR(collectCounters)},
3364 {CC "getCountersSize", CC "()I", FN_PTR(getCountersSize)},
3365 {CC "setCountersSize", CC "(I)Z", FN_PTR(setCountersSize)},
3366 {CC "allocateCompileId", CC "(" HS_METHOD2 "I)I", FN_PTR(allocateCompileId)},
3367 {CC "isMature", CC "(J)Z", FN_PTR(isMature)},
3368 {CC "hasCompiledCodeForOSR", CC "(" HS_METHOD2 "II)Z", FN_PTR(hasCompiledCodeForOSR)},
3369 {CC "getSymbol", CC "(J)" STRING, FN_PTR(getSymbol)},
3370 {CC "getSignatureName", CC "(J)" STRING, FN_PTR(getSignatureName)},
3371 {CC "iterateFrames", CC "([" RESOLVED_METHOD "[" RESOLVED_METHOD "I" INSPECTED_FRAME_VISITOR ")" OBJECT, FN_PTR(iterateFrames)},
3372 {CC "materializeVirtualObjects", CC "(" HS_STACK_FRAME_REF "Z)V", FN_PTR(materializeVirtualObjects)},
3373 {CC "shouldDebugNonSafepoints", CC "()Z", FN_PTR(shouldDebugNonSafepoints)},
3374 {CC "writeDebugOutput", CC "(JIZ)V", FN_PTR(writeDebugOutput)},
3375 {CC "flushDebugOutput", CC "()V", FN_PTR(flushDebugOutput)},
3376 {CC "methodDataProfileDataSize", CC "(JI)I", FN_PTR(methodDataProfileDataSize)},
3377 {CC "methodDataExceptionSeen", CC "(JI)I", FN_PTR(methodDataExceptionSeen)},
3378 {CC "interpreterFrameSize", CC "(" BYTECODE_FRAME ")I", FN_PTR(interpreterFrameSize)},
3379 {CC "compileToBytecode", CC "(" OBJECTCONSTANT ")V", FN_PTR(compileToBytecode)},
3380 {CC "getFlagValue", CC "(" STRING ")" OBJECT, FN_PTR(getFlagValue)},
3381 {CC "getInterfaces", CC "(" HS_KLASS2 ")[" HS_KLASS, FN_PTR(getInterfaces)},
3382 {CC "getComponentType", CC "(" HS_KLASS2 ")" HS_RESOLVED_TYPE, FN_PTR(getComponentType)},
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 #include "classfile/classLoaderData.inline.hpp"
25 #include "classfile/javaClasses.inline.hpp"
26 #include "classfile/stringTable.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/systemDictionary.hpp"
29 #include "classfile/vmClasses.hpp"
30 #include "code/nmethod.hpp"
31 #include "code/scopeDesc.hpp"
32 #include "compiler/compileBroker.hpp"
33 #include "compiler/compilerEvent.hpp"
34 #include "compiler/compilerOracle.hpp"
35 #include "compiler/disassembler.hpp"
36 #include "compiler/oopMap.hpp"
37 #include "interpreter/bytecodeStream.hpp"
38 #include "interpreter/linkResolver.hpp"
39 #include "interpreter/oopMapCache.hpp"
40 #include "jfr/jfrEvents.hpp"
41 #include "jvmci/jvmciCodeInstaller.hpp"
42 #include "jvmci/jvmciCompilerToVM.hpp"
43 #include "jvmci/jvmciRuntime.hpp"
44 #include "logging/log.hpp"
45 #include "logging/logTag.hpp"
46 #include "memory/oopFactory.hpp"
47 #include "memory/universe.hpp"
48 #include "oops/constantPool.inline.hpp"
49 #include "oops/instanceKlass.inline.hpp"
50 #include "oops/instanceMirrorKlass.hpp"
1190 if (PrintCodeCacheOnCompilation) {
1191 stringStream s;
1192 // Dump code cache into a buffer before locking the tty,
1193 {
1194 MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
1195 CodeCache::print_summary(&s, false);
1196 }
1197 ttyLocker ttyl;
1198 tty->print_raw_cr(s.freeze());
1199 }
1200
1201 if (result != JVMCI::ok) {
1202 assert(cb == nullptr, "should be");
1203 } else {
1204 stats->on_install(cb);
1205 if (installed_code_handle.is_non_null()) {
1206 if (cb->is_nmethod()) {
1207 assert(JVMCIENV->isa_HotSpotNmethod(installed_code_handle), "wrong type");
1208 // Clear the link to an old nmethod first
1209 JVMCIObject nmethod_mirror = installed_code_handle;
1210 JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, true, nmethod::InvalidationReason::JVMCI_REPLACED_WITH_NEW_CODE, JVMCI_CHECK_0);
1211 } else {
1212 assert(JVMCIENV->isa_InstalledCode(installed_code_handle), "wrong type");
1213 }
1214 // Initialize the link to the new code blob
1215 JVMCIENV->initialize_installed_code(installed_code_handle, cb, JVMCI_CHECK_0);
1216 }
1217 }
1218 return result;
1219 C2V_END
1220
1221 C2V_VMENTRY_0(jobject, getInvalidationReasonDescription, (JNIEnv *env, jobject, jint invalidation_reason))
1222 HandleMark hm(THREAD);
1223 JNIHandleMark jni_hm(thread);
1224 nmethod::InvalidationReason reason = static_cast<nmethod::InvalidationReason>(invalidation_reason);
1225 JVMCIObject desc = JVMCIENV->create_string(nmethod::invalidation_reason_to_string(reason), JVMCI_CHECK_NULL);
1226 return JVMCIENV->get_jobject(desc);
1227 C2V_END
1228
1229 C2V_VMENTRY(void, resetCompilationStatistics, (JNIEnv* env, jobject))
1230 JVMCICompiler* compiler = JVMCICompiler::instance(true, CHECK);
1231 CompilerStatistics* stats = compiler->stats();
1232 stats->_standard.reset();
1233 stats->_osr.reset();
1234 C2V_END
1235
1236 C2V_VMENTRY_NULL(jobject, disassembleCodeBlob, (JNIEnv* env, jobject, jobject installedCode))
1237 HandleMark hm(THREAD);
1238
1239 if (installedCode == nullptr) {
1240 JVMCI_THROW_MSG_NULL(NullPointerException, "installedCode is null");
1241 }
1242
1243 JVMCIObject installedCodeObject = JVMCIENV->wrap(installedCode);
1244 CodeBlob* cb = JVMCIENV->get_code_blob(installedCodeObject);
1245 if (cb == nullptr) {
1246 return nullptr;
1247 }
1248
1374 if (method_data == nullptr) {
1375 method->build_profiling_method_data(method, CHECK_NULL);
1376 method_data = method->method_data();
1377 if (method_data == nullptr) {
1378 THROW_MSG_NULL(vmSymbols::java_lang_OutOfMemoryError(), "cannot allocate MethodData")
1379 }
1380 }
1381 return method_data;
1382 }
1383
1384 C2V_VMENTRY(void, reprofile, (JNIEnv* env, jobject, ARGUMENT_PAIR(method)))
1385 methodHandle method(THREAD, UNPACK_PAIR(Method, method));
1386 MethodCounters* mcs = method->method_counters();
1387 if (mcs != nullptr) {
1388 mcs->clear_counters();
1389 }
1390 NOT_PRODUCT(method->set_compiled_invocation_count(0));
1391
1392 nmethod* code = method->code();
1393 if (code != nullptr) {
1394 code->make_not_entrant(nmethod::InvalidationReason::JVMCI_REPROFILE);
1395 }
1396
1397 MethodData* method_data = method->method_data();
1398 if (method_data == nullptr) {
1399 method_data = get_profiling_method_data(method, CHECK);
1400 } else {
1401 CompilerThreadCanCallJava canCallJava(THREAD, true);
1402 method_data->reinitialize();
1403 }
1404 C2V_END
1405
1406
1407 C2V_VMENTRY(void, invalidateHotSpotNmethod, (JNIEnv* env, jobject, jobject hs_nmethod, jboolean deoptimize, jint invalidation_reason))
1408 int first = static_cast<int>(nmethod::InvalidationReason::C1_CODEPATCH);
1409 int last = static_cast<int>(nmethod::InvalidationReason::INVALIDATION_REASONS_COUNT);
1410 if (invalidation_reason < first || invalidation_reason >= last) {
1411 JVMCI_THROW_MSG(IllegalArgumentException, err_msg("Invalid invalidation_reason: %d", invalidation_reason));
1412 }
1413 JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod);
1414 JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, deoptimize, static_cast<nmethod::InvalidationReason>(invalidation_reason), JVMCI_CHECK);
1415 C2V_END
1416
1417 C2V_VMENTRY_NULL(jlongArray, collectCounters, (JNIEnv* env, jobject))
1418 // Returns a zero length array if counters aren't enabled
1419 JVMCIPrimitiveArray array = JVMCIENV->new_longArray(JVMCICounterSize, JVMCI_CHECK_NULL);
1420 if (JVMCICounterSize > 0) {
1421 jlong* temp_array = NEW_RESOURCE_ARRAY(jlong, JVMCICounterSize);
1422 JavaThread::collect_counters(temp_array, JVMCICounterSize);
1423 JVMCIENV->copy_longs_from(temp_array, array, 0, JVMCICounterSize);
1424 }
1425 return (jlongArray) JVMCIENV->get_jobject(array);
1426 C2V_END
1427
1428 C2V_VMENTRY_0(jint, getCountersSize, (JNIEnv* env, jobject))
1429 return (jint) JVMCICounterSize;
1430 C2V_END
1431
1432 C2V_VMENTRY_0(jboolean, setCountersSize, (JNIEnv* env, jobject, jint new_size))
1433 return JavaThread::resize_all_jvmci_counters(new_size);
1434 C2V_END
1819 }
1820
1821 requireInHotSpot("materializeVirtualObjects", JVMCI_CHECK);
1822
1823 JVMCIENV->HotSpotStackFrameReference_initialize(JVMCI_CHECK);
1824
1825 // look for the given stack frame
1826 StackFrameStream fst(thread, false /* update */, true /* process_frames */);
1827 intptr_t* stack_pointer = (intptr_t*) JVMCIENV->get_HotSpotStackFrameReference_stackPointer(hs_frame);
1828 while (fst.current()->id() != stack_pointer && !fst.is_done()) {
1829 fst.next();
1830 }
1831 if (fst.current()->id() != stack_pointer) {
1832 JVMCI_THROW_MSG(IllegalStateException, "stack frame not found");
1833 }
1834
1835 if (invalidate) {
1836 if (!fst.current()->is_compiled_frame()) {
1837 JVMCI_THROW_MSG(IllegalStateException, "compiled stack frame expected");
1838 }
1839 fst.current()->cb()->as_nmethod()->make_not_entrant(nmethod::InvalidationReason::JVMCI_MATERIALIZE_VIRTUAL_OBJECT);
1840 }
1841 Deoptimization::deoptimize(thread, *fst.current(), Deoptimization::Reason_none);
1842 // look for the frame again as it has been updated by deopt (pc, deopt state...)
1843 StackFrameStream fstAfterDeopt(thread, true /* update */, true /* process_frames */);
1844 while (fstAfterDeopt.current()->id() != stack_pointer && !fstAfterDeopt.is_done()) {
1845 fstAfterDeopt.next();
1846 }
1847 if (fstAfterDeopt.current()->id() != stack_pointer) {
1848 JVMCI_THROW_MSG(IllegalStateException, "stack frame not found after deopt");
1849 }
1850
1851 vframe* vf = vframe::new_vframe(fstAfterDeopt.current(), fstAfterDeopt.register_map(), thread);
1852 if (!vf->is_compiled_frame()) {
1853 JVMCI_THROW_MSG(IllegalStateException, "compiled stack frame expected");
1854 }
1855
1856 GrowableArray<compiledVFrame*>* virtualFrames = new GrowableArray<compiledVFrame*>(10);
1857 while (true) {
1858 assert(vf->is_compiled_frame(), "Wrong frame type");
1859 virtualFrames->push(compiledVFrame::cast(vf));
3348 {CC "getUncachedStringInPool", CC "(" HS_CONSTANT_POOL2 "I)" JAVACONSTANT, FN_PTR(getUncachedStringInPool)},
3349 {CC "resolveTypeInPool", CC "(" HS_CONSTANT_POOL2 "I)" HS_KLASS, FN_PTR(resolveTypeInPool)},
3350 {CC "resolveFieldInPool", CC "(" HS_CONSTANT_POOL2 "I" HS_METHOD2 "B[I)" HS_KLASS, FN_PTR(resolveFieldInPool)},
3351 {CC "decodeFieldIndexToCPIndex", CC "(" HS_CONSTANT_POOL2 "I)I", FN_PTR(decodeFieldIndexToCPIndex)},
3352 {CC "decodeMethodIndexToCPIndex", CC "(" HS_CONSTANT_POOL2 "I)I", FN_PTR(decodeMethodIndexToCPIndex)},
3353 {CC "decodeIndyIndexToCPIndex", CC "(" HS_CONSTANT_POOL2 "IZ)I", FN_PTR(decodeIndyIndexToCPIndex)},
3354 {CC "resolveInvokeHandleInPool", CC "(" HS_CONSTANT_POOL2 "I)V", FN_PTR(resolveInvokeHandleInPool)},
3355 {CC "isResolvedInvokeHandleInPool", CC "(" HS_CONSTANT_POOL2 "II)I", FN_PTR(isResolvedInvokeHandleInPool)},
3356 {CC "resolveMethod", CC "(" HS_KLASS2 HS_METHOD2 HS_KLASS2 ")" HS_METHOD, FN_PTR(resolveMethod)},
3357 {CC "getSignaturePolymorphicHolders", CC "()[" STRING, FN_PTR(getSignaturePolymorphicHolders)},
3358 {CC "getVtableIndexForInterfaceMethod", CC "(" HS_KLASS2 HS_METHOD2 ")I", FN_PTR(getVtableIndexForInterfaceMethod)},
3359 {CC "getClassInitializer", CC "(" HS_KLASS2 ")" HS_METHOD, FN_PTR(getClassInitializer)},
3360 {CC "hasFinalizableSubclass", CC "(" HS_KLASS2 ")Z", FN_PTR(hasFinalizableSubclass)},
3361 {CC "getMaxCallTargetOffset", CC "(J)J", FN_PTR(getMaxCallTargetOffset)},
3362 {CC "asResolvedJavaMethod", CC "(" EXECUTABLE ")" HS_METHOD, FN_PTR(asResolvedJavaMethod)},
3363 {CC "getResolvedJavaMethod", CC "(" OBJECTCONSTANT "J)" HS_METHOD, FN_PTR(getResolvedJavaMethod)},
3364 {CC "getConstantPool", CC "(" OBJECT "JZ)" HS_CONSTANT_POOL, FN_PTR(getConstantPool)},
3365 {CC "getResolvedJavaType0", CC "(Ljava/lang/Object;JZ)" HS_KLASS, FN_PTR(getResolvedJavaType0)},
3366 {CC "readConfiguration", CC "()[" OBJECT, FN_PTR(readConfiguration)},
3367 {CC "installCode0", CC "(JJZ" HS_COMPILED_CODE "[" OBJECT INSTALLED_CODE "J[B)I", FN_PTR(installCode0)},
3368 {CC "getInvalidationReasonDescription", CC "(I)" STRING, FN_PTR(getInvalidationReasonDescription)},
3369 {CC "getInstallCodeFlags", CC "()I", FN_PTR(getInstallCodeFlags)},
3370 {CC "resetCompilationStatistics", CC "()V", FN_PTR(resetCompilationStatistics)},
3371 {CC "disassembleCodeBlob", CC "(" INSTALLED_CODE ")" STRING, FN_PTR(disassembleCodeBlob)},
3372 {CC "executeHotSpotNmethod", CC "([" OBJECT HS_NMETHOD ")" OBJECT, FN_PTR(executeHotSpotNmethod)},
3373 {CC "getLineNumberTable", CC "(" HS_METHOD2 ")[J", FN_PTR(getLineNumberTable)},
3374 {CC "getLocalVariableTableStart", CC "(" HS_METHOD2 ")J", FN_PTR(getLocalVariableTableStart)},
3375 {CC "getLocalVariableTableLength", CC "(" HS_METHOD2 ")I", FN_PTR(getLocalVariableTableLength)},
3376 {CC "reprofile", CC "(" HS_METHOD2 ")V", FN_PTR(reprofile)},
3377 {CC "invalidateHotSpotNmethod", CC "(" HS_NMETHOD "ZI)V", FN_PTR(invalidateHotSpotNmethod)},
3378 {CC "collectCounters", CC "()[J", FN_PTR(collectCounters)},
3379 {CC "getCountersSize", CC "()I", FN_PTR(getCountersSize)},
3380 {CC "setCountersSize", CC "(I)Z", FN_PTR(setCountersSize)},
3381 {CC "allocateCompileId", CC "(" HS_METHOD2 "I)I", FN_PTR(allocateCompileId)},
3382 {CC "isMature", CC "(J)Z", FN_PTR(isMature)},
3383 {CC "hasCompiledCodeForOSR", CC "(" HS_METHOD2 "II)Z", FN_PTR(hasCompiledCodeForOSR)},
3384 {CC "getSymbol", CC "(J)" STRING, FN_PTR(getSymbol)},
3385 {CC "getSignatureName", CC "(J)" STRING, FN_PTR(getSignatureName)},
3386 {CC "iterateFrames", CC "([" RESOLVED_METHOD "[" RESOLVED_METHOD "I" INSPECTED_FRAME_VISITOR ")" OBJECT, FN_PTR(iterateFrames)},
3387 {CC "materializeVirtualObjects", CC "(" HS_STACK_FRAME_REF "Z)V", FN_PTR(materializeVirtualObjects)},
3388 {CC "shouldDebugNonSafepoints", CC "()Z", FN_PTR(shouldDebugNonSafepoints)},
3389 {CC "writeDebugOutput", CC "(JIZ)V", FN_PTR(writeDebugOutput)},
3390 {CC "flushDebugOutput", CC "()V", FN_PTR(flushDebugOutput)},
3391 {CC "methodDataProfileDataSize", CC "(JI)I", FN_PTR(methodDataProfileDataSize)},
3392 {CC "methodDataExceptionSeen", CC "(JI)I", FN_PTR(methodDataExceptionSeen)},
3393 {CC "interpreterFrameSize", CC "(" BYTECODE_FRAME ")I", FN_PTR(interpreterFrameSize)},
3394 {CC "compileToBytecode", CC "(" OBJECTCONSTANT ")V", FN_PTR(compileToBytecode)},
3395 {CC "getFlagValue", CC "(" STRING ")" OBJECT, FN_PTR(getFlagValue)},
3396 {CC "getInterfaces", CC "(" HS_KLASS2 ")[" HS_KLASS, FN_PTR(getInterfaces)},
3397 {CC "getComponentType", CC "(" HS_KLASS2 ")" HS_RESOLVED_TYPE, FN_PTR(getComponentType)},
|