< prev index next >

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

Print this page
@@ -25,10 +25,11 @@
  #include "classfile/javaClasses.inline.hpp"
  #include "classfile/stringTable.hpp"
  #include "classfile/symbolTable.hpp"
  #include "classfile/systemDictionary.hpp"
  #include "classfile/vmClasses.hpp"
+ #include "code/nmethod.hpp"
  #include "code/scopeDesc.hpp"
  #include "compiler/compileBroker.hpp"
  #include "compiler/compilerEvent.hpp"
  #include "compiler/compilerOracle.hpp"
  #include "compiler/disassembler.hpp"

@@ -1204,21 +1205,29 @@
      if (installed_code_handle.is_non_null()) {
        if (cb->is_nmethod()) {
          assert(JVMCIENV->isa_HotSpotNmethod(installed_code_handle), "wrong type");
          // Clear the link to an old nmethod first
          JVMCIObject nmethod_mirror = installed_code_handle;
-         JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, true, JVMCI_CHECK_0);
+         JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, true, nmethod::InvalidationReason::JVMCI_REPLACED_WITH_NEW_CODE, JVMCI_CHECK_0);
        } else {
          assert(JVMCIENV->isa_InstalledCode(installed_code_handle), "wrong type");
        }
        // Initialize the link to the new code blob
        JVMCIENV->initialize_installed_code(installed_code_handle, cb, JVMCI_CHECK_0);
      }
    }
    return result;
  C2V_END
  
+ C2V_VMENTRY_0(jobject, getInvalidationReasonDescription, (JNIEnv *env, jobject, jint invalidation_reason))
+   HandleMark hm(THREAD);
+   JNIHandleMark jni_hm(thread);
+   nmethod::InvalidationReason reason = static_cast<nmethod::InvalidationReason>(invalidation_reason);
+   JVMCIObject desc = JVMCIENV->create_string(nmethod::invalidation_reason_to_string(reason), JVMCI_CHECK_NULL);
+   return JVMCIENV->get_jobject(desc);
+ C2V_END
+ 
  C2V_VMENTRY(void, resetCompilationStatistics, (JNIEnv* env, jobject))
    JVMCICompiler* compiler = JVMCICompiler::instance(true, CHECK);
    CompilerStatistics* stats = compiler->stats();
    stats->_standard.reset();
    stats->_osr.reset();

@@ -1380,11 +1389,11 @@
    }
    NOT_PRODUCT(method->set_compiled_invocation_count(0));
  
    nmethod* code = method->code();
    if (code != nullptr) {
-     code->make_not_entrant("JVMCI reprofile");
+     code->make_not_entrant(nmethod::InvalidationReason::JVMCI_REPROFILE);
    }
  
    MethodData* method_data = method->method_data();
    if (method_data == nullptr) {
      method_data = get_profiling_method_data(method, CHECK);

@@ -1393,13 +1402,18 @@
      method_data->reinitialize();
    }
  C2V_END
  
  
- C2V_VMENTRY(void, invalidateHotSpotNmethod, (JNIEnv* env, jobject, jobject hs_nmethod, jboolean deoptimize))
+ C2V_VMENTRY(void, invalidateHotSpotNmethod, (JNIEnv* env, jobject, jobject hs_nmethod, jboolean deoptimize, jint invalidation_reason))
+   int first = static_cast<int>(nmethod::InvalidationReason::C1_CODEPATCH);
+   int last = static_cast<int>(nmethod::InvalidationReason::INVALIDATION_REASONS_COUNT);
+   if (invalidation_reason < first || invalidation_reason >= last) {
+     JVMCI_THROW_MSG(IllegalArgumentException, err_msg("Invalid invalidation_reason: %d", invalidation_reason));
+   }
    JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod);
-   JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, deoptimize, JVMCI_CHECK);
+   JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, deoptimize, static_cast<nmethod::InvalidationReason>(invalidation_reason), JVMCI_CHECK);
  C2V_END
  
  C2V_VMENTRY_NULL(jlongArray, collectCounters, (JNIEnv* env, jobject))
    // Returns a zero length array if counters aren't enabled
    JVMCIPrimitiveArray array = JVMCIENV->new_longArray(JVMCICounterSize, JVMCI_CHECK_NULL);

@@ -1820,11 +1834,11 @@
  
    if (invalidate) {
      if (!fst.current()->is_compiled_frame()) {
        JVMCI_THROW_MSG(IllegalStateException, "compiled stack frame expected");
      }
-     fst.current()->cb()->as_nmethod()->make_not_entrant("JVMCI materialize virtual objects");
+     fst.current()->cb()->as_nmethod()->make_not_entrant(nmethod::InvalidationReason::JVMCI_MATERIALIZE_VIRTUAL_OBJECT);
    }
    Deoptimization::deoptimize(thread, *fst.current(), Deoptimization::Reason_none);
    // look for the frame again as it has been updated by deopt (pc, deopt state...)
    StackFrameStream fstAfterDeopt(thread, true /* update */, true /* process_frames */);
    while (fstAfterDeopt.current()->id() != stack_pointer && !fstAfterDeopt.is_done()) {

@@ -3349,19 +3363,20 @@
    {CC "getResolvedJavaMethod",                        CC "(" OBJECTCONSTANT "J)" HS_METHOD,                                                 FN_PTR(getResolvedJavaMethod)},
    {CC "getConstantPool",                              CC "(" OBJECT "JZ)" HS_CONSTANT_POOL,                                                 FN_PTR(getConstantPool)},
    {CC "getResolvedJavaType0",                         CC "(Ljava/lang/Object;JZ)" HS_KLASS,                                                 FN_PTR(getResolvedJavaType0)},
    {CC "readConfiguration",                            CC "()[" OBJECT,                                                                      FN_PTR(readConfiguration)},
    {CC "installCode0",                                 CC "(JJZ" HS_COMPILED_CODE "[" OBJECT INSTALLED_CODE "J[B)I",                         FN_PTR(installCode0)},
+   {CC "getInvalidationReasonDescription",             CC "(I)" STRING,                                                                      FN_PTR(getInvalidationReasonDescription)},
    {CC "getInstallCodeFlags",                          CC "()I",                                                                             FN_PTR(getInstallCodeFlags)},
    {CC "resetCompilationStatistics",                   CC "()V",                                                                             FN_PTR(resetCompilationStatistics)},
    {CC "disassembleCodeBlob",                          CC "(" INSTALLED_CODE ")" STRING,                                                     FN_PTR(disassembleCodeBlob)},
    {CC "executeHotSpotNmethod",                        CC "([" OBJECT HS_NMETHOD ")" OBJECT,                                                 FN_PTR(executeHotSpotNmethod)},
    {CC "getLineNumberTable",                           CC "(" HS_METHOD2 ")[J",                                                              FN_PTR(getLineNumberTable)},
    {CC "getLocalVariableTableStart",                   CC "(" HS_METHOD2 ")J",                                                               FN_PTR(getLocalVariableTableStart)},
    {CC "getLocalVariableTableLength",                  CC "(" HS_METHOD2 ")I",                                                               FN_PTR(getLocalVariableTableLength)},
    {CC "reprofile",                                    CC "(" HS_METHOD2 ")V",                                                               FN_PTR(reprofile)},
-   {CC "invalidateHotSpotNmethod",                     CC "(" HS_NMETHOD "Z)V",                                                              FN_PTR(invalidateHotSpotNmethod)},
+   {CC "invalidateHotSpotNmethod",                     CC "(" HS_NMETHOD "ZI)V",                                                             FN_PTR(invalidateHotSpotNmethod)},
    {CC "collectCounters",                              CC "()[J",                                                                            FN_PTR(collectCounters)},
    {CC "getCountersSize",                              CC "()I",                                                                             FN_PTR(getCountersSize)},
    {CC "setCountersSize",                              CC "(I)Z",                                                                            FN_PTR(setCountersSize)},
    {CC "allocateCompileId",                            CC "(" HS_METHOD2 "I)I",                                                              FN_PTR(allocateCompileId)},
    {CC "isMature",                                     CC "(J)Z",                                                                            FN_PTR(isMature)},
< prev index next >