mirror of
https://github.com/openjdk/jdk.git
synced 2025-08-28 15:24:43 +02:00
8187443: Forest Consolidation: Move files to unified layout
Reviewed-by: darcy, ihse
This commit is contained in:
Erik Joelsson
parent
270fe13182
commit
3789983e89
56923 changed files with 3 additions and 15727 deletions
|
|
@ -1,267 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2015, 2016, 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.HotSpotResolvedObjectType;
|
||||
import jdk.vm.ci.meta.ResolvedJavaMethod;
|
||||
import sun.hotspot.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()) {
|
||||
boolean isCPCached = WB.getConstantPoolCacheLength(dummyClass.klass) > -1;
|
||||
System.out.printf("Testing dummy %s with constant pool cached = %b%n",
|
||||
dummyClass.klass,
|
||||
isCPCached);
|
||||
HotSpotResolvedObjectType holder = HotSpotResolvedObjectType.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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue