stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
Reviewed-by: kvn, never
This commit is contained in:
Dean Long 2019-06-24 18:51:54 -04:00
parent d50c63ac29
commit 01c739c34a
6 changed files with 56 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/hotspot/share/jvmci/jvmciCompilerToVM.cpp
View File

@ -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)},

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

@ -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
* {@code JVM_CONSTANT_String} entry.
* The behavior of this method is undefined if {@code cpi} does not denote one of the following
* 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);

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

@ -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);
}

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

@ -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;

122
test/hotspot/jtreg/compiler/jvmci/compilerToVM/ResolveConstantInPoolTest.java
View File

@ -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);
}
}

54
test/hotspot/jtreg/compiler/jvmci/compilerToVM/ResolvePossiblyCachedConstantInPoolTest.java
View File

@ -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.
// When class is initialized, constant pool cache is available.
// This method works only with cached constant pool.
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());
}
@ -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);
}
}