1 /*
2 * Copyright (c) 2015, 2016, 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 * @requires (os.simpleArch == "x64" | os.simpleArch == "sparcv9") & os.arch != "aarch64"
27 * @compile CodeInstallationTest.java TestAssembler.java amd64/AMD64TestAssembler.java sparc/SPARCTestAssembler.java
28 * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI compiler.jvmci.code.DataPatchTest
29 */
30
31 package compiler.jvmci.code;
32
33 import jdk.vm.ci.code.Register;
34 import jdk.vm.ci.code.site.DataSectionReference;
35 import jdk.vm.ci.hotspot.HotSpotConstant;
36 import jdk.vm.ci.hotspot.HotSpotMetaAccessProvider;
37 import jdk.vm.ci.hotspot.HotSpotSymbol;
38 import jdk.vm.ci.hotspot.HotSpotVMConfig;
39 import jdk.vm.ci.meta.ResolvedJavaType;
40
41 import org.junit.Assume;
42 import org.junit.Test;
43
44 /**
45 * Test code installation with data patches.
46 */
47 public class DataPatchTest extends CodeInstallationTest {
48
49 public static Class<?> getConstClass() {
50 return DataPatchTest.class;
51 }
52
53 private void test(TestCompiler compiler) {
54 test(compiler, getMethod("getConstClass"));
55 }
56
57 @Test
58 public void testInlineObject() {
59 test(asm -> {
60 ResolvedJavaType type = metaAccess.lookupJavaType(getConstClass());
61 HotSpotConstant c = (HotSpotConstant) constantReflection.asJavaClass(type);
62 Register ret = asm.emitLoadPointer(c);
63 asm.emitPointerRet(ret);
64 });
65 }
66
67 @Test
68 public void testInlineNarrowObject() {
69 Assume.assumeTrue(HotSpotVMConfig.config().useCompressedOops);
70 test(asm -> {
71 ResolvedJavaType type = metaAccess.lookupJavaType(getConstClass());
72 HotSpotConstant c = (HotSpotConstant) constantReflection.asJavaClass(type);
73 Register compressed = asm.emitLoadPointer((HotSpotConstant) c.compress());
74 Register ret = asm.emitUncompressPointer(compressed, HotSpotVMConfig.config().narrowOopBase, HotSpotVMConfig.config().narrowOopShift);
75 asm.emitPointerRet(ret);
76 });
77 }
78
79 @Test
80 public void testDataSectionReference() {
81 test(asm -> {
82 ResolvedJavaType type = metaAccess.lookupJavaType(getConstClass());
83 HotSpotConstant c = (HotSpotConstant) constantReflection.asJavaClass(type);
84 DataSectionReference ref = asm.emitDataItem(c);
85 Register ret = asm.emitLoadPointer(ref);
86 asm.emitPointerRet(ret);
87 });
88 }
89
90 @Test
91 public void testNarrowDataSectionReference() {
92 Assume.assumeTrue(HotSpotVMConfig.config().useCompressedOops);
93 test(asm -> {
94 ResolvedJavaType type = metaAccess.lookupJavaType(getConstClass());
95 HotSpotConstant c = (HotSpotConstant) constantReflection.asJavaClass(type);
96 HotSpotConstant cCompressed = (HotSpotConstant) c.compress();
97 DataSectionReference ref = asm.emitDataItem(cCompressed);
98 Register compressed = asm.emitLoadNarrowPointer(ref);
99 Register ret = asm.emitUncompressPointer(compressed, HotSpotVMConfig.config().narrowOopBase, HotSpotVMConfig.config().narrowOopShift);
100 asm.emitPointerRet(ret);
101 });
102 }
103
104 @Test
105 public void testInlineMetadata() {
106 test(asm -> {
107 ResolvedJavaType type = metaAccess.lookupJavaType(getConstClass());
108 Register klass = asm.emitLoadPointer((HotSpotConstant) constantReflection.asObjectHub(type));
109 Register ret = asm.emitLoadPointer(klass, HotSpotVMConfig.config().classMirrorOffset);
110 asm.emitPointerRet(ret);
111 });
112 }
113
114 @Test
115 public void testInlineNarrowMetadata() {
116 Assume.assumeTrue(HotSpotVMConfig.config().useCompressedClassPointers);
117 test(asm -> {
118 ResolvedJavaType type = metaAccess.lookupJavaType(getConstClass());
119 HotSpotConstant hub = (HotSpotConstant) constantReflection.asObjectHub(type);
120 Register narrowKlass = asm.emitLoadPointer((HotSpotConstant) hub.compress());
121 Register klass = asm.emitUncompressPointer(narrowKlass, HotSpotVMConfig.config().narrowKlassBase, HotSpotVMConfig.config().narrowKlassShift);
122 Register ret = asm.emitLoadPointer(klass, HotSpotVMConfig.config().classMirrorOffset);
123 asm.emitPointerRet(ret);
124 });
125 }
126
127 @Test
128 public void testMetadataInDataSection() {
129 test(asm -> {
130 ResolvedJavaType type = metaAccess.lookupJavaType(getConstClass());
131 HotSpotConstant hub = (HotSpotConstant) constantReflection.asObjectHub(type);
132 DataSectionReference ref = asm.emitDataItem(hub);
133 Register klass = asm.emitLoadPointer(ref);
134 Register ret = asm.emitLoadPointer(klass, HotSpotVMConfig.config().classMirrorOffset);
135 asm.emitPointerRet(ret);
136 });
137 }
138
139 @Test
140 public void testNarrowMetadataInDataSection() {
141 Assume.assumeTrue(HotSpotVMConfig.config().useCompressedClassPointers);
142 test(asm -> {
143 ResolvedJavaType type = metaAccess.lookupJavaType(getConstClass());
144 HotSpotConstant hub = (HotSpotConstant) constantReflection.asObjectHub(type);
145 HotSpotConstant narrowHub = (HotSpotConstant) hub.compress();
146 DataSectionReference ref = asm.emitDataItem(narrowHub);
147 Register narrowKlass = asm.emitLoadNarrowPointer(ref);
148 Register klass = asm.emitUncompressPointer(narrowKlass, HotSpotVMConfig.config().narrowKlassBase, HotSpotVMConfig.config().narrowKlassShift);
149 Register ret = asm.emitLoadPointer(klass, HotSpotVMConfig.config().classMirrorOffset);
150 asm.emitPointerRet(ret);
151 });
152 }
153
154
155 public static long getConstSymbol(HotSpotMetaAccessProvider meta) {
156 HotSpotSymbol symbol = meta.lookupSymbol("java/lang/Object");
157 return symbol.getMetaspacePointer();
158 }
159
160 private void testSymbol(TestCompiler compiler) {
161 test(compiler, getMethod("getConstSymbol", HotSpotMetaAccessProvider.class), (HotSpotMetaAccessProvider) metaAccess);
162 }
163
164 @Test
165 public void testInlineSymbol() {
166 testSymbol(asm -> {
167 HotSpotSymbol symbol = ((HotSpotMetaAccessProvider) metaAccess).lookupSymbol("java/lang/Object");
168 Register ret = asm.emitLoadPointer((HotSpotConstant) symbol.asConstant());
169 asm.emitPointerRet(ret);
170 });
171 }
172
173 @Test
174 public void testSymbolInDataSection() {
175 testSymbol(asm -> {
176 HotSpotSymbol symbol = ((HotSpotMetaAccessProvider) metaAccess).lookupSymbol("java/lang/Object");
177 DataSectionReference ref = asm.emitDataItem((HotSpotConstant) symbol.asConstant());
178 Register ret = asm.emitLoadPointer(ref);
179 asm.emitPointerRet(ret);
180 });
181 }
182 }