ffa35d8cf1
Co-authored-by: Gui Cao <gcao@openjdk.org> Co-authored-by: Fei Yang <fyang@openjdk.org> Co-authored-by: Martin Doerr <mdoerr@openjdk.org> Co-authored-by: Amit Kumar <amitkumar@openjdk.org> Reviewed-by: coleenp, adinn, fparain
267 lines
12 KiB
Java
267 lines
12 KiB
Java
/*
|
|
* Copyright (c) 2015, 2022, 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.
|
|
*/
|
|
|
|
package compiler.jvmci.compilerToVM;
|
|
|
|
import compiler.jvmci.compilerToVM.ConstantPoolTestsHelper.DummyClasses;
|
|
import jdk.internal.reflect.ConstantPool;
|
|
import jdk.internal.reflect.ConstantPool.Tag;
|
|
import jdk.vm.ci.hotspot.CompilerToVMHelper;
|
|
import jdk.vm.ci.hotspot.HotSpotResolvedObjectType;
|
|
import jdk.vm.ci.meta.ResolvedJavaMethod;
|
|
import jdk.test.whitebox.WhiteBox;
|
|
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_CLASS;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_DOUBLE;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_FIELDREF;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_FLOAT;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_INTEGER;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_INTERFACEMETHODREF;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_INVALID;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_INVOKEDYNAMIC;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_LONG;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_METHODHANDLE;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_METHODREF;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_METHODTYPE;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_NAMEANDTYPE;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_STRING;
|
|
import static compiler.jvmci.compilerToVM.ConstantPoolTestCase.ConstantTypes.CONSTANT_UTF8;
|
|
|
|
/**
|
|
* Common class for jdk.vm.ci.hotspot.CompilerToVM constant pool tests
|
|
*/
|
|
public class ConstantPoolTestCase {
|
|
|
|
private static final Map<Tag, ConstantTypes> TAG_TO_TYPE_MAP;
|
|
static {
|
|
TAG_TO_TYPE_MAP = new HashMap<>();
|
|
TAG_TO_TYPE_MAP.put(Tag.CLASS, CONSTANT_CLASS);
|
|
TAG_TO_TYPE_MAP.put(Tag.FIELDREF, CONSTANT_FIELDREF);
|
|
TAG_TO_TYPE_MAP.put(Tag.METHODREF, CONSTANT_METHODREF);
|
|
TAG_TO_TYPE_MAP.put(Tag.INTERFACEMETHODREF, CONSTANT_INTERFACEMETHODREF);
|
|
TAG_TO_TYPE_MAP.put(Tag.STRING, CONSTANT_STRING);
|
|
TAG_TO_TYPE_MAP.put(Tag.INTEGER, CONSTANT_INTEGER);
|
|
TAG_TO_TYPE_MAP.put(Tag.FLOAT, CONSTANT_FLOAT);
|
|
TAG_TO_TYPE_MAP.put(Tag.LONG, CONSTANT_LONG);
|
|
TAG_TO_TYPE_MAP.put(Tag.DOUBLE, CONSTANT_DOUBLE);
|
|
TAG_TO_TYPE_MAP.put(Tag.NAMEANDTYPE, CONSTANT_NAMEANDTYPE);
|
|
TAG_TO_TYPE_MAP.put(Tag.UTF8, CONSTANT_UTF8);
|
|
TAG_TO_TYPE_MAP.put(Tag.METHODHANDLE, CONSTANT_METHODHANDLE);
|
|
TAG_TO_TYPE_MAP.put(Tag.METHODTYPE, CONSTANT_METHODTYPE);
|
|
TAG_TO_TYPE_MAP.put(Tag.INVOKEDYNAMIC, CONSTANT_INVOKEDYNAMIC);
|
|
TAG_TO_TYPE_MAP.put(Tag.INVALID, CONSTANT_INVALID);
|
|
}
|
|
private static final WhiteBox WB = WhiteBox.getWhiteBox();
|
|
private final Map<ConstantTypes, Validator> typeTests;
|
|
|
|
public static enum ConstantTypes {
|
|
CONSTANT_CLASS {
|
|
@Override
|
|
public TestedCPEntry getTestedCPEntry(DummyClasses dummyClass, int index) {
|
|
ConstantPool constantPoolSS = dummyClass.constantPoolSS;
|
|
checkIndex(constantPoolSS, index);
|
|
Class<?> klass = constantPoolSS.getClassAt(index);
|
|
String klassName = klass.getName();
|
|
TestedCPEntry[] testedEntries = dummyClass.testedCP.get(this);
|
|
for (TestedCPEntry entry : testedEntries) {
|
|
if (entry.klass.replaceAll("/", "\\.").equals(klassName)) {
|
|
return entry;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
},
|
|
CONSTANT_FIELDREF {
|
|
@Override
|
|
public TestedCPEntry getTestedCPEntry(DummyClasses dummyClass, int index) {
|
|
return this.getTestedCPEntryForMethodAndField(dummyClass, index);
|
|
}
|
|
},
|
|
CONSTANT_METHODREF {
|
|
@Override
|
|
public TestedCPEntry getTestedCPEntry(DummyClasses dummyClass, int index) {
|
|
return this.getTestedCPEntryForMethodAndField(dummyClass, index);
|
|
}
|
|
},
|
|
CONSTANT_INTERFACEMETHODREF {
|
|
@Override
|
|
public TestedCPEntry getTestedCPEntry(DummyClasses dummyClass, int index) {
|
|
return this.getTestedCPEntryForMethodAndField(dummyClass, index);
|
|
}
|
|
},
|
|
CONSTANT_STRING {
|
|
@Override
|
|
public TestedCPEntry getTestedCPEntry(DummyClasses dummyClass, int index) {
|
|
ConstantPool constantPoolSS = dummyClass.constantPoolSS;
|
|
checkIndex(constantPoolSS, index);
|
|
String value = constantPoolSS.getStringAt(index);
|
|
TestedCPEntry[] testedEntries = dummyClass.testedCP.get(this);
|
|
for (TestedCPEntry entry : testedEntries) {
|
|
if (entry.name.equals(value)) {
|
|
return entry;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
},
|
|
CONSTANT_INTEGER,
|
|
CONSTANT_FLOAT,
|
|
CONSTANT_LONG,
|
|
CONSTANT_DOUBLE,
|
|
CONSTANT_NAMEANDTYPE,
|
|
CONSTANT_UTF8,
|
|
CONSTANT_METHODHANDLE,
|
|
CONSTANT_METHODTYPE,
|
|
CONSTANT_INVOKEDYNAMIC {
|
|
@Override
|
|
public TestedCPEntry getTestedCPEntry(DummyClasses dummyClass, int index) {
|
|
ConstantPool constantPoolSS = dummyClass.constantPoolSS;
|
|
checkIndex(constantPoolSS, index);
|
|
int nameAndTypeIndex = constantPoolSS.getNameAndTypeRefIndexAt(index);
|
|
String[] info = constantPoolSS.getNameAndTypeRefInfoAt(nameAndTypeIndex);
|
|
TestedCPEntry[] testedEntries = dummyClass.testedCP.get(this);
|
|
for (TestedCPEntry entry : testedEntries) {
|
|
if (info[0].equals(entry.name) && info[1].equals(entry.type)) {
|
|
return entry;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
},
|
|
CONSTANT_INVALID;
|
|
|
|
public TestedCPEntry getTestedCPEntry(DummyClasses dummyClass, int index) {
|
|
return null; // returning null by default
|
|
}
|
|
|
|
public TestedCPEntry[] getAllCPEntriesForType(DummyClasses dummyClass) {
|
|
TestedCPEntry[] toReturn = dummyClass.testedCP.get(this);
|
|
if (toReturn == null) {
|
|
return new TestedCPEntry[0];
|
|
}
|
|
return dummyClass.testedCP.get(this);
|
|
}
|
|
|
|
protected TestedCPEntry getTestedCPEntryForMethodAndField(DummyClasses dummyClass, int index) {
|
|
ConstantPool constantPoolSS = dummyClass.constantPoolSS;
|
|
checkIndex(constantPoolSS, index);
|
|
String[] info = constantPoolSS.getMemberRefInfoAt(index);
|
|
TestedCPEntry[] testedEntries = dummyClass.testedCP.get(this);
|
|
for (TestedCPEntry entry : testedEntries) {
|
|
if (info[0].equals(entry.klass) && info[1].equals(entry.name) && info[2].equals(entry.type)) {
|
|
return entry;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected void checkIndex(ConstantPool constantPoolSS, int index) {
|
|
ConstantPool.Tag tag = constantPoolSS.getTagAt(index);
|
|
ConstantTypes type = mapTagToCPType(tag);
|
|
if (!this.equals(type)) {
|
|
String msg = String.format("TESTBUG: CP tag should be a %s, but is %s",
|
|
this.name(),
|
|
type.name());
|
|
throw new Error(msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static interface Validator {
|
|
void validate(jdk.vm.ci.meta.ConstantPool constantPoolCTVM,
|
|
ConstantTypes cpType,
|
|
DummyClasses dummyClass,
|
|
int index);
|
|
}
|
|
|
|
public static class TestedCPEntry {
|
|
public final String klass;
|
|
public final String name;
|
|
public final String type;
|
|
public final ResolvedJavaMethod[] methods;
|
|
public final byte[] opcodes;
|
|
public final int accFlags;
|
|
|
|
public TestedCPEntry(String klass, String name, String type, byte[] opcodes, int accFlags) {
|
|
this(klass, name, type, null, opcodes, accFlags);
|
|
}
|
|
|
|
public TestedCPEntry(String klass, String name, String type, ResolvedJavaMethod[] methods, byte[] opcodes, int accFlags) {
|
|
this.klass = klass;
|
|
this.name = name;
|
|
this.type = type;
|
|
if (methods != null) {
|
|
this.methods = new ResolvedJavaMethod[methods.length];
|
|
System.arraycopy(methods, 0, this.methods, 0, methods.length);
|
|
} else {
|
|
this.methods = null;
|
|
}
|
|
if (opcodes != null) {
|
|
this.opcodes = new byte[opcodes.length];
|
|
System.arraycopy(opcodes, 0, this.opcodes, 0, opcodes.length);
|
|
} else {
|
|
this.opcodes = null;
|
|
}
|
|
this.accFlags = accFlags;
|
|
}
|
|
|
|
public TestedCPEntry(String klass, String name, String type, byte[] opcodes) {
|
|
this(klass, name, type, opcodes, 0);
|
|
}
|
|
|
|
public TestedCPEntry(String klass, String name, String type) {
|
|
this(klass, name, type, null, 0);
|
|
}
|
|
}
|
|
|
|
public static ConstantTypes mapTagToCPType(Tag tag) {
|
|
return TAG_TO_TYPE_MAP.get(tag);
|
|
}
|
|
|
|
public ConstantPoolTestCase(Map<ConstantTypes, Validator> typeTests) {
|
|
this.typeTests = new HashMap<>();
|
|
this.typeTests.putAll(typeTests);
|
|
}
|
|
|
|
public void test() {
|
|
for (DummyClasses dummyClass : DummyClasses.values()) {
|
|
System.out.printf("Testing dummy %s with constant pool",
|
|
dummyClass.klass);
|
|
HotSpotResolvedObjectType holder = CompilerToVMHelper.fromObjectClass(dummyClass.klass);
|
|
jdk.vm.ci.meta.ConstantPool constantPoolCTVM = holder.getConstantPool();
|
|
ConstantPool constantPoolSS = dummyClass.constantPoolSS;
|
|
for (int i = 0; i < constantPoolSS.getSize(); i++) {
|
|
Tag tag = constantPoolSS.getTagAt(i);
|
|
ConstantTypes cpType = mapTagToCPType(tag);
|
|
if (!typeTests.keySet().contains(cpType)) {
|
|
continue;
|
|
}
|
|
typeTests.get(cpType).validate(constantPoolCTVM, cpType, dummyClass, i);
|
|
}
|
|
}
|
|
}
|
|
}
|