GetResolvedJavaTypeTest.java revision 9111:a41fe5ffa839 
1/*
2 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/*
25 * @test
26 * @bug 8136421
27 * @requires (os.simpleArch == "x64" | os.simpleArch == "sparcv9") & os.arch != "aarch64"
28 * @library / /testlibrary /../../test/lib
29 * @compile ../common/CompilerToVMHelper.java
30 * @build compiler.jvmci.compilerToVM.GetResolvedJavaTypeTest
31 * @run main ClassFileInstaller
32 *      sun.hotspot.WhiteBox
33 *      sun.hotspot.WhiteBox$WhiteBoxPermission
34 *      jdk.vm.ci.hotspot.CompilerToVMHelper
35 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockExperimentalVMOptions
36 *      -XX:+EnableJVMCI -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
37 *      -XX:+UseCompressedOops
38 *      compiler.jvmci.compilerToVM.GetResolvedJavaTypeTest
39 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockExperimentalVMOptions
40 *      -XX:+EnableJVMCI -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
41 *      -XX:-UseCompressedOops
42 *      compiler.jvmci.compilerToVM.GetResolvedJavaTypeTest
43 */
44
45package compiler.jvmci.compilerToVM;
46
47import java.lang.reflect.Field;
48import jdk.vm.ci.hotspot.CompilerToVMHelper;
49import jdk.vm.ci.hotspot.HotSpotConstantPool;
50import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethodImpl;
51import jdk.vm.ci.hotspot.HotSpotResolvedObjectTypeImpl;
52import jdk.vm.ci.hotspot.MetaspaceWrapperObject;
53import jdk.test.lib.Asserts;
54import jdk.test.lib.Utils;
55import sun.hotspot.WhiteBox;
56import sun.misc.Unsafe;
57
58public class GetResolvedJavaTypeTest {
59    private static enum TestCase {
60        NULL_BASE {
61            @Override
62            HotSpotResolvedObjectTypeImpl getResolvedJavaType() {
63                return CompilerToVMHelper.getResolvedJavaType(
64                        null, getPtrToKlass(), COMPRESSED);
65            }
66        },
67        JAVA_METHOD_BASE {
68            @Override
69            HotSpotResolvedObjectTypeImpl getResolvedJavaType() {
70                HotSpotResolvedJavaMethodImpl methodInstance
71                        = CompilerToVMHelper.getResolvedJavaMethodAtSlot(
72                        TEST_CLASS, 0);
73                Field field;
74                try {
75                    field = HotSpotResolvedJavaMethodImpl
76                            .class.getDeclaredField("metaspaceMethod");
77                    field.setAccessible(true);
78                    field.set(methodInstance, getPtrToKlass());
79                } catch (ReflectiveOperationException e) {
80                    throw new Error("TEST BUG : " + e, e);
81                }
82
83                return CompilerToVMHelper.getResolvedJavaType(methodInstance,
84                        0L, COMPRESSED);
85            }
86        },
87        CONSTANT_POOL_BASE {
88            @Override
89            HotSpotResolvedObjectTypeImpl getResolvedJavaType() {
90                HotSpotConstantPool cpInst;
91                try {
92                    cpInst = CompilerToVMHelper.getConstantPool(null,
93                            getPtrToKlass());
94                    Field field = HotSpotConstantPool.class
95                            .getDeclaredField("metaspaceConstantPool");
96                    field.setAccessible(true);
97                    field.set(cpInst, getPtrToKlass());
98                } catch (ReflectiveOperationException e) {
99                    throw new Error("TESTBUG : " + e.getMessage(), e);
100                }
101                return CompilerToVMHelper.getResolvedJavaType(cpInst,
102                        0L, COMPRESSED);
103            }
104        },
105        CONSTANT_POOL_BASE_IN_TWO {
106            @Override
107            HotSpotResolvedObjectTypeImpl getResolvedJavaType() {
108                long ptr = getPtrToKlass();
109                HotSpotConstantPool cpInst = HotSpotResolvedObjectTypeImpl
110                        .fromObjectClass(TEST_CLASS).getConstantPool();
111                try {
112                    Field field = HotSpotConstantPool.class
113                            .getDeclaredField("metaspaceConstantPool");
114                    field.setAccessible(true);
115                    field.set(cpInst, ptr / 2L);
116                } catch (ReflectiveOperationException e) {
117                    throw new Error("TESTBUG : " + e.getMessage(), e);
118                }
119                return CompilerToVMHelper.getResolvedJavaType(cpInst,
120                        ptr - ptr / 2L, COMPRESSED);
121            }
122        },
123        CONSTANT_POOL_BASE_ZERO {
124            @Override
125            HotSpotResolvedObjectTypeImpl getResolvedJavaType() {
126                long ptr = getPtrToKlass();
127                HotSpotConstantPool cpInst = HotSpotResolvedObjectTypeImpl
128                        .fromObjectClass(TEST_CLASS).getConstantPool();
129                try {
130                    Field field = HotSpotConstantPool.class
131                            .getDeclaredField("metaspaceConstantPool");
132                    field.setAccessible(true);
133                    field.set(cpInst, 0L);
134                } catch (ReflectiveOperationException e) {
135                    throw new Error("TESTBUG : " + e.getMessage(), e);
136                }
137                return CompilerToVMHelper.getResolvedJavaType(cpInst,
138                        ptr, COMPRESSED);
139            }
140        },
141        OBJECT_TYPE_BASE {
142            @Override
143            HotSpotResolvedObjectTypeImpl getResolvedJavaType() {
144                HotSpotResolvedObjectTypeImpl type
145                        = HotSpotResolvedObjectTypeImpl.fromObjectClass(
146                        OBJECT_TYPE_BASE.getClass());
147                long ptrToClass = UNSAFE.getKlassPointer(OBJECT_TYPE_BASE);
148                return CompilerToVMHelper.getResolvedJavaType(type,
149                        getPtrToKlass() - ptrToClass, COMPRESSED);
150            }
151        },
152        ;
153        abstract HotSpotResolvedObjectTypeImpl getResolvedJavaType();
154    }
155
156    private static final Unsafe UNSAFE = Utils.getUnsafe();
157    private static final WhiteBox WB = WhiteBox.getWhiteBox();
158    private static final long PTR = UNSAFE.getKlassPointer(
159            new GetResolvedJavaTypeTest());
160    private static final Class TEST_CLASS = GetResolvedJavaTypeTest.class;
161    /* a compressed parameter for tested method is set to false because
162       unsafe.getKlassPointer always returns uncompressed pointer */
163    private static final boolean COMPRESSED = false;
164            // = WB.getBooleanVMFlag("UseCompressedClassPointers");
165
166    private static long getPtrToKlass() {
167        Field field;
168        try {
169            field = TEST_CLASS.getDeclaredField("PTR");
170        } catch (NoSuchFieldException e) {
171            throw new Error("TEST BUG : " + e, e);
172        }
173        Object base = UNSAFE.staticFieldBase(field);
174        return WB.getObjectAddress(base) + UNSAFE.staticFieldOffset(field);
175    }
176
177    public void test(TestCase testCase) {
178        System.out.println(testCase.name());
179        HotSpotResolvedObjectTypeImpl type = testCase.getResolvedJavaType();
180        Asserts.assertEQ(type.mirror(), TEST_CLASS, testCase +
181                        " Unexpected Class returned by getResolvedJavaType");
182    }
183
184    public static void main(String[] args) {
185        GetResolvedJavaTypeTest test = new GetResolvedJavaTypeTest();
186        for (TestCase testCase : TestCase.values()) {
187            test.test(testCase);
188        }
189        testObjectBase();
190        testMetaspaceWrapperBase();
191    }
192
193    private static void testMetaspaceWrapperBase() {
194        try {
195            HotSpotResolvedObjectTypeImpl type
196                    = CompilerToVMHelper.getResolvedJavaType(
197                            new MetaspaceWrapperObject() {
198                                @Override
199                                public long getMetaspacePointer() {
200                                    return getPtrToKlass();
201                                }
202                            }, 0L, COMPRESSED);
203            throw new AssertionError("Test METASPACE_WRAPPER_BASE."
204                    + " Expected IllegalArgumentException has not been caught");
205        } catch (IllegalArgumentException iae) {
206            // expected
207        }
208    }
209
210    private static void testObjectBase() {
211        try {
212            HotSpotResolvedObjectTypeImpl type
213                    = CompilerToVMHelper.getResolvedJavaType(new Object(), 0L,
214                            COMPRESSED);
215            throw new AssertionError("Test OBJECT_BASE."
216                + " Expected IllegalArgumentException has not been caught");
217        } catch (IllegalArgumentException iae) {
218            // expected
219        }
220    }
221}
222