< prev index next >

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

Print this page

  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)},
< prev index next >