Esempio n. 1
0
 public static void main(String[] args) {
   for (String arg : args) {
     TestCaseData tcase = TestCaseData.valueOf(arg);
     CompilerToVMHelper.writeDebugOutput(tcase.getData(), tcase.offset, tcase.length);
     CompilerToVMHelper.flushDebugOutput();
   }
 }
Esempio n. 2
0
  private static void runSanityTest(Executable aMethod, Integer expectedTableLength) {
    HotSpotResolvedJavaMethod method = CTVMUtilities.getResolvedMethod(aMethod);
    int tableLength = CompilerToVMHelper.getExceptionTableLength(method);
    Asserts.assertEQ(
        tableLength, expectedTableLength, aMethod + " incorrect exception table length.");

    long tableStart = CompilerToVMHelper.getExceptionTableStart(method);
    if (tableLength > 0) {
      Asserts.assertNE(tableStart, 0L, aMethod + " exception table starts " + "at 0.");
    }
  }
Esempio n. 3
0
 @Override
 ConstantPool getConstantPool() {
   ConstantPool cpInst;
   try {
     cpInst = CompilerToVMHelper.getConstantPool(null, getPtrToCpAddress());
     Field field =
         CompilerToVMHelper.HotSpotConstantPoolClass()
             .getDeclaredField("metaspaceConstantPool");
     field.setAccessible(true);
     field.set(cpInst, getPtrToCpAddress());
   } catch (ReflectiveOperationException e) {
     throw new Error("TESTBUG : " + e.getMessage(), e);
   }
   return CompilerToVMHelper.getConstantPool(cpInst, 0L);
 }
 public static void validate(
     jdk.vm.ci.meta.ConstantPool constantPoolCTVM,
     ConstantPool constantPoolSS,
     ConstantPoolTestsHelper.DummyClasses dummyClass,
     int i) {
   Object classToVerify = CompilerToVMHelper.lookupKlassInPool(constantPoolCTVM, i);
   if (!(classToVerify instanceof HotSpotResolvedObjectType)
       && !(classToVerify instanceof String)) {
     String msg =
         String.format(
             "Output of method"
                 + " CTVM.lookupKlassInPool is neither"
                 + " a HotSpotResolvedObjectType, nor a String");
     throw new AssertionError(msg);
   }
   int classNameIndex = (int) dummyClass.cp.get(i).value;
   String classNameToRefer = constantPoolSS.getUTF8At(classNameIndex);
   String outputToVerify = classToVerify.toString();
   if (!outputToVerify.contains(classNameToRefer)) {
     String msg =
         String.format(
             "Wrong class accessed by constant" + " pool index %d: %s, but should be %s",
             i, outputToVerify, classNameToRefer);
     throw new AssertionError(msg);
   }
 }
Esempio n. 5
0
 @Override
 ConstantPool getConstantPool() {
   HotSpotResolvedObjectType type =
       HotSpotResolvedObjectType.fromObjectClass(OBJECT_TYPE_BASE.getClass());
   long ptrToClass = UNSAFE.getKlassPointer(OBJECT_TYPE_BASE);
   return CompilerToVMHelper.getConstantPool(type, getPtrToCpAddress() - ptrToClass);
 }
Esempio n. 6
0
      @Override
      ConstantPool getConstantPool() {
        HotSpotResolvedJavaMethod methodInstance =
            CompilerToVMHelper.getResolvedJavaMethodAtSlot(TEST_CLASS, 0);
        Field field;
        try {
          // jdk.vm.ci.hotspot.HotSpotResolvedJavaMethodImpl.metaspaceMethod
          field = methodInstance.getClass().getDeclaredField("metaspaceMethod");
          field.setAccessible(true);
          field.set(methodInstance, getPtrToCpAddress());
        } catch (ReflectiveOperationException e) {
          throw new Error("TESTBUG : " + e, e);
        }

        return CompilerToVMHelper.getConstantPool(methodInstance, 0L);
      }
Esempio n. 7
0
 private static void testObjectBase() {
   try {
     Object cp = CompilerToVMHelper.getConstantPool(new Object(), 0L);
     throw new AssertionError(
         "Test OBJECT_BASE." + " Expected IllegalArgumentException has not been caught");
   } catch (IllegalArgumentException iae) {
     // expected
   }
 }
 private void runTest(TestCase tcase) {
   System.out.println(tcase);
   HotSpotResolvedObjectType resolvedIface =
       CompilerToVMHelper.lookupType(
           Utils.toJVMTypeSignature(tcase.anInterface), getClass(), /* resolve = */ true);
   HotSpotResolvedObjectType resolvedImplementer =
       CompilerToVMHelper.getImplementor(resolvedIface);
   HotSpotResolvedObjectType resolvedExpected = null;
   if (tcase.expectedImplementer != null) {
     resolvedExpected =
         CompilerToVMHelper.lookupType(
             Utils.toJVMTypeSignature(tcase.expectedImplementer),
             getClass(),
             /* resolve = */ true);
   }
   Asserts.assertEQ(
       resolvedImplementer,
       resolvedExpected,
       "Unexpected implementer for " + tcase.anInterface.getName());
 }
 private void check(boolean materialize) {
   // Materialize virtual objects on last invocation
   if (materialize) {
     HotSpotStackFrameReference hsFrame =
         CompilerToVMHelper.getNextStackFrame(
             /* topmost frame */ null,
             new ResolvedJavaMethod[] {RESOLVED_METHOD}, /* don't skip any */
             0);
     Asserts.assertNotNull(hsFrame, getName() + " : got null frame");
     Asserts.assertTrue(WB.isMethodCompiled(METHOD), getName() + "Test method should be compiled");
     Asserts.assertTrue(
         hsFrame.hasVirtualObjects(),
         getName() + ": has no virtual object before materialization");
     CompilerToVMHelper.materializeVirtualObjects(hsFrame, INVALIDATE);
     Asserts.assertFalse(
         hsFrame.hasVirtualObjects(), getName() + " : has virtual object after materialization");
     Asserts.assertEQ(
         WB.isMethodCompiled(METHOD), !INVALIDATE, getName() + " : unexpected compiled status");
   }
 }
Esempio n. 10
0
 public void test(TestCase testCase) {
   System.out.println(testCase.name());
   ConstantPool cp = testCase.getConstantPool();
   String cpStringRep = cp.toString();
   String cpClassSimpleName = CompilerToVMHelper.HotSpotConstantPoolClass().getSimpleName();
   if (!cpStringRep.contains(cpClassSimpleName) || !cpStringRep.contains(TEST_CLASS.getName())) {
     String msg =
         String.format(
             "%s : "
                 + " Constant pool is not valid."
                 + " String representation should contain \"%s\" and \"%s\"",
             testCase.name(), cpClassSimpleName, TEST_CLASS.getName());
     throw new AssertionError(msg);
   }
 }
  private void checkSanity(CompileCodeTestCase testCase) {
    System.out.println(testCase);
    // to have a clean state
    testCase.deoptimize();
    Pair<Object, ? extends Throwable> reflectionResult;
    Object[] args = Utils.getNullValues(testCase.executable.getParameterTypes());
    reflectionResult = testCase.invoke(args);
    NMethod nMethod = testCase.compile();
    if (nMethod == null) {
      throw new Error(testCase + " : nmethod is null");
    }
    InstalledCode installedCode = testCase.toInstalledCode();
    Object result = null;
    Throwable expectedException = reflectionResult.second;
    boolean gotException = true;
    try {
      args = addReceiver(testCase, args);
      result = CompilerToVMHelper.executeInstalledCode(args, installedCode);
      if (testCase.executable instanceof Constructor) {
        // <init> doesn't have return value, it changes receiver
        result = args[0];
      }
      gotException = false;
    } catch (InvalidInstalledCodeException e) {
      throw new AssertionError(testCase + " : unexpected InvalidInstalledCodeException", e);
    } catch (Throwable t) {
      if (expectedException == null) {
        throw new AssertionError(testCase + " : got unexpected execption : " + t.getMessage(), t);
      }

      if (expectedException.getClass() != t.getClass()) {
        System.err.println("exception from CompilerToVM:");
        t.printStackTrace();
        System.err.println("exception from reflection:");
        expectedException.printStackTrace();
        throw new AssertionError(
            String.format(
                "%s : got unexpected different exceptions : %s != %s",
                testCase, expectedException.getClass(), t.getClass()));
      }
    }

    Asserts.assertEQ(reflectionResult.first, result, testCase + " : different return value");
    if (!gotException) {
      Asserts.assertNull(expectedException, testCase + " : expected exception hasn't been thrown");
    }
  }
Esempio n. 12
0
 private static void testMetaspaceWrapperBase() {
   try {
     Object cp =
         CompilerToVMHelper.getConstantPool(
             new PublicMetaspaceWrapperObject() {
               @Override
               public long getMetaspacePointer() {
                 return getPtrToCpAddress();
               }
             },
             0L);
     throw new AssertionError(
         "Test METASPACE_WRAPPER_BASE."
             + " Expected IllegalArgumentException has not been caught");
   } catch (IllegalArgumentException iae) {
     // expected
   }
 }
  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);
      }
    }
  }
 private void checkNull() {
   Utils.runAndCheckException(
       () -> CompilerToVMHelper.invalidateInstalledCode(null), NullPointerException.class);
 }
Esempio n. 15
0
 @Override
 ConstantPool getConstantPool() {
   return CompilerToVMHelper.getConstantPool(null, getPtrToCpAddress());
 }