GetResolvedJavaTypeTest.java revision 9814:22fd02fad88b 
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.simpleArch == "aarch64")
28 * @library / /testlibrary /test/lib
29 * @compile ../common/CompilerToVMHelper.java
30 *          ../common/PublicMetaspaceWrapperObject.java
31 * @build compiler.jvmci.compilerToVM.GetResolvedJavaTypeTest
32 * @run main ClassFileInstaller
33 *      sun.hotspot.WhiteBox
34 *      sun.hotspot.WhiteBox$WhiteBoxPermission
35 *      jdk.vm.ci.hotspot.CompilerToVMHelper
36 *      jdk.vm.ci.hotspot.PublicMetaspaceWrapperObject
37 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockExperimentalVMOptions
38 *      -XX:+EnableJVMCI -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
39 *      -XX:+UseCompressedOops
40 *      compiler.jvmci.compilerToVM.GetResolvedJavaTypeTest
41 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockExperimentalVMOptions
42 *      -XX:+EnableJVMCI -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
43 *      -XX:-UseCompressedOops
44 *      compiler.jvmci.compilerToVM.GetResolvedJavaTypeTest
45 */
46
47package compiler.jvmci.compilerToVM;
48
49import java.lang.reflect.Field;
50import jdk.vm.ci.meta.ConstantPool;
51import jdk.vm.ci.hotspot.CompilerToVMHelper;
52import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod;
53import jdk.vm.ci.hotspot.HotSpotResolvedObjectType;
54import jdk.vm.ci.hotspot.PublicMetaspaceWrapperObject;
55import jdk.test.lib.Asserts;
56import jdk.test.lib.Utils;
57import sun.hotspot.WhiteBox;
58import sun.misc.Unsafe;
59
60public class GetResolvedJavaTypeTest {
61    private static enum TestCase {
62        NULL_BASE {
63            @Override
64            HotSpotResolvedObjectType getResolvedJavaType() {
65                return CompilerToVMHelper.getResolvedJavaType(
66                        null, getPtrToKlass(), COMPRESSED);
67            }
68        },
69        JAVA_METHOD_BASE {
70            @Override
71            HotSpotResolvedObjectType getResolvedJavaType() {
72                HotSpotResolvedJavaMethod methodInstance
73                        = CompilerToVMHelper.getResolvedJavaMethodAtSlot(
74                        TEST_CLASS, 0);
75                Field field;
76                try {
77                    // jdk.vm.ci.hotspot.HotSpotResolvedJavaMethodImpl.metaspaceMethod
78                    field = methodInstance.getClass()
79                            .getDeclaredField("metaspaceMethod");
80                    field.setAccessible(true);
81                    field.set(methodInstance, getPtrToKlass());
82                } catch (ReflectiveOperationException e) {
83                    throw new Error("TEST BUG : " + e, e);
84                }
85
86                return CompilerToVMHelper.getResolvedJavaType(methodInstance,
87                        0L, COMPRESSED);
88            }
89        },
90        CONSTANT_POOL_BASE {
91            @Override
92            HotSpotResolvedObjectType getResolvedJavaType() {
93                ConstantPool cpInst;
94                try {
95                    cpInst = CompilerToVMHelper.getConstantPool(null,
96                            getPtrToKlass());
97                    // jdk.vm.ci.hotspot.HotSpotConstantPool.metaspaceConstantPool
98                    Field field = cpInst.getClass()
99                            .getDeclaredField("metaspaceConstantPool");
100                    field.setAccessible(true);
101                    field.set(cpInst, getPtrToKlass());
102                } catch (ReflectiveOperationException e) {
103                    throw new Error("TESTBUG : " + e, e);
104                }
105                return CompilerToVMHelper.getResolvedJavaType(cpInst,
106                        0L, COMPRESSED);
107            }
108        },
109        CONSTANT_POOL_BASE_IN_TWO {
110            @Override
111            HotSpotResolvedObjectType getResolvedJavaType() {
112                long ptr = getPtrToKlass();
113                ConstantPool cpInst = HotSpotResolvedObjectType
114                        .fromObjectClass(TEST_CLASS)
115                        .getConstantPool();
116                try {
117                    Field field = cpInst.getClass()
118                            .getDeclaredField("metaspaceConstantPool");
119                    field.setAccessible(true);
120                    field.set(cpInst, ptr / 2L);
121                } catch (ReflectiveOperationException e) {
122                    throw new Error("TESTBUG : " + e, e);
123                }
124                return CompilerToVMHelper.getResolvedJavaType(cpInst,
125                        ptr - ptr / 2L, COMPRESSED);
126            }
127        },
128        CONSTANT_POOL_BASE_ZERO {
129            @Override
130            HotSpotResolvedObjectType getResolvedJavaType() {
131                long ptr = getPtrToKlass();
132                ConstantPool cpInst = HotSpotResolvedObjectType
133                        .fromObjectClass(TEST_CLASS)
134                        .getConstantPool();
135                try {
136                    Field field = cpInst.getClass()
137                            .getDeclaredField("metaspaceConstantPool");
138                    field.setAccessible(true);
139                    field.set(cpInst, 0L);
140                } catch (ReflectiveOperationException e) {
141                    throw new Error("TESTBUG : " + e, e);
142                }
143                return CompilerToVMHelper.getResolvedJavaType(cpInst,
144                        ptr, COMPRESSED);
145            }
146        },
147        OBJECT_TYPE_BASE {
148            @Override
149            HotSpotResolvedObjectType getResolvedJavaType() {
150                HotSpotResolvedObjectType type
151                        = HotSpotResolvedObjectType.fromObjectClass(
152                        OBJECT_TYPE_BASE.getClass());
153                long ptrToClass = UNSAFE.getKlassPointer(OBJECT_TYPE_BASE);
154                return CompilerToVMHelper.getResolvedJavaType(type,
155                        getPtrToKlass() - ptrToClass, COMPRESSED);
156            }
157        },
158        ;
159        abstract HotSpotResolvedObjectType getResolvedJavaType();
160    }
161
162    private static final Unsafe UNSAFE = Utils.getUnsafe();
163    private static final WhiteBox WB = WhiteBox.getWhiteBox();
164    private static final long PTR = UNSAFE.getKlassPointer(
165            new GetResolvedJavaTypeTest());
166    private static final Class TEST_CLASS = GetResolvedJavaTypeTest.class;
167    /* a compressed parameter for tested method is set to false because
168       unsafe.getKlassPointer always returns uncompressed pointer */
169    private static final boolean COMPRESSED = false;
170            // = WB.getBooleanVMFlag("UseCompressedClassPointers");
171
172    private static long getPtrToKlass() {
173        Field field;
174        try {
175            field = TEST_CLASS.getDeclaredField("PTR");
176        } catch (NoSuchFieldException e) {
177            throw new Error("TEST BUG : " + e, e);
178        }
179        Object base = UNSAFE.staticFieldBase(field);
180        return WB.getObjectAddress(base) + UNSAFE.staticFieldOffset(field);
181    }
182
183    public void test(TestCase testCase) {
184        System.out.println(testCase.name());
185        HotSpotResolvedObjectType type = testCase.getResolvedJavaType();
186        Asserts.assertEQ(TEST_CLASS,
187                CompilerToVMHelper.getMirror(type),
188                testCase +  " : unexpected class returned");
189    }
190
191    public static void main(String[] args) {
192        GetResolvedJavaTypeTest test = new GetResolvedJavaTypeTest();
193        for (TestCase testCase : TestCase.values()) {
194            test.test(testCase);
195        }
196        testObjectBase();
197        testMetaspaceWrapperBase();
198    }
199
200    private static void testMetaspaceWrapperBase() {
201        try {
202            HotSpotResolvedObjectType type
203                    = CompilerToVMHelper.getResolvedJavaType(
204                            new PublicMetaspaceWrapperObject() {
205                                @Override
206                                public long getMetaspacePointer() {
207                                    return getPtrToKlass();
208                                }
209                            }, 0L, COMPRESSED);
210            throw new AssertionError("Test METASPACE_WRAPPER_BASE."
211                    + " Expected IllegalArgumentException has not been caught");
212        } catch (IllegalArgumentException iae) {
213            // expected
214        }
215    }
216
217    private static void testObjectBase() {
218        try {
219            HotSpotResolvedObjectType type
220                    = CompilerToVMHelper.getResolvedJavaType(new Object(), 0L,
221                            COMPRESSED);
222            throw new AssertionError("Test OBJECT_BASE."
223                + " Expected IllegalArgumentException has not been caught");
224        } catch (IllegalArgumentException iae) {
225            // expected
226        }
227    }
228}
229