test/compiler/jvmci/compilerToVM/InvalidateInstalledCodeTest.java

@@ -39,18 +39,29 @@
  *      compiler.jvmci.compilerToVM.InvalidateInstalledCodeTest
  */
 
 package compiler.jvmci.compilerToVM;
 
+import compiler.jvmci.common.CTVMUtilities;
 import jdk.vm.ci.code.InstalledCode;
 import jdk.vm.ci.hotspot.CompilerToVMHelper;
 import jdk.test.lib.Asserts;
+import jdk.test.lib.Utils;
 import sun.hotspot.code.NMethod;
 
 import java.util.List;
+import jdk.vm.ci.code.CodeCacheProvider;
+import jdk.vm.ci.code.CompilationResult;
+import jdk.vm.ci.hotspot.HotSpotCompilationRequest;
+import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime;
+import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod;
 
 public class InvalidateInstalledCodeTest {
+    private static final CodeCacheProvider CACHE_PROVIDER
+            = HotSpotJVMCIRuntime.runtime().getHostJVMCIBackend()
+                    .getCodeCache();
+
     public static void main(String[] args) {
         InvalidateInstalledCodeTest test
                 = new InvalidateInstalledCodeTest();
         List<CompileCodeTestCase> testCases
                 = CompileCodeTestCase.generate(/* bci = */ 0);

@@ -58,37 +69,46 @@
         testCases.forEach(test::check);
         test.checkNull();
     }
 
     private void checkNull() {
-        InstalledCode installedCode = new InstalledCode("<null>");
-        installedCode.setAddress(0);
+        InstalledCode installedCode = CTVMUtilities.getInstalledCode(
+                "<null>", 0L, 0L);
         CompilerToVMHelper.invalidateInstalledCode(installedCode);
     }
 
     private void check(CompileCodeTestCase testCase) {
         System.out.println(testCase);
-        // to have a clean state
-        NMethod beforeInvalidation = testCase.deoptimizeAndCompile();
-        if (beforeInvalidation == null) {
-            throw new Error("method is not compiled, testCase " + testCase);
+        HotSpotResolvedJavaMethod javaMethod
+                = CTVMUtilities.getResolvedMethod(testCase.executable);
+        HotSpotCompilationRequest compRequest = new HotSpotCompilationRequest(
+                javaMethod, testCase.bci, /* jvmciEnv = */ 0L);
+        String name = testCase.executable.getName();
+        CompilationResult compResult = new CompilationResult(name);
+        // to pass sanity check of default -1
+        compResult.setTotalFrameSize(0);
+        InstalledCode installedCode = CACHE_PROVIDER.installCode(
+                compRequest, compResult,
+                new InstalledCode(name), /* speculationLog = */ null,
+                /* isDefault = */ false);
+        Asserts.assertTrue(installedCode.isValid(), testCase
+                + " : code is invalid even before invalidation");
+
+        NMethod beforeInvalidation = testCase.toNMethod();
+        if (beforeInvalidation != null) {
+            throw new Error("TESTBUG : " + testCase + " : nmethod isn't found");
         }
-
         // run twice to verify how it works if method is already invalidated
         for (int i = 0; i < 2; ++i) {
-            InstalledCode installedCode = new InstalledCode(
-                    testCase.executable.getName());
-            installedCode.setAddress(beforeInvalidation.address);
-
             CompilerToVMHelper.invalidateInstalledCode(installedCode);
+            Asserts.assertFalse(installedCode.isValid(), testCase
+                            + " : code is valid after invalidation, i = " + i);
             NMethod afterInvalidation = testCase.toNMethod();
             if (afterInvalidation != null) {
                 System.err.println("before: " + beforeInvalidation);
                 System.err.println("after: " + afterInvalidation);
                 throw new AssertionError(testCase
                         + " : method hasn't been invalidated, i = " + i);
             }
-            Asserts.assertFalse(installedCode.isValid(), testCase
-                            + " : code is valid after invalidation, i = " + i);
         }
     }
 }