36 * jdk.vm.ci/jdk.vm.ci.hotspot.PublicMetaspaceWrapperObject
37 * sun.hotspot.WhiteBox
38 * @run driver ClassFileInstaller sun.hotspot.WhiteBox
39 * sun.hotspot.WhiteBox$WhiteBoxPermission
40 * @run main/othervm -Xbootclasspath/a:.
41 * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
42 * -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
43 * -XX:+UseCompressedOops
44 * compiler.jvmci.compilerToVM.GetResolvedJavaTypeTest
45 * @run main/othervm -Xbootclasspath/a:.
46 * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
47 * -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
48 * -XX:-UseCompressedOops
49 * compiler.jvmci.compilerToVM.GetResolvedJavaTypeTest
50 */
51
52 package compiler.jvmci.compilerToVM;
53
54 import jdk.internal.misc.Unsafe;
55 import jdk.test.lib.Asserts;
56 import jdk.test.lib.unsafe.UnsafeHelper;
57 import jdk.vm.ci.hotspot.CompilerToVMHelper;
58 import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod;
59 import jdk.vm.ci.hotspot.HotSpotResolvedObjectType;
60 import jdk.vm.ci.hotspot.PublicMetaspaceWrapperObject;
61 import jdk.vm.ci.meta.ConstantPool;
62 import sun.hotspot.WhiteBox;
63
64 import java.lang.reflect.Field;
65
66 public class GetResolvedJavaTypeTest {
67 private static enum TestCase {
68 NULL_BASE {
69 @Override
70 HotSpotResolvedObjectType getResolvedJavaType() {
71 return CompilerToVMHelper.getResolvedJavaType(
72 null, getPtrToKlass(), COMPRESSED);
73 }
74 },
75 JAVA_METHOD_BASE {
76 @Override
137 long ptr = getPtrToKlass();
138 ConstantPool cpInst = HotSpotResolvedObjectType
139 .fromObjectClass(TEST_CLASS)
140 .getConstantPool();
141 try {
142 Field field = cpInst.getClass()
143 .getDeclaredField("metaspaceConstantPool");
144 field.setAccessible(true);
145 field.set(cpInst, 0L);
146 } catch (ReflectiveOperationException e) {
147 throw new Error("TESTBUG : " + e, e);
148 }
149 return CompilerToVMHelper.getResolvedJavaType(cpInst,
150 ptr, COMPRESSED);
151 }
152 },
153 ;
154 abstract HotSpotResolvedObjectType getResolvedJavaType();
155 }
156
157 private static final Unsafe UNSAFE = UnsafeHelper.getUnsafe();
158 private static final WhiteBox WB = WhiteBox.getWhiteBox();
159 private static final Class TEST_CLASS = GetResolvedJavaTypeTest.class;
160 /* a compressed parameter for tested method is set to false because
161 unsafe.getKlassPointer always returns uncompressed pointer */
162 private static final boolean COMPRESSED = false;
163 // = WB.getBooleanVMFlag("UseCompressedClassPointers");
164
165 private static long getPtrToKlass() {
166 Field field;
167 try {
168 field = TEST_CLASS.getDeclaredField("PTR");
169 } catch (NoSuchFieldException e) {
170 throw new Error("TEST BUG : " + e, e);
171 }
172 Object base = UNSAFE.staticFieldBase(field);
173 return WB.getObjectAddress(base) + UNSAFE.staticFieldOffset(field);
174 }
175
176 public void test(TestCase testCase) {
177 System.out.println(testCase.name());
|
36 * jdk.vm.ci/jdk.vm.ci.hotspot.PublicMetaspaceWrapperObject
37 * sun.hotspot.WhiteBox
38 * @run driver ClassFileInstaller sun.hotspot.WhiteBox
39 * sun.hotspot.WhiteBox$WhiteBoxPermission
40 * @run main/othervm -Xbootclasspath/a:.
41 * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
42 * -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
43 * -XX:+UseCompressedOops
44 * compiler.jvmci.compilerToVM.GetResolvedJavaTypeTest
45 * @run main/othervm -Xbootclasspath/a:.
46 * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
47 * -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
48 * -XX:-UseCompressedOops
49 * compiler.jvmci.compilerToVM.GetResolvedJavaTypeTest
50 */
51
52 package compiler.jvmci.compilerToVM;
53
54 import jdk.internal.misc.Unsafe;
55 import jdk.test.lib.Asserts;
56 import jdk.vm.ci.hotspot.CompilerToVMHelper;
57 import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod;
58 import jdk.vm.ci.hotspot.HotSpotResolvedObjectType;
59 import jdk.vm.ci.hotspot.PublicMetaspaceWrapperObject;
60 import jdk.vm.ci.meta.ConstantPool;
61 import sun.hotspot.WhiteBox;
62
63 import java.lang.reflect.Field;
64
65 public class GetResolvedJavaTypeTest {
66 private static enum TestCase {
67 NULL_BASE {
68 @Override
69 HotSpotResolvedObjectType getResolvedJavaType() {
70 return CompilerToVMHelper.getResolvedJavaType(
71 null, getPtrToKlass(), COMPRESSED);
72 }
73 },
74 JAVA_METHOD_BASE {
75 @Override
136 long ptr = getPtrToKlass();
137 ConstantPool cpInst = HotSpotResolvedObjectType
138 .fromObjectClass(TEST_CLASS)
139 .getConstantPool();
140 try {
141 Field field = cpInst.getClass()
142 .getDeclaredField("metaspaceConstantPool");
143 field.setAccessible(true);
144 field.set(cpInst, 0L);
145 } catch (ReflectiveOperationException e) {
146 throw new Error("TESTBUG : " + e, e);
147 }
148 return CompilerToVMHelper.getResolvedJavaType(cpInst,
149 ptr, COMPRESSED);
150 }
151 },
152 ;
153 abstract HotSpotResolvedObjectType getResolvedJavaType();
154 }
155
156 private static final Unsafe UNSAFE = Unsafe.getUnsafe();
157 private static final WhiteBox WB = WhiteBox.getWhiteBox();
158 private static final Class TEST_CLASS = GetResolvedJavaTypeTest.class;
159 /* a compressed parameter for tested method is set to false because
160 unsafe.getKlassPointer always returns uncompressed pointer */
161 private static final boolean COMPRESSED = false;
162 // = WB.getBooleanVMFlag("UseCompressedClassPointers");
163
164 private static long getPtrToKlass() {
165 Field field;
166 try {
167 field = TEST_CLASS.getDeclaredField("PTR");
168 } catch (NoSuchFieldException e) {
169 throw new Error("TEST BUG : " + e, e);
170 }
171 Object base = UNSAFE.staticFieldBase(field);
172 return WB.getObjectAddress(base) + UNSAFE.staticFieldOffset(field);
173 }
174
175 public void test(TestCase testCase) {
176 System.out.println(testCase.name());
|