StackMoveTest.java revision 12651:6ef01bd40ce2 
1/*
2 * Copyright (c) 2015, 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 */
23package org.graalvm.compiler.lir.jtt;
24
25import org.junit.Before;
26import org.junit.Test;
27
28import org.graalvm.compiler.core.common.LIRKind;
29import org.graalvm.compiler.lir.Variable;
30import org.graalvm.compiler.lir.VirtualStackSlot;
31import org.graalvm.compiler.lir.framemap.FrameMapBuilder;
32import org.graalvm.compiler.lir.gen.LIRGeneratorTool;
33
34import jdk.vm.ci.meta.JavaKind;
35import jdk.vm.ci.meta.PlatformKind;
36import jdk.vm.ci.meta.Value;
37import jdk.vm.ci.meta.ValueKind;
38
39public class StackMoveTest extends LIRTest {
40    private static PlatformKind byteKind;
41    private static PlatformKind shortKind;
42
43    @Before
44    public void setUp() {
45        byteKind = getBackend().getTarget().arch.getPlatformKind(JavaKind.Byte);
46        shortKind = getBackend().getTarget().arch.getPlatformKind(JavaKind.Short);
47    }
48
49    private static class StackCopySpec extends LIRTestSpecification {
50        @Override
51        public void generate(LIRGeneratorTool gen, Value a) {
52            FrameMapBuilder frameMapBuilder = gen.getResult().getFrameMapBuilder();
53            ValueKind<?> valueKind = getValueKind(a);
54
55            // create slots
56            VirtualStackSlot s1 = frameMapBuilder.allocateSpillSlot(valueKind);
57            VirtualStackSlot s2 = frameMapBuilder.allocateSpillSlot(valueKind);
58
59            // start emit
60            gen.emitMove(s1, a);
61            Value copy1 = gen.emitMove(s1);
62            gen.append(gen.getSpillMoveFactory().createStackMove(s2, s1));
63            Variable result = gen.emitMove(s2);
64            // end emit
65
66            // set output and result
67            setResult(result);
68            setOutput("slotcopy", copy1);
69            setOutput("slot1", s1);
70            setOutput("slot2", s2);
71        }
72
73        protected ValueKind<?> getValueKind(Value value) {
74            return value.getValueKind();
75        }
76    }
77
78    private static final LIRTestSpecification stackCopy = new StackCopySpec();
79
80    /*
81     * int
82     */
83
84    @SuppressWarnings("unused")
85    @LIRIntrinsic
86    public static int copyInt(LIRTestSpecification spec, int a) {
87        return a;
88    }
89
90    public int[] testInt(int a, int[] out) {
91        out[0] = copyInt(stackCopy, a);
92        out[1] = getOutput(stackCopy, "slotcopy", a);
93        out[2] = getOutput(stackCopy, "slot1", a);
94        out[3] = getOutput(stackCopy, "slot2", a);
95        return out;
96    }
97
98    @Test
99    public void runInt() throws Throwable {
100        runTest("testInt", Integer.MIN_VALUE, supply(() -> new int[4]));
101        runTest("testInt", -1, supply(() -> new int[4]));
102        runTest("testInt", 0, supply(() -> new int[4]));
103        runTest("testInt", 1, supply(() -> new int[4]));
104        runTest("testInt", Integer.MAX_VALUE, supply(() -> new int[4]));
105    }
106
107    /*
108     * long
109     */
110
111    @SuppressWarnings("unused")
112    @LIRIntrinsic
113    public static long copyLong(LIRTestSpecification spec, long a) {
114        return a;
115    }
116
117    public long[] testLong(long a, long[] out) {
118        out[0] = copyLong(stackCopy, a);
119        out[1] = getOutput(stackCopy, "slotcopy", a);
120        out[2] = getOutput(stackCopy, "slot1", a);
121        out[3] = getOutput(stackCopy, "slot2", a);
122        return out;
123    }
124
125    @Test
126    public void runLong() throws Throwable {
127        runTest("testLong", Long.MIN_VALUE, supply(() -> new long[3]));
128        runTest("testLong", -1L, supply(() -> new long[3]));
129        runTest("testLong", 0L, supply(() -> new long[3]));
130        runTest("testLong", 1L, supply(() -> new long[3]));
131        runTest("testLong", Long.MAX_VALUE, supply(() -> new long[3]));
132    }
133
134    /*
135     * float
136     */
137
138    @SuppressWarnings("unused")
139    @LIRIntrinsic
140    public static float copyFloat(LIRTestSpecification spec, float a) {
141        return a;
142    }
143
144    public float[] testFloat(float a, float[] out) {
145        out[0] = copyFloat(stackCopy, a);
146        out[1] = getOutput(stackCopy, "slotcopy", a);
147        out[2] = getOutput(stackCopy, "slot1", a);
148        out[3] = getOutput(stackCopy, "slot2", a);
149        return out;
150    }
151
152    @Test
153    public void runFloat() throws Throwable {
154        runTest("testFloat", Float.MIN_VALUE, supply(() -> new float[3]));
155        runTest("testFloat", -1f, supply(() -> new float[3]));
156        runTest("testFloat", -0.1f, supply(() -> new float[3]));
157        runTest("testFloat", 0f, supply(() -> new float[3]));
158        runTest("testFloat", 0.1f, supply(() -> new float[3]));
159        runTest("testFloat", 1f, supply(() -> new float[3]));
160        runTest("testFloat", Float.MAX_VALUE, supply(() -> new float[3]));
161    }
162
163    /*
164     * double
165     */
166
167    @SuppressWarnings("unused")
168    @LIRIntrinsic
169    public static double copyDouble(LIRTestSpecification spec, double a) {
170        return a;
171    }
172
173    public double[] testDouble(double a, double[] out) {
174        out[0] = copyDouble(stackCopy, a);
175        out[1] = getOutput(stackCopy, "slotcopy", a);
176        out[2] = getOutput(stackCopy, "slot1", a);
177        out[3] = getOutput(stackCopy, "slot2", a);
178        return out;
179    }
180
181    @Test
182    public void runDouble() throws Throwable {
183        runTest("testDouble", Double.MIN_VALUE, supply(() -> new double[3]));
184        runTest("testDouble", -1., supply(() -> new double[3]));
185        runTest("testDouble", -0.1, supply(() -> new double[3]));
186        runTest("testDouble", 0., supply(() -> new double[3]));
187        runTest("testDouble", 0.1, supply(() -> new double[3]));
188        runTest("testDouble", 1., supply(() -> new double[3]));
189        runTest("testDouble", Double.MAX_VALUE, supply(() -> new double[3]));
190    }
191
192    /*
193     * short
194     */
195
196    private static final LIRTestSpecification shortStackCopy = new StackCopySpec() {
197        @Override
198        protected ValueKind<?> getValueKind(Value value) {
199            return LIRKind.value(shortKind);
200        }
201    };
202
203    @SuppressWarnings("unused")
204    @LIRIntrinsic
205    public static short copyShort(LIRTestSpecification spec, short a) {
206        return a;
207    }
208
209    public short[] testShort(short a, short[] out) {
210        out[0] = copyShort(shortStackCopy, a);
211        out[1] = getOutput(shortStackCopy, "slotcopy", a);
212        out[2] = getOutput(shortStackCopy, "slot1", a);
213        out[3] = getOutput(shortStackCopy, "slot2", a);
214        return out;
215    }
216
217    @Test
218    public void runShort() throws Throwable {
219        runTest("testShort", Short.MIN_VALUE, supply(() -> new short[3]));
220        runTest("testShort", (short) -1, supply(() -> new short[3]));
221        runTest("testShort", (short) 0, supply(() -> new short[3]));
222        runTest("testShort", (short) 1, supply(() -> new short[3]));
223        runTest("testShort", Short.MAX_VALUE, supply(() -> new short[3]));
224    }
225
226    /*
227     * byte
228     */
229
230    private static final LIRTestSpecification byteStackCopy = new StackCopySpec() {
231        @Override
232        protected ValueKind<?> getValueKind(Value value) {
233            return LIRKind.value(byteKind);
234        }
235    };
236
237    @SuppressWarnings("unused")
238    @LIRIntrinsic
239    public static byte copyByte(LIRTestSpecification spec, byte a) {
240        return a;
241    }
242
243    public byte[] testByte(byte a, byte[] out) {
244        out[0] = copyByte(byteStackCopy, a);
245        out[1] = getOutput(byteStackCopy, "slotcopy", a);
246        out[2] = getOutput(byteStackCopy, "slot1", a);
247        out[3] = getOutput(byteStackCopy, "slot2", a);
248        return out;
249    }
250
251    @Test
252    public void runByte() throws Throwable {
253        runTest("testByte", Byte.MIN_VALUE, supply(() -> new byte[3]));
254        runTest("testByte", (byte) -1, supply(() -> new byte[3]));
255        runTest("testByte", (byte) 0, supply(() -> new byte[3]));
256        runTest("testByte", (byte) 1, supply(() -> new byte[3]));
257        runTest("testByte", Byte.MAX_VALUE, supply(() -> new byte[3]));
258    }
259}
260