8225369: [AOT] vm/classfmt/cpl/cplres001/cplres00101m004/cplres00101m004.html fails

Reviewed-by: kvn, never

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

@@ -582,12 +582,6 @@ C2V_VMENTRY_NULL(jobject, lookupClass, (JNIEnv* env, jobject, jclass mirror))
   return JVMCIENV->get_jobject(result);
 }
 
-C2V_VMENTRY_NULL(jobject, resolveConstantInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
-  constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
-  oop result = cp->resolve_constant_at(index, CHECK_NULL);
-  return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(result));
-C2V_END
-
 C2V_VMENTRY_NULL(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
   constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
   oop result = cp->resolve_possibly_cached_constant_at(index, CHECK_NULL);
@@ -2633,7 +2627,6 @@ JNINativeMethod CompilerToVM::methods[] = {
   {CC "lookupAppendixInPool",                         CC "(" HS_CONSTANT_POOL "I)" OBJECTCONSTANT,                                          FN_PTR(lookupAppendixInPool)},
   {CC "lookupMethodInPool",                           CC "(" HS_CONSTANT_POOL "IB)" HS_RESOLVED_METHOD,                                     FN_PTR(lookupMethodInPool)},
   {CC "constantPoolRemapInstructionOperandFromCache", CC "(" HS_CONSTANT_POOL "I)I",                                                        FN_PTR(constantPoolRemapInstructionOperandFromCache)},
-  {CC "resolveConstantInPool",                        CC "(" HS_CONSTANT_POOL "I)" OBJECTCONSTANT,                                          FN_PTR(resolveConstantInPool)},
   {CC "resolvePossiblyCachedConstantInPool",          CC "(" HS_CONSTANT_POOL "I)" OBJECTCONSTANT,                                          FN_PTR(resolvePossiblyCachedConstantInPool)},
   {CC "resolveTypeInPool",                            CC "(" HS_CONSTANT_POOL "I)" HS_RESOLVED_KLASS,                                       FN_PTR(resolveTypeInPool)},
   {CC "resolveFieldInPool",                           CC "(" HS_CONSTANT_POOL "I" HS_RESOLVED_METHOD "B[I)" HS_RESOLVED_KLASS,              FN_PTR(resolveFieldInPool)},

src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/CompilerToVM.java

@@ -210,21 +210,14 @@ final class CompilerToVM {
 
     native HotSpotResolvedJavaType lookupClass(Class<?> javaClass);
 
-    /**
-     * Resolves the entry at index {@code cpi} in {@code constantPool} to an object.
-     *
-     * The behavior of this method is undefined if {@code cpi} does not denote one of the following
-     * entry types: {@code JVM_CONSTANT_MethodHandle}, {@code JVM_CONSTANT_MethodHandleInError},
-     * {@code JVM_CONSTANT_MethodType} and {@code JVM_CONSTANT_MethodTypeInError}.
-     */
-    native HotSpotObjectConstantImpl resolveConstantInPool(HotSpotConstantPool constantPool, int cpi);
-
     /**
      * Resolves the entry at index {@code cpi} in {@code constantPool} to an object, looking in the
      * constant pool cache first.
      *
-     * The behavior of this method is undefined if {@code cpi} does not denote a
+     * The behavior of this method is undefined if {@code cpi} does not denote one of the following
-     * {@code JVM_CONSTANT_String} entry.
+     * entry types: {@code JVM_CONSTANT_String}, {@code JVM_CONSTANT_MethodHandle},
+     * {@code JVM_CONSTANT_MethodHandleInError}, {@code JVM_CONSTANT_MethodType} and
+     * {@code JVM_CONSTANT_MethodTypeInError}.
      */
     native HotSpotObjectConstantImpl resolvePossiblyCachedConstantInPool(HotSpotConstantPool constantPool, int cpi);
 

src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotConstantPool.java

@@ -545,7 +545,7 @@ public final class HotSpotConstantPool implements ConstantPool, MetaspaceHandleO
             case "MethodHandleInError":
             case "MethodType":
             case "MethodTypeInError":
-                return compilerToVM().resolveConstantInPool(this, cpi);
+                return compilerToVM().resolvePossiblyCachedConstantInPool(this, cpi);
             default:
                 throw new JVMCIError("Unknown constant pool tag %s", tag);
         }

test/hotspot/jtreg/compiler/jvmci/common/patches/jdk.internal.vm.ci/jdk/vm/ci/hotspot/CompilerToVMHelper.java

@@ -101,11 +101,6 @@ public class CompilerToVMHelper {
         }
     }
 
-    public static Object resolveConstantInPool(ConstantPool constantPool, int cpi) {
-        DirectHotSpotObjectConstantImpl obj = (DirectHotSpotObjectConstantImpl) CTVM.resolveConstantInPool((HotSpotConstantPool) constantPool, cpi);
-        return obj.object;
-    }
-
     public static Object resolvePossiblyCachedConstantInPool(ConstantPool constantPool, int cpi) {
         DirectHotSpotObjectConstantImpl obj = (DirectHotSpotObjectConstantImpl) CTVM.resolvePossiblyCachedConstantInPool((HotSpotConstantPool) constantPool, cpi);
         return obj.object;

test/hotspot/jtreg/compiler/jvmci/compilerToVM/ResolveConstantInPoolTest.java

@@ -1,122 +0,0 @@
-/*
- * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-/*
- * @test
- * @bug 8136421
- * @requires vm.jvmci
- * @library /test/lib /
- * @library ../common/patches
- * @modules java.base/jdk.internal.access
- *          java.base/jdk.internal.reflect
- *          java.base/jdk.internal.org.objectweb.asm
- *          jdk.internal.vm.ci/jdk.vm.ci.hotspot
- *          jdk.internal.vm.ci/jdk.vm.ci.runtime
- *          jdk.internal.vm.ci/jdk.vm.ci.meta
- *
- * @build jdk.internal.vm.ci/jdk.vm.ci.hotspot.CompilerToVMHelper sun.hotspot.WhiteBox
- * @run driver ClassFileInstaller sun.hotspot.WhiteBox
- *                                sun.hotspot.WhiteBox$WhiteBoxPermission
- * @run main/othervm -Xbootclasspath/a:.
- *                   -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
- *                   -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
- *                   -XX:-UseJVMCICompiler
- *                   compiler.jvmci.compilerToVM.ResolveConstantInPoolTest
- */
-
-package compiler.jvmci.compilerToVM;
-
-import compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes;
-import compiler.jvmci.compilerToVM.ConstantPoolTestCase.Validator;
-import compiler.jvmci.compilerToVM.ConstantPoolTestsHelper.DummyClasses;
-import jdk.test.lib.Asserts;
-import jdk.vm.ci.hotspot.CompilerToVMHelper;
-import jdk.vm.ci.meta.ConstantPool;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodType;
-import java.util.HashMap;
-import java.util.Map;
-
-import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_METHODHANDLE;
-import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_METHODTYPE;
-
-/**
- * Test for {@code jdk.vm.ci.hotspot.CompilerToVM.resolveConstantInPool} method
- */
-public class ResolveConstantInPoolTest {
-
-    private static final String NOT_NULL_MSG
-            = "Object returned by resolveConstantInPool method should not be null";
-
-    public static void main(String[] args) throws Exception {
-        Map<ConstantTypes, Validator> typeTests = new HashMap<>();
-        typeTests.put(CONSTANT_METHODHANDLE, ResolveConstantInPoolTest::validateMethodHandle);
-        typeTests.put(CONSTANT_METHODTYPE, ResolveConstantInPoolTest::validateMethodType);
-        ConstantPoolTestCase testCase = new ConstantPoolTestCase(typeTests);
-        testCase.test();
-        // The next "Class.forName" and repeating "testCase.test()"
-        // are here for the following reason.
-        // The first test run is without dummy class initialization,
-        // which means no constant pool cache exists.
-        // The second run is with initialized class (with constant pool cache available).
-        // Some CompilerToVM methods require different input
-        // depending on whether CP cache exists or not.
-        for (DummyClasses dummy : DummyClasses.values()) {
-            Class.forName(dummy.klass.getName());
-        }
-        testCase.test();
-    }
-
-    private static void validateMethodHandle(ConstantPool constantPoolCTVM,
-                                             ConstantTypes cpType,
-                                             DummyClasses dummyClass,
-                                             int index) {
-        Object constantInPool = CompilerToVMHelper.resolveConstantInPool(constantPoolCTVM, index);
-        String msg = String.format("%s for index %d", NOT_NULL_MSG, index);
-        Asserts.assertNotNull(constantInPool, msg);
-        if (!(constantInPool instanceof MethodHandle)) {
-            msg = String.format("Wrong constant pool entry accessed by index"
-                                        + " %d: %s, but should be subclass of %s",
-                                index,
-                                constantInPool.getClass(),
-                                MethodHandle.class.getName());
-            throw new AssertionError(msg);
-        }
-    }
-
-    private static void validateMethodType(ConstantPool constantPoolCTVM,
-                                           ConstantTypes cpType,
-                                           DummyClasses dummyClass,
-                                           int index) {
-        Object constantInPool = CompilerToVMHelper.resolveConstantInPool(constantPoolCTVM, index);
-        String msg = String.format("%s for index %d", NOT_NULL_MSG, index);
-        Asserts.assertNotNull(constantInPool, msg);
-        Class mtToVerify = constantInPool.getClass();
-        Class mtToRefer = MethodType.class;
-        msg = String.format("Wrong method type class accessed by"
-                                    + " constant pool index %d",
-                            index);
-        Asserts.assertEQ(mtToRefer, mtToVerify, msg);
-    }
-}

test/hotspot/jtreg/compiler/jvmci/compilerToVM/ResolvePossiblyCachedConstantInPoolTest.java

@@ -24,6 +24,7 @@
 /*
  * @test
  * @bug 8138708
+ * @bug 8136421
  * @requires vm.jvmci
  * @library /test/lib /
  * @library ../common/patches
@@ -54,9 +55,13 @@ import jdk.test.lib.Asserts;
 import jdk.vm.ci.hotspot.CompilerToVMHelper;
 import jdk.vm.ci.meta.ConstantPool;
 
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
 import java.util.HashMap;
 import java.util.Map;
 
+import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_METHODHANDLE;
+import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_METHODTYPE;
 import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_STRING;
 
 /**
@@ -67,10 +72,17 @@ public class ResolvePossiblyCachedConstantInPoolTest {
     public static void main(String[] args) throws Exception {
         Map<ConstantTypes, Validator> typeTests = new HashMap<>();
         typeTests.put(CONSTANT_STRING, ResolvePossiblyCachedConstantInPoolTest::validateString);
+        typeTests.put(CONSTANT_METHODHANDLE, ResolvePossiblyCachedConstantInPoolTest::validateMethodHandle);
+        typeTests.put(CONSTANT_METHODTYPE, ResolvePossiblyCachedConstantInPoolTest::validateMethodType);
         ConstantPoolTestCase testCase = new ConstantPoolTestCase(typeTests);
-        // The next "Class.forName" is here for the following reason.
+        testCase.test();
-        // When class is initialized, constant pool cache is available.
+        // The next "Class.forName" and repeating "testCase.test()"
-        // This method works only with cached constant pool.
+        // are here for the following reason.
+        // The first test run is without dummy class initialization,
+        // which means no constant pool cache exists.
+        // The second run is with initialized class (with constant pool cache available).
+        // Some CompilerToVM methods require different input
+        // depending on whether CP cache exists or not.
         for (DummyClasses dummy : DummyClasses.values()) {
             Class.forName(dummy.klass.getName());
         }
@@ -101,4 +113,40 @@ public class ResolvePossiblyCachedConstantInPoolTest {
         String msg = String.format("Wrong string accessed by %sconstant pool index %d", cached, index);
         Asserts.assertEQ(stringToRefer, stringToVerify, msg);
     }
+
+    private static final String NOT_NULL_MSG
+            = "Object returned by resolvePossiblyCachedConstantInPool method should not be null";
+
+
+    private static void validateMethodHandle(ConstantPool constantPoolCTVM,
+                                             ConstantTypes cpType,
+                                             DummyClasses dummyClass,
+                                             int index) {
+        Object constantInPool = CompilerToVMHelper.resolvePossiblyCachedConstantInPool(constantPoolCTVM, index);
+        String msg = String.format("%s for index %d", NOT_NULL_MSG, index);
+        Asserts.assertNotNull(constantInPool, msg);
+        if (!(constantInPool instanceof MethodHandle)) {
+            msg = String.format("Wrong constant pool entry accessed by index"
+                                        + " %d: %s, but should be subclass of %s",
+                                index,
+                                constantInPool.getClass(),
+                                MethodHandle.class.getName());
+            throw new AssertionError(msg);
+        }
+    }
+
+    private static void validateMethodType(ConstantPool constantPoolCTVM,
+                                           ConstantTypes cpType,
+                                           DummyClasses dummyClass,
+                                           int index) {
+        Object constantInPool = CompilerToVMHelper.resolvePossiblyCachedConstantInPool(constantPoolCTVM, index);
+        String msg = String.format("%s for index %d", NOT_NULL_MSG, index);
+        Asserts.assertNotNull(constantInPool, msg);
+        Class mtToVerify = constantInPool.getClass();
+        Class mtToRefer = MethodType.class;
+        msg = String.format("Wrong method type class accessed by"
+                                    + " constant pool index %d",
+                            index);
+        Asserts.assertEQ(mtToRefer, mtToVerify, msg);
+    }
 }