SPARCTestAssembler.java revision 10973:b7e54a66a397 
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
24package jdk.vm.ci.code.test.sparc;
25
26import jdk.vm.ci.code.CodeCacheProvider;
27import jdk.vm.ci.code.DebugInfo;
28import jdk.vm.ci.code.Register;
29import jdk.vm.ci.code.StackSlot;
30import jdk.vm.ci.code.site.ConstantReference;
31import jdk.vm.ci.code.site.DataSectionReference;
32import jdk.vm.ci.code.test.TestAssembler;
33import jdk.vm.ci.hotspot.HotSpotCallingConventionType;
34import jdk.vm.ci.hotspot.HotSpotCompiledCode;
35import jdk.vm.ci.hotspot.HotSpotConstant;
36import jdk.vm.ci.hotspot.HotSpotForeignCallTarget;
37import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod;
38import jdk.vm.ci.hotspot.HotSpotVMConfig;
39import jdk.vm.ci.meta.JavaKind;
40import jdk.vm.ci.meta.LIRKind;
41import jdk.vm.ci.meta.VMConstant;
42import jdk.vm.ci.sparc.SPARC;
43import jdk.vm.ci.sparc.SPARCKind;
44
45public class SPARCTestAssembler extends TestAssembler {
46
47    private static final int MASK13 = (1 << 13) - 1;
48
49    public SPARCTestAssembler(CodeCacheProvider codeCache) {
50        super(codeCache, 0, 16, SPARCKind.WORD, SPARC.l0, SPARC.l1, SPARC.l2, SPARC.l3, SPARC.l4, SPARC.l5, SPARC.l6, SPARC.l7);
51    }
52
53    private void emitOp2(Register rd, int op2, int imm22) {
54        code.emitInt((0b00 << 30) | (rd.encoding << 25) | (op2 << 22) | imm22);
55    }
56
57    private void emitOp3(int op, Register rd, int op3, Register rs1, Register rs2) {
58        code.emitInt((op << 30) | (rd.encoding << 25) | (op3 << 19) | (rs1.encoding << 14) | rs2.encoding);
59    }
60
61    private void emitOp3(int op, Register rd, int op3, Register rs1, int simm13) {
62        code.emitInt((op << 30) | (rd.encoding << 25) | (op3 << 19) | (rs1.encoding << 14) | (1 << 13) | (simm13 & MASK13));
63    }
64
65    private void emitNop() {
66        code.emitInt(1 << 24);
67    }
68
69    @Override
70    public void emitPrologue() {
71        // SAVE sp, -128, sp
72        emitOp3(0b10, SPARC.sp, 0b111100, SPARC.sp, -SPARC.REGISTER_SAFE_AREA_SIZE);
73        setDeoptRescueSlot(newStackSlot(LIRKind.value(SPARCKind.XWORD)));
74    }
75
76    @Override
77    public void emitEpilogue() {
78        HotSpotVMConfig config = HotSpotVMConfig.config();
79        recordMark(config.MARKID_DEOPT_HANDLER_ENTRY);
80        recordCall(new HotSpotForeignCallTarget(config.handleDeoptStub), 4, true, null);
81        code.emitInt(1 << 30); // CALL
82    }
83
84    @Override
85    public HotSpotCompiledCode finish(HotSpotResolvedJavaMethod method) {
86        frameSize += SPARC.REGISTER_SAFE_AREA_SIZE;
87        return super.finish(method);
88    }
89
90    @Override
91    public void emitGrowStack(int size) {
92        emitOp3(0b10, SPARC.sp, 0b000100, SPARC.sp, size); // SUB sp, size, sp
93    }
94
95    @Override
96    public Register emitIntArg0() {
97        return codeCache.getRegisterConfig().getCallingConventionRegisters(HotSpotCallingConventionType.JavaCallee, JavaKind.Int)[0];
98    }
99
100    @Override
101    public Register emitIntArg1() {
102        return codeCache.getRegisterConfig().getCallingConventionRegisters(HotSpotCallingConventionType.JavaCallee, JavaKind.Int)[1];
103    }
104
105    @Override
106    public Register emitLoadInt(int c) {
107        Register ret = newRegister();
108        int hi = c >>> 10;
109        int lo = c & ((1 << 10) - 1);
110        if (hi == 0) {
111            emitOp3(0b10, ret, 0b000010, SPARC.g0, lo); // OR g0, lo, ret
112        } else {
113            emitOp2(ret, 0b100, hi);                    // SETHI hi, ret
114            if (lo != 0) {
115                emitOp3(0b10, ret, 0b000010, ret, lo);  // OR ret, lo, ret
116            }
117        }
118        return ret;
119    }
120
121    @Override
122    public Register emitLoadLong(long c) {
123        if ((c & 0xFFFF_FFFFL) == c) {
124            return emitLoadInt((int) c);
125        } else {
126            DataSectionReference ref = new DataSectionReference();
127            data.align(8);
128            ref.setOffset(data.position());
129            data.emitLong(c);
130            return emitLoadPointer(ref);
131        }
132    }
133
134    private void emitPatchableSethi(Register ret, boolean wide) {
135        int startPos = code.position();
136        emitOp2(ret, 0b100, 0);              // SETHI 0, ret
137        if (wide) {
138            // pad for later patching
139            while (code.position() < (startPos + 28)) {
140                emitNop();
141            }
142        }
143    }
144
145    @Override
146    public Register emitLoadFloat(float c) {
147        DataSectionReference ref = new DataSectionReference();
148        data.align(4);
149        ref.setOffset(data.position());
150        data.emitFloat(c);
151
152        Register ptr = newRegister();
153        recordDataPatchInCode(ref);
154        emitPatchableSethi(ptr, true);
155        emitOp3(0b11, SPARC.f0, 0b100000, ptr, 0); // LDF [ptr+0], f0
156        return SPARC.f0;
157    }
158
159    @Override
160    public Register emitLoadPointer(HotSpotConstant c) {
161        Register ret = newRegister();
162        recordDataPatchInCode(new ConstantReference((VMConstant) c));
163
164        emitPatchableSethi(ret, !c.isCompressed());
165        emitOp3(0b10, ret, 0b000010, ret, 0); // OR ret, 0, ret
166
167        return ret;
168    }
169
170    @Override
171    public Register emitLoadPointer(DataSectionReference ref) {
172        Register ret = newRegister();
173        recordDataPatchInCode(ref);
174        emitPatchableSethi(ret, true);
175        emitOp3(0b11, ret, 0b001011, ret, 0); // LDX [ret+0], ret
176        return ret;
177    }
178
179    @Override
180    public Register emitLoadNarrowPointer(DataSectionReference ref) {
181        Register ret = newRegister();
182        recordDataPatchInCode(ref);
183        emitPatchableSethi(ret, true);
184        emitOp3(0b11, ret, 0b000000, ret, 0); // LDUW [ret+0], ret
185        return ret;
186    }
187
188    @Override
189    public Register emitLoadPointer(Register b, int offset) {
190        Register ret = newRegister();
191        emitOp3(0b11, ret, 0b001011, b, offset); // LDX [b+offset], ret
192        return ret;
193    }
194
195    @Override
196    public StackSlot emitIntToStack(Register a) {
197        StackSlot ret = newStackSlot(LIRKind.value(SPARCKind.WORD));
198        // STW a, [fp+offset]
199        emitOp3(0b11, a, 0b000100, SPARC.fp, ret.getRawOffset() + SPARC.STACK_BIAS);
200        return ret;
201    }
202
203    @Override
204    public StackSlot emitLongToStack(Register a) {
205        StackSlot ret = newStackSlot(LIRKind.value(SPARCKind.XWORD));
206        // STX a, [fp+offset]
207        emitOp3(0b11, a, 0b001110, SPARC.fp, ret.getRawOffset() + SPARC.STACK_BIAS);
208        return ret;
209    }
210
211    @Override
212    public StackSlot emitFloatToStack(Register a) {
213        StackSlot ret = newStackSlot(LIRKind.value(SPARCKind.SINGLE));
214        // STF a, [fp+offset]
215        emitOp3(0b11, a, 0b100100, SPARC.fp, ret.getRawOffset() + SPARC.STACK_BIAS);
216        return ret;
217    }
218
219    @Override
220    public StackSlot emitPointerToStack(Register a) {
221        StackSlot ret = newStackSlot(LIRKind.reference(SPARCKind.XWORD));
222        // STX a, [fp+offset]
223        emitOp3(0b11, a, 0b001110, SPARC.fp, ret.getRawOffset() + SPARC.STACK_BIAS);
224        return ret;
225    }
226
227    @Override
228    public StackSlot emitNarrowPointerToStack(Register a) {
229        StackSlot ret = newStackSlot(LIRKind.reference(SPARCKind.WORD));
230        // STW a, [fp+offset]
231        emitOp3(0b11, a, 0b000100, SPARC.fp, ret.getRawOffset() + SPARC.STACK_BIAS);
232        return ret;
233    }
234
235    @Override
236    public Register emitUncompressPointer(Register compressed, long base, int shift) {
237        Register ret;
238        if (shift > 0) {
239            ret = newRegister();
240            emitOp3(0b10, ret, 0b100101, compressed, shift); // SLL compressed, shift, ret
241        } else {
242            ret = compressed;
243        }
244        if (base == 0) {
245            return ret;
246        } else {
247            Register b = emitLoadLong(base);
248            emitOp3(0b10, b, 0b00000, ret, b); // ADD b, ret, b
249            return b;
250        }
251    }
252
253    @Override
254    public Register emitIntAdd(Register a, Register b) {
255        Register ret = newRegister();
256        emitOp3(0b10, ret, 0b00000, a, b); // ADD a, b, ret
257        return ret;
258    }
259
260    private void emitMove(Register to, Register from) {
261        if (to != from) {
262            emitOp3(0b10, to, 0b000010, from, SPARC.g0); // OR from, g0, to
263        }
264    }
265
266    @Override
267    public void emitIntRet(Register a) {
268        emitPointerRet(a);
269    }
270
271    @Override
272    public void emitPointerRet(Register a) {
273        emitMove(SPARC.i0, a);
274        emitOp3(0b10, SPARC.g0, 0b111000, SPARC.i7, 8);        // JMPL [i7+8], g0
275        emitOp3(0b10, SPARC.g0, 0b111101, SPARC.g0, SPARC.g0); // RESTORE g0, g0, g0
276    }
277
278    @Override
279    public void emitTrap(DebugInfo info) {
280        recordImplicitException(info);
281        emitOp3(0b11, SPARC.g0, 0b001011, SPARC.g0, 0); // LDX [g0+0], g0
282    }
283
284    @Override
285    public DataSectionReference emitDataItem(HotSpotConstant c) {
286        if (c.isCompressed()) {
287            data.align(4);
288        } else {
289            data.align(8);
290        }
291        return super.emitDataItem(c);
292    }
293}
294