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