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