test/compiler/jvmci/compilerToVM/InvalidateInstalledCodeTest.java

*** 39,56 ****
--- 39,67 ----
   *      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,94 ****
          testCases.forEach(test::check);
          test.checkNull();
      }
  
      private void checkNull() {
!         InstalledCode installedCode = new InstalledCode("<null>");
!         installedCode.setAddress(0);
          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);
          }
- 
          // 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);
              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);
          }
      }
  }
--- 69,114 ----
          testCases.forEach(test::check);
          test.checkNull();
      }
  
      private void checkNull() {
!         InstalledCode installedCode = CTVMUtilities.getInstalledCode(
!                 "<null>", 0L, 0L);
          CompilerToVMHelper.invalidateInstalledCode(installedCode);
      }
  
      private void check(CompileCodeTestCase testCase) {
          System.out.println(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) {
              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);
              }
          }
      }
  }