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 (vm.simpleArch == "x64" | vm.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 TestHotSpotVMConfig.java amd64/AMD64TestAssembler.java sparc/SPARCTestAssembler.java
36 * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI jdk.vm.ci.code.test.SimpleDebugInfoTest
37 */
38
39 package jdk.vm.ci.code.test;
40
41 import org.junit.Assume;
42 import org.junit.Test;
43
44 import jdk.vm.ci.code.Register;
45 import jdk.vm.ci.hotspot.HotSpotConstant;
46 import jdk.vm.ci.meta.JavaConstant;
47 import jdk.vm.ci.meta.JavaKind;
48 import jdk.vm.ci.meta.ResolvedJavaType;
49 import jdk.vm.ci.meta.Value;
50
51 public class SimpleDebugInfoTest extends DebugInfoTest {
52
53 public static int intOnStack() {
54 return 42;
55 }
56
57 private void testIntOnStack(DebugInfoCompiler compiler) {
58 test(compiler, getMethod("intOnStack"), 2, JavaKind.Int);
59 }
60
61 public static int intInLocal() {
62 int local = 42;
63 return local;
64 }
65
66 public void testIntInLocal(DebugInfoCompiler compiler) {
67 test(compiler, getMethod("intInLocal"), 3, JavaKind.Int);
68 }
69
70 @Test
71 public void testConstInt() {
72 DebugInfoCompiler compiler = (asm, values) -> {
73 values[0] = JavaConstant.forInt(42);
74 return null;
75 };
76 testIntOnStack(compiler);
77 testIntInLocal(compiler);
78 }
79
80 @Test
81 public void testRegInt() {
82 DebugInfoCompiler compiler = (asm, values) -> {
83 Register reg = asm.emitLoadInt(42);
84 values[0] = reg.asValue(asm.getValueKind(JavaKind.Int));
85 return null;
86 };
87 testIntOnStack(compiler);
88 testIntInLocal(compiler);
89 }
90
91 @Test
92 public void testStackInt() {
93 DebugInfoCompiler compiler = (asm, values) -> {
94 Register reg = asm.emitLoadInt(42);
95 values[0] = asm.emitIntToStack(reg);
96 return null;
97 };
98 testIntOnStack(compiler);
99 testIntInLocal(compiler);
100 }
101
102 public static float floatOnStack() {
103 return 42.0f;
104 }
105
106 private void testFloatOnStack(DebugInfoCompiler compiler) {
107 test(compiler, getMethod("floatOnStack"), 2, JavaKind.Float);
108 }
109
110 public static float floatInLocal() {
111 float local = 42.0f;
112 return local;
113 }
114
115 private void testFloatInLocal(DebugInfoCompiler compiler) {
116 test(compiler, getMethod("floatInLocal"), 3, JavaKind.Float);
117 }
118
119 @Test
120 public void testConstFloat() {
121 DebugInfoCompiler compiler = (asm, values) -> {
122 values[0] = JavaConstant.forFloat(42.0f);
123 return null;
124 };
125 testFloatOnStack(compiler);
126 testFloatInLocal(compiler);
127 }
128
129 @Test
130 public void testRegFloat() {
131 DebugInfoCompiler compiler = (asm, values) -> {
132 Register reg = asm.emitLoadFloat(42.0f);
133 values[0] = reg.asValue(asm.getValueKind(JavaKind.Float));
134 return null;
135 };
136 testFloatOnStack(compiler);
137 testFloatInLocal(compiler);
138 }
139
140 @Test
141 public void testStackFloat() {
142 DebugInfoCompiler compiler = (asm, values) -> {
143 Register reg = asm.emitLoadFloat(42.0f);
144 values[0] = asm.emitFloatToStack(reg);
145 return null;
146 };
147 testFloatOnStack(compiler);
148 testFloatInLocal(compiler);
149 }
150
151 public static long longOnStack() {
152 return 42;
153 }
154
155 private void testLongOnStack(DebugInfoCompiler compiler) {
156 test(compiler, getMethod("longOnStack"), 3, JavaKind.Long, JavaKind.Illegal);
157 }
158
159 public static long longInLocal() {
160 long local = 42;
161 return local;
162 }
163
164 private void testLongInLocal(DebugInfoCompiler compiler) {
165 test(compiler, getMethod("longInLocal"), 4, JavaKind.Long, JavaKind.Illegal);
166 }
167
168 @Test
169 public void testConstLong() {
170 DebugInfoCompiler compiler = (asm, values) -> {
171 values[0] = JavaConstant.forLong(42);
172 values[1] = Value.ILLEGAL;
173 return null;
174 };
175 testLongOnStack(compiler);
176 testLongInLocal(compiler);
177 }
178
179 @Test
180 public void testRegLong() {
181 DebugInfoCompiler compiler = (asm, values) -> {
182 Register reg = asm.emitLoadLong(42);
183 values[0] = reg.asValue(asm.getValueKind(JavaKind.Long));
184 values[1] = Value.ILLEGAL;
185 return null;
186 };
187 testLongOnStack(compiler);
188 testLongInLocal(compiler);
189 }
190
191 @Test
192 public void testStackLong() {
193 DebugInfoCompiler compiler = (asm, values) -> {
194 Register reg = asm.emitLoadLong(42);
195 values[0] = asm.emitLongToStack(reg);
196 values[1] = Value.ILLEGAL;
197 return null;
198 };
199 testLongOnStack(compiler);
200 testLongInLocal(compiler);
201 }
202
203 public static Class<?> objectOnStack() {
204 return SimpleDebugInfoTest.class;
205 }
206
207 private void testObjectOnStack(DebugInfoCompiler compiler) {
208 test(compiler, getMethod("objectOnStack"), 2, JavaKind.Object);
209 }
210
211 public static Class<?> objectInLocal() {
212 Class<?> local = SimpleDebugInfoTest.class;
213 return local;
214 }
215
216 private void testObjectInLocal(DebugInfoCompiler compiler) {
217 test(compiler, getMethod("objectInLocal"), 3, JavaKind.Object);
218 }
219
220 @Test
221 public void testConstObject() {
222 ResolvedJavaType type = metaAccess.lookupJavaType(objectOnStack());
223 DebugInfoCompiler compiler = (asm, values) -> {
224 values[0] = constantReflection.asJavaClass(type);
225 return null;
226 };
227 testObjectOnStack(compiler);
228 testObjectInLocal(compiler);
229 }
230
231 @Test
232 public void testRegObject() {
233 ResolvedJavaType type = metaAccess.lookupJavaType(objectOnStack());
234 DebugInfoCompiler compiler = (asm, values) -> {
235 Register reg = asm.emitLoadPointer((HotSpotConstant) constantReflection.asJavaClass(type));
236 values[0] = reg.asValue(asm.getValueKind(JavaKind.Object));
237 return null;
238 };
239 testObjectOnStack(compiler);
240 testObjectInLocal(compiler);
241 }
242
243 @Test
244 public void testStackObject() {
245 ResolvedJavaType type = metaAccess.lookupJavaType(objectOnStack());
246 DebugInfoCompiler compiler = (asm, values) -> {
247 Register reg = asm.emitLoadPointer((HotSpotConstant) constantReflection.asJavaClass(type));
248 values[0] = asm.emitPointerToStack(reg);
249 return null;
250 };
251 testObjectOnStack(compiler);
252 testObjectInLocal(compiler);
253 }
254
255 @Test
256 public void testRegNarrowObject() {
257 Assume.assumeTrue(config.useCompressedOops);
258 ResolvedJavaType type = metaAccess.lookupJavaType(objectOnStack());
259 DebugInfoCompiler compiler = (asm, values) -> {
260 HotSpotConstant wide = (HotSpotConstant) constantReflection.asJavaClass(type);
261 Register reg = asm.emitLoadPointer((HotSpotConstant) wide.compress());
262 values[0] = reg.asValue(asm.narrowOopKind);
263 return null;
264 };
265 testObjectOnStack(compiler);
266 testObjectInLocal(compiler);
267 }
268
269 @Test
270 public void testStackNarrowObject() {
271 Assume.assumeTrue(config.useCompressedOops);
272 ResolvedJavaType type = metaAccess.lookupJavaType(objectOnStack());
273 DebugInfoCompiler compiler = (asm, values) -> {
274 HotSpotConstant wide = (HotSpotConstant) constantReflection.asJavaClass(type);
275 Register reg = asm.emitLoadPointer((HotSpotConstant) wide.compress());
276 values[0] = asm.emitNarrowPointerToStack(reg);
277 return null;
278 };
279 testObjectOnStack(compiler);
280 testObjectInLocal(compiler);
281 }
282 }