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