?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
softmmu: commonize helper definitions
[qemu-kvm.git] / tcg / sparc / tcg-target.c
blob40f2ec10274f7abf4693b6c06872e32b0e500b4f
1 /*
2 * Tiny Code Generator for QEMU
3 *
4 * Copyright (c) 2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "tcg-be-null.h"
26
27 #ifndef NDEBUG
28 static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
29 "%g0",
30 "%g1",
31 "%g2",
32 "%g3",
33 "%g4",
34 "%g5",
35 "%g6",
36 "%g7",
37 "%o0",
38 "%o1",
39 "%o2",
40 "%o3",
41 "%o4",
42 "%o5",
43 "%o6",
44 "%o7",
45 "%l0",
46 "%l1",
47 "%l2",
48 "%l3",
49 "%l4",
50 "%l5",
51 "%l6",
52 "%l7",
53 "%i0",
54 "%i1",
55 "%i2",
56 "%i3",
57 "%i4",
58 "%i5",
59 "%i6",
60 "%i7",
61 };
62 #endif
63
64 #ifdef __arch64__
65 # define SPARC64 1
66 #else
67 # define SPARC64 0
68 #endif
69
70 /* Note that sparcv8plus can only hold 64 bit quantities in %g and %o
71 registers. These are saved manually by the kernel in full 64-bit
72 slots. The %i and %l registers are saved by the register window
73 mechanism, which only allocates space for 32 bits. Given that this
74 window spill/fill can happen on any signal, we must consider the
75 high bits of the %i and %l registers garbage at all times. */
76 #if SPARC64
77 # define ALL_64 0xffffffffu
78 #else
79 # define ALL_64 0xffffu
80 #endif
81
82 /* Define some temporary registers. T2 is used for constant generation. */
83 #define TCG_REG_T1 TCG_REG_G1
84 #define TCG_REG_T2 TCG_REG_O7
85
86 #ifdef CONFIG_USE_GUEST_BASE
87 # define TCG_GUEST_BASE_REG TCG_REG_I5
88 #else
89 # define TCG_GUEST_BASE_REG TCG_REG_G0
90 #endif
91
92 static const int tcg_target_reg_alloc_order[] = {
93 TCG_REG_L0,
94 TCG_REG_L1,
95 TCG_REG_L2,
96 TCG_REG_L3,
97 TCG_REG_L4,
98 TCG_REG_L5,
99 TCG_REG_L6,
100 TCG_REG_L7,
101
102 TCG_REG_I0,
103 TCG_REG_I1,
104 TCG_REG_I2,
105 TCG_REG_I3,
106 TCG_REG_I4,
107 TCG_REG_I5,
108
109 TCG_REG_G2,
110 TCG_REG_G3,
111 TCG_REG_G4,
112 TCG_REG_G5,
113
114 TCG_REG_O0,
115 TCG_REG_O1,
116 TCG_REG_O2,
117 TCG_REG_O3,
118 TCG_REG_O4,
119 TCG_REG_O5,
120 };
121
122 static const int tcg_target_call_iarg_regs[6] = {
123 TCG_REG_O0,
124 TCG_REG_O1,
125 TCG_REG_O2,
126 TCG_REG_O3,
127 TCG_REG_O4,
128 TCG_REG_O5,
129 };
130
131 static const int tcg_target_call_oarg_regs[] = {
132 TCG_REG_O0,
133 TCG_REG_O1,
134 TCG_REG_O2,
135 TCG_REG_O3,
136 };
137
138 #define INSN_OP(x) ((x) << 30)
139 #define INSN_OP2(x) ((x) << 22)
140 #define INSN_OP3(x) ((x) << 19)
141 #define INSN_OPF(x) ((x) << 5)
142 #define INSN_RD(x) ((x) << 25)
143 #define INSN_RS1(x) ((x) << 14)
144 #define INSN_RS2(x) (x)
145 #define INSN_ASI(x) ((x) << 5)
146
147 #define INSN_IMM10(x) ((1 << 13) | ((x) & 0x3ff))
148 #define INSN_IMM11(x) ((1 << 13) | ((x) & 0x7ff))
149 #define INSN_IMM13(x) ((1 << 13) | ((x) & 0x1fff))
150 #define INSN_OFF16(x) ((((x) >> 2) & 0x3fff) | ((((x) >> 16) & 3) << 20))
151 #define INSN_OFF19(x) (((x) >> 2) & 0x07ffff)
152 #define INSN_COND(x) ((x) << 25)
153
154 #define COND_N 0x0
155 #define COND_E 0x1
156 #define COND_LE 0x2
157 #define COND_L 0x3
158 #define COND_LEU 0x4
159 #define COND_CS 0x5
160 #define COND_NEG 0x6
161 #define COND_VS 0x7
162 #define COND_A 0x8
163 #define COND_NE 0x9
164 #define COND_G 0xa
165 #define COND_GE 0xb
166 #define COND_GU 0xc
167 #define COND_CC 0xd
168 #define COND_POS 0xe
169 #define COND_VC 0xf
170 #define BA (INSN_OP(0) | INSN_COND(COND_A) | INSN_OP2(0x2))
171
172 #define RCOND_Z 1
173 #define RCOND_LEZ 2
174 #define RCOND_LZ 3
175 #define RCOND_NZ 5
176 #define RCOND_GZ 6
177 #define RCOND_GEZ 7
178
179 #define MOVCC_ICC (1 << 18)
180 #define MOVCC_XCC (1 << 18 | 1 << 12)
181
182 #define BPCC_ICC 0
183 #define BPCC_XCC (2 << 20)
184 #define BPCC_PT (1 << 19)
185 #define BPCC_PN 0
186 #define BPCC_A (1 << 29)
187
188 #define BPR_PT BPCC_PT
189
190 #define ARITH_ADD (INSN_OP(2) | INSN_OP3(0x00))
191 #define ARITH_ADDCC (INSN_OP(2) | INSN_OP3(0x10))
192 #define ARITH_AND (INSN_OP(2) | INSN_OP3(0x01))
193 #define ARITH_ANDN (INSN_OP(2) | INSN_OP3(0x05))
194 #define ARITH_OR (INSN_OP(2) | INSN_OP3(0x02))
195 #define ARITH_ORCC (INSN_OP(2) | INSN_OP3(0x12))
196 #define ARITH_ORN (INSN_OP(2) | INSN_OP3(0x06))
197 #define ARITH_XOR (INSN_OP(2) | INSN_OP3(0x03))
198 #define ARITH_SUB (INSN_OP(2) | INSN_OP3(0x04))
199 #define ARITH_SUBCC (INSN_OP(2) | INSN_OP3(0x14))
200 #define ARITH_ADDX (INSN_OP(2) | INSN_OP3(0x08))
201 #define ARITH_SUBX (INSN_OP(2) | INSN_OP3(0x0c))
202 #define ARITH_UMUL (INSN_OP(2) | INSN_OP3(0x0a))
203 #define ARITH_SMUL (INSN_OP(2) | INSN_OP3(0x0b))
204 #define ARITH_UDIV (INSN_OP(2) | INSN_OP3(0x0e))
205 #define ARITH_SDIV (INSN_OP(2) | INSN_OP3(0x0f))
206 #define ARITH_MULX (INSN_OP(2) | INSN_OP3(0x09))
207 #define ARITH_UDIVX (INSN_OP(2) | INSN_OP3(0x0d))
208 #define ARITH_SDIVX (INSN_OP(2) | INSN_OP3(0x2d))
209 #define ARITH_MOVCC (INSN_OP(2) | INSN_OP3(0x2c))
210 #define ARITH_MOVR (INSN_OP(2) | INSN_OP3(0x2f))
211
212 #define SHIFT_SLL (INSN_OP(2) | INSN_OP3(0x25))
213 #define SHIFT_SRL (INSN_OP(2) | INSN_OP3(0x26))
214 #define SHIFT_SRA (INSN_OP(2) | INSN_OP3(0x27))
215
216 #define SHIFT_SLLX (INSN_OP(2) | INSN_OP3(0x25) | (1 << 12))
217 #define SHIFT_SRLX (INSN_OP(2) | INSN_OP3(0x26) | (1 << 12))
218 #define SHIFT_SRAX (INSN_OP(2) | INSN_OP3(0x27) | (1 << 12))
219
220 #define RDY (INSN_OP(2) | INSN_OP3(0x28) | INSN_RS1(0))
221 #define WRY (INSN_OP(2) | INSN_OP3(0x30) | INSN_RD(0))
222 #define JMPL (INSN_OP(2) | INSN_OP3(0x38))
223 #define RETURN (INSN_OP(2) | INSN_OP3(0x39))
224 #define SAVE (INSN_OP(2) | INSN_OP3(0x3c))
225 #define RESTORE (INSN_OP(2) | INSN_OP3(0x3d))
226 #define SETHI (INSN_OP(0) | INSN_OP2(0x4))
227 #define CALL INSN_OP(1)
228 #define LDUB (INSN_OP(3) | INSN_OP3(0x01))
229 #define LDSB (INSN_OP(3) | INSN_OP3(0x09))
230 #define LDUH (INSN_OP(3) | INSN_OP3(0x02))
231 #define LDSH (INSN_OP(3) | INSN_OP3(0x0a))
232 #define LDUW (INSN_OP(3) | INSN_OP3(0x00))
233 #define LDSW (INSN_OP(3) | INSN_OP3(0x08))
234 #define LDX (INSN_OP(3) | INSN_OP3(0x0b))
235 #define STB (INSN_OP(3) | INSN_OP3(0x05))
236 #define STH (INSN_OP(3) | INSN_OP3(0x06))
237 #define STW (INSN_OP(3) | INSN_OP3(0x04))
238 #define STX (INSN_OP(3) | INSN_OP3(0x0e))
239 #define LDUBA (INSN_OP(3) | INSN_OP3(0x11))
240 #define LDSBA (INSN_OP(3) | INSN_OP3(0x19))
241 #define LDUHA (INSN_OP(3) | INSN_OP3(0x12))
242 #define LDSHA (INSN_OP(3) | INSN_OP3(0x1a))
243 #define LDUWA (INSN_OP(3) | INSN_OP3(0x10))
244 #define LDSWA (INSN_OP(3) | INSN_OP3(0x18))
245 #define LDXA (INSN_OP(3) | INSN_OP3(0x1b))
246 #define STBA (INSN_OP(3) | INSN_OP3(0x15))
247 #define STHA (INSN_OP(3) | INSN_OP3(0x16))
248 #define STWA (INSN_OP(3) | INSN_OP3(0x14))
249 #define STXA (INSN_OP(3) | INSN_OP3(0x1e))
250
251 #ifndef ASI_PRIMARY_LITTLE
252 #define ASI_PRIMARY_LITTLE 0x88
253 #endif
254
255 #define LDUH_LE (LDUHA | INSN_ASI(ASI_PRIMARY_LITTLE))
256 #define LDSH_LE (LDSHA | INSN_ASI(ASI_PRIMARY_LITTLE))
257 #define LDUW_LE (LDUWA | INSN_ASI(ASI_PRIMARY_LITTLE))
258 #define LDSW_LE (LDSWA | INSN_ASI(ASI_PRIMARY_LITTLE))
259 #define LDX_LE (LDXA | INSN_ASI(ASI_PRIMARY_LITTLE))
260
261 #define STH_LE (STHA | INSN_ASI(ASI_PRIMARY_LITTLE))
262 #define STW_LE (STWA | INSN_ASI(ASI_PRIMARY_LITTLE))
263 #define STX_LE (STXA | INSN_ASI(ASI_PRIMARY_LITTLE))
264
265 static inline int check_fit_i64(int64_t val, unsigned int bits)
266 {
267 return val == sextract64(val, 0, bits);
268 }
269
270 static inline int check_fit_i32(int32_t val, unsigned int bits)
271 {
272 return val == sextract32(val, 0, bits);
273 }
274
275 #define check_fit_tl check_fit_i64
276 #if SPARC64
277 # define check_fit_ptr check_fit_i64
278 #else
279 # define check_fit_ptr check_fit_i32
280 #endif
281
282 static void patch_reloc(tcg_insn_unit *code_ptr, int type,
283 intptr_t value, intptr_t addend)
284 {
285 uint32_t insn;
286
287 assert(addend == 0);
288 value = tcg_ptr_byte_diff((tcg_insn_unit *)value, code_ptr);
289
290 switch (type) {
291 case R_SPARC_WDISP16:
292 if (!check_fit_ptr(value >> 2, 16)) {
293 tcg_abort();
294 }
295 insn = *code_ptr;
296 insn &= ~INSN_OFF16(-1);
297 insn |= INSN_OFF16(value);
298 *code_ptr = insn;
299 break;
300 case R_SPARC_WDISP19:
301 if (!check_fit_ptr(value >> 2, 19)) {
302 tcg_abort();
303 }
304 insn = *code_ptr;
305 insn &= ~INSN_OFF19(-1);
306 insn |= INSN_OFF19(value);
307 *code_ptr = insn;
308 break;
309 default:
310 tcg_abort();
311 }
312 }
313
314 /* parse target specific constraints */
315 static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
316 {
317 const char *ct_str;
318
319 ct_str = *pct_str;
320 switch (ct_str[0]) {
321 case 'r':
322 ct->ct |= TCG_CT_REG;
323 tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
324 break;
325 case 'R':
326 ct->ct |= TCG_CT_REG;
327 tcg_regset_set32(ct->u.regs, 0, ALL_64);
328 break;
329 case 'A': /* qemu_ld/st address constraint */
330 ct->ct |= TCG_CT_REG;
331 tcg_regset_set32(ct->u.regs, 0,
332 TARGET_LONG_BITS == 64 ? ALL_64 : 0xffffffff);
333 reserve_helpers:
334 tcg_regset_reset_reg(ct->u.regs, TCG_REG_O0);
335 tcg_regset_reset_reg(ct->u.regs, TCG_REG_O1);
336 tcg_regset_reset_reg(ct->u.regs, TCG_REG_O2);
337 break;
338 case 's': /* qemu_st data 32-bit constraint */
339 ct->ct |= TCG_CT_REG;
340 tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
341 goto reserve_helpers;
342 case 'S': /* qemu_st data 64-bit constraint */
343 ct->ct |= TCG_CT_REG;
344 tcg_regset_set32(ct->u.regs, 0, ALL_64);
345 goto reserve_helpers;
346 case 'I':
347 ct->ct |= TCG_CT_CONST_S11;
348 break;
349 case 'J':
350 ct->ct |= TCG_CT_CONST_S13;
351 break;
352 case 'Z':
353 ct->ct |= TCG_CT_CONST_ZERO;
354 break;
355 default:
356 return -1;
357 }
358 ct_str++;
359 *pct_str = ct_str;
360 return 0;
361 }
362
363 /* test if a constant matches the constraint */
364 static inline int tcg_target_const_match(tcg_target_long val, TCGType type,
365 const TCGArgConstraint *arg_ct)
366 {
367 int ct = arg_ct->ct;
368
369 if (ct & TCG_CT_CONST) {
370 return 1;
371 }
372
373 if (type == TCG_TYPE_I32) {
374 val = (int32_t)val;
375 }
376
377 if ((ct & TCG_CT_CONST_ZERO) && val == 0) {
378 return 1;
379 } else if ((ct & TCG_CT_CONST_S11) && check_fit_tl(val, 11)) {
380 return 1;
381 } else if ((ct & TCG_CT_CONST_S13) && check_fit_tl(val, 13)) {
382 return 1;
383 } else {
384 return 0;
385 }
386 }
387
388 static inline void tcg_out_arith(TCGContext *s, TCGReg rd, TCGReg rs1,
389 TCGReg rs2, int op)
390 {
391 tcg_out32(s, op | INSN_RD(rd) | INSN_RS1(rs1) | INSN_RS2(rs2));
392 }
393
394 static inline void tcg_out_arithi(TCGContext *s, TCGReg rd, TCGReg rs1,
395 int32_t offset, int op)
396 {
397 tcg_out32(s, op | INSN_RD(rd) | INSN_RS1(rs1) | INSN_IMM13(offset));
398 }
399
400 static void tcg_out_arithc(TCGContext *s, TCGReg rd, TCGReg rs1,
401 int32_t val2, int val2const, int op)
402 {
403 tcg_out32(s, op | INSN_RD(rd) | INSN_RS1(rs1)
404 | (val2const ? INSN_IMM13(val2) : INSN_RS2(val2)));
405 }
406
407 static inline void tcg_out_mov(TCGContext *s, TCGType type,
408 TCGReg ret, TCGReg arg)
409 {
410 if (ret != arg) {
411 tcg_out_arith(s, ret, arg, TCG_REG_G0, ARITH_OR);
412 }
413 }
414
415 static inline void tcg_out_sethi(TCGContext *s, TCGReg ret, uint32_t arg)
416 {
417 tcg_out32(s, SETHI | INSN_RD(ret) | ((arg & 0xfffffc00) >> 10));
418 }
419
420 static inline void tcg_out_movi_imm13(TCGContext *s, TCGReg ret, int32_t arg)
421 {
422 tcg_out_arithi(s, ret, TCG_REG_G0, arg, ARITH_OR);
423 }
424
425 static void tcg_out_movi(TCGContext *s, TCGType type,
426 TCGReg ret, tcg_target_long arg)
427 {
428 tcg_target_long hi, lo = (int32_t)arg;
429
430 /* Make sure we test 32-bit constants for imm13 properly. */
431 if (type == TCG_TYPE_I32) {
432 arg = lo;
433 }
434
435 /* A 13-bit constant sign-extended to 64-bits. */
436 if (check_fit_tl(arg, 13)) {
437 tcg_out_movi_imm13(s, ret, arg);
438 return;
439 }
440
441 /* A 32-bit constant, or 32-bit zero-extended to 64-bits. */
442 if (type == TCG_TYPE_I32 || arg == (uint32_t)arg) {
443 tcg_out_sethi(s, ret, arg);
444 if (arg & 0x3ff) {
445 tcg_out_arithi(s, ret, ret, arg & 0x3ff, ARITH_OR);
446 }
447 return;
448 }
449
450 /* A 32-bit constant sign-extended to 64-bits. */
451 if (arg == lo) {
452 tcg_out_sethi(s, ret, ~arg);
453 tcg_out_arithi(s, ret, ret, (arg & 0x3ff) | -0x400, ARITH_XOR);
454 return;
455 }
456
457 /* A 64-bit constant decomposed into 2 32-bit pieces. */
458 if (check_fit_i32(lo, 13)) {
459 hi = (arg - lo) >> 32;
460 tcg_out_movi(s, TCG_TYPE_I32, ret, hi);
461 tcg_out_arithi(s, ret, ret, 32, SHIFT_SLLX);
462 tcg_out_arithi(s, ret, ret, lo, ARITH_ADD);
463 } else {
464 hi = arg >> 32;
465 tcg_out_movi(s, TCG_TYPE_I32, ret, hi);
466 tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_T2, lo);
467 tcg_out_arithi(s, ret, ret, 32, SHIFT_SLLX);
468 tcg_out_arith(s, ret, ret, TCG_REG_T2, ARITH_OR);
469 }
470 }
471
472 static inline void tcg_out_ldst_rr(TCGContext *s, TCGReg data, TCGReg a1,
473 TCGReg a2, int op)
474 {
475 tcg_out32(s, op | INSN_RD(data) | INSN_RS1(a1) | INSN_RS2(a2));
476 }
477
478 static void tcg_out_ldst(TCGContext *s, TCGReg ret, TCGReg addr,
479 intptr_t offset, int op)
480 {
481 if (check_fit_ptr(offset, 13)) {
482 tcg_out32(s, op | INSN_RD(ret) | INSN_RS1(addr) |
483 INSN_IMM13(offset));
484 } else {
485 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_T1, offset);
486 tcg_out_ldst_rr(s, ret, addr, TCG_REG_T1, op);
487 }
488 }
489
490 static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret,
491 TCGReg arg1, intptr_t arg2)
492 {
493 tcg_out_ldst(s, ret, arg1, arg2, (type == TCG_TYPE_I32 ? LDUW : LDX));
494 }
495
496 static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
497 TCGReg arg1, intptr_t arg2)
498 {
499 tcg_out_ldst(s, arg, arg1, arg2, (type == TCG_TYPE_I32 ? STW : STX));
500 }
501
502 static void tcg_out_ld_ptr(TCGContext *s, TCGReg ret, uintptr_t arg)
503 {
504 tcg_out_movi(s, TCG_TYPE_PTR, ret, arg & ~0x3ff);
505 tcg_out_ld(s, TCG_TYPE_PTR, ret, ret, arg & 0x3ff);
506 }
507
508 static inline void tcg_out_sety(TCGContext *s, TCGReg rs)
509 {
510 tcg_out32(s, WRY | INSN_RS1(TCG_REG_G0) | INSN_RS2(rs));
511 }
512
513 static inline void tcg_out_rdy(TCGContext *s, TCGReg rd)
514 {
515 tcg_out32(s, RDY | INSN_RD(rd));
516 }
517
518 static void tcg_out_div32(TCGContext *s, TCGReg rd, TCGReg rs1,
519 int32_t val2, int val2const, int uns)
520 {
521 /* Load Y with the sign/zero extension of RS1 to 64-bits. */
522 if (uns) {
523 tcg_out_sety(s, TCG_REG_G0);
524 } else {
525 tcg_out_arithi(s, TCG_REG_T1, rs1, 31, SHIFT_SRA);
526 tcg_out_sety(s, TCG_REG_T1);
527 }
528
529 tcg_out_arithc(s, rd, rs1, val2, val2const,
530 uns ? ARITH_UDIV : ARITH_SDIV);
531 }
532
533 static inline void tcg_out_nop(TCGContext *s)
534 {
535 tcg_out_sethi(s, TCG_REG_G0, 0);
536 }
537
538 static const uint8_t tcg_cond_to_bcond[] = {
539 [TCG_COND_EQ] = COND_E,
540 [TCG_COND_NE] = COND_NE,
541 [TCG_COND_LT] = COND_L,
542 [TCG_COND_GE] = COND_GE,
543 [TCG_COND_LE] = COND_LE,
544 [TCG_COND_GT] = COND_G,
545 [TCG_COND_LTU] = COND_CS,
546 [TCG_COND_GEU] = COND_CC,
547 [TCG_COND_LEU] = COND_LEU,
548 [TCG_COND_GTU] = COND_GU,
549 };
550
551 static const uint8_t tcg_cond_to_rcond[] = {
552 [TCG_COND_EQ] = RCOND_Z,
553 [TCG_COND_NE] = RCOND_NZ,
554 [TCG_COND_LT] = RCOND_LZ,
555 [TCG_COND_GT] = RCOND_GZ,
556 [TCG_COND_LE] = RCOND_LEZ,
557 [TCG_COND_GE] = RCOND_GEZ
558 };
559
560 static void tcg_out_bpcc0(TCGContext *s, int scond, int flags, int off19)
561 {
562 tcg_out32(s, INSN_OP(0) | INSN_OP2(1) | INSN_COND(scond) | flags | off19);
563 }
564
565 static void tcg_out_bpcc(TCGContext *s, int scond, int flags, int label)
566 {
567 TCGLabel *l = &s->labels[label];
568 int off19;
569
570 if (l->has_value) {
571 off19 = INSN_OFF19(tcg_pcrel_diff(s, l->u.value_ptr));
572 } else {
573 /* Make sure to preserve destinations during retranslation. */
574 off19 = *s->code_ptr & INSN_OFF19(-1);
575 tcg_out_reloc(s, s->code_ptr, R_SPARC_WDISP19, label, 0);
576 }
577 tcg_out_bpcc0(s, scond, flags, off19);
578 }
579
580 static void tcg_out_cmp(TCGContext *s, TCGReg c1, int32_t c2, int c2const)
581 {
582 tcg_out_arithc(s, TCG_REG_G0, c1, c2, c2const, ARITH_SUBCC);
583 }
584
585 static void tcg_out_brcond_i32(TCGContext *s, TCGCond cond, TCGReg arg1,
586 int32_t arg2, int const_arg2, int label)
587 {
588 tcg_out_cmp(s, arg1, arg2, const_arg2);
589 tcg_out_bpcc(s, tcg_cond_to_bcond[cond], BPCC_ICC | BPCC_PT, label);
590 tcg_out_nop(s);
591 }
592
593 static void tcg_out_movcc(TCGContext *s, TCGCond cond, int cc, TCGReg ret,
594 int32_t v1, int v1const)
595 {
596 tcg_out32(s, ARITH_MOVCC | cc | INSN_RD(ret)
597 | INSN_RS1(tcg_cond_to_bcond[cond])
598 | (v1const ? INSN_IMM11(v1) : INSN_RS2(v1)));
599 }
600
601 static void tcg_out_movcond_i32(TCGContext *s, TCGCond cond, TCGReg ret,
602 TCGReg c1, int32_t c2, int c2const,
603 int32_t v1, int v1const)
604 {
605 tcg_out_cmp(s, c1, c2, c2const);
606 tcg_out_movcc(s, cond, MOVCC_ICC, ret, v1, v1const);
607 }
608
609 static void tcg_out_brcond_i64(TCGContext *s, TCGCond cond, TCGReg arg1,
610 int32_t arg2, int const_arg2, int label)
611 {
612 /* For 64-bit signed comparisons vs zero, we can avoid the compare. */
613 if (arg2 == 0 && !is_unsigned_cond(cond)) {
614 TCGLabel *l = &s->labels[label];
615 int off16;
616
617 if (l->has_value) {
618 off16 = INSN_OFF16(tcg_pcrel_diff(s, l->u.value_ptr));
619 } else {
620 /* Make sure to preserve destinations during retranslation. */
621 off16 = *s->code_ptr & INSN_OFF16(-1);
622 tcg_out_reloc(s, s->code_ptr, R_SPARC_WDISP16, label, 0);
623 }
624 tcg_out32(s, INSN_OP(0) | INSN_OP2(3) | BPR_PT | INSN_RS1(arg1)
625 | INSN_COND(tcg_cond_to_rcond[cond]) | off16);
626 } else {
627 tcg_out_cmp(s, arg1, arg2, const_arg2);
628 tcg_out_bpcc(s, tcg_cond_to_bcond[cond], BPCC_XCC | BPCC_PT, label);
629 }
630 tcg_out_nop(s);
631 }
632
633 static void tcg_out_movr(TCGContext *s, TCGCond cond, TCGReg ret, TCGReg c1,
634 int32_t v1, int v1const)
635 {
636 tcg_out32(s, ARITH_MOVR | INSN_RD(ret) | INSN_RS1(c1)
637 | (tcg_cond_to_rcond[cond] << 10)
638 | (v1const ? INSN_IMM10(v1) : INSN_RS2(v1)));
639 }
640
641 static void tcg_out_movcond_i64(TCGContext *s, TCGCond cond, TCGReg ret,
642 TCGReg c1, int32_t c2, int c2const,
643 int32_t v1, int v1const)
644 {
645 /* For 64-bit signed comparisons vs zero, we can avoid the compare.
646 Note that the immediate range is one bit smaller, so we must check
647 for that as well. */
648 if (c2 == 0 && !is_unsigned_cond(cond)
649 && (!v1const || check_fit_i32(v1, 10))) {
650 tcg_out_movr(s, cond, ret, c1, v1, v1const);
651 } else {
652 tcg_out_cmp(s, c1, c2, c2const);
653 tcg_out_movcc(s, cond, MOVCC_XCC, ret, v1, v1const);
654 }
655 }
656
657 static void tcg_out_setcond_i32(TCGContext *s, TCGCond cond, TCGReg ret,
658 TCGReg c1, int32_t c2, int c2const)
659 {
660 /* For 32-bit comparisons, we can play games with ADDX/SUBX. */
661 switch (cond) {
662 case TCG_COND_LTU:
663 case TCG_COND_GEU:
664 /* The result of the comparison is in the carry bit. */
665 break;
666
667 case TCG_COND_EQ:
668 case TCG_COND_NE:
669 /* For equality, we can transform to inequality vs zero. */
670 if (c2 != 0) {
671 tcg_out_arithc(s, ret, c1, c2, c2const, ARITH_XOR);
672 }
673 c1 = TCG_REG_G0, c2 = ret, c2const = 0;
674 cond = (cond == TCG_COND_EQ ? TCG_COND_GEU : TCG_COND_LTU);
675 break;
676
677 case TCG_COND_GTU:
678 case TCG_COND_LEU:
679 /* If we don't need to load a constant into a register, we can
680 swap the operands on GTU/LEU. There's no benefit to loading
681 the constant into a temporary register. */
682 if (!c2const || c2 == 0) {
683 TCGReg t = c1;
684 c1 = c2;
685 c2 = t;
686 c2const = 0;
687 cond = tcg_swap_cond(cond);
688 break;
689 }
690 /* FALLTHRU */
691
692 default:
693 tcg_out_cmp(s, c1, c2, c2const);
694 tcg_out_movi_imm13(s, ret, 0);
695 tcg_out_movcc(s, cond, MOVCC_ICC, ret, 1, 1);
696 return;
697 }
698
699 tcg_out_cmp(s, c1, c2, c2const);
700 if (cond == TCG_COND_LTU) {
701 tcg_out_arithi(s, ret, TCG_REG_G0, 0, ARITH_ADDX);
702 } else {
703 tcg_out_arithi(s, ret, TCG_REG_G0, -1, ARITH_SUBX);
704 }
705 }
706
707 static void tcg_out_setcond_i64(TCGContext *s, TCGCond cond, TCGReg ret,
708 TCGReg c1, int32_t c2, int c2const)
709 {
710 /* For 64-bit signed comparisons vs zero, we can avoid the compare
711 if the input does not overlap the output. */
712 if (c2 == 0 && !is_unsigned_cond(cond) && c1 != ret) {
713 tcg_out_movi_imm13(s, ret, 0);
714 tcg_out_movr(s, cond, ret, c1, 1, 1);
715 } else {
716 tcg_out_cmp(s, c1, c2, c2const);
717 tcg_out_movi_imm13(s, ret, 0);
718 tcg_out_movcc(s, cond, MOVCC_XCC, ret, 1, 1);
719 }
720 }
721
722 static void tcg_out_addsub2(TCGContext *s, TCGReg rl, TCGReg rh,
723 TCGReg al, TCGReg ah, int32_t bl, int blconst,
724 int32_t bh, int bhconst, int opl, int oph)
725 {
726 TCGReg tmp = TCG_REG_T1;
727
728 /* Note that the low parts are fully consumed before tmp is set. */
729 if (rl != ah && (bhconst || rl != bh)) {
730 tmp = rl;
731 }
732
733 tcg_out_arithc(s, tmp, al, bl, blconst, opl);
734 tcg_out_arithc(s, rh, ah, bh, bhconst, oph);
735 tcg_out_mov(s, TCG_TYPE_I32, rl, tmp);
736 }
737
738 static void tcg_out_call_nodelay(TCGContext *s, tcg_insn_unit *dest)
739 {
740 ptrdiff_t disp = tcg_pcrel_diff(s, dest);
741
742 if (disp == (int32_t)disp) {
743 tcg_out32(s, CALL | (uint32_t)disp >> 2);
744 } else {
745 uintptr_t desti = (uintptr_t)dest;
746 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_T1, desti & ~0xfff);
747 tcg_out_arithi(s, TCG_REG_O7, TCG_REG_T1, desti & 0xfff, JMPL);
748 }
749 }
750
751 static void tcg_out_call(TCGContext *s, tcg_insn_unit *dest)
752 {
753 tcg_out_call_nodelay(s, dest);
754 tcg_out_nop(s);
755 }
756
757 #ifdef CONFIG_SOFTMMU
758 static tcg_insn_unit *qemu_ld_trampoline[16];
759 static tcg_insn_unit *qemu_st_trampoline[16];
760
761 static void build_trampolines(TCGContext *s)
762 {
763 static void * const qemu_ld_helpers[16] = {
764 [MO_UB] = helper_ret_ldub_mmu,
765 [MO_SB] = helper_ret_ldsb_mmu,
766 [MO_LEUW] = helper_le_lduw_mmu,
767 [MO_LESW] = helper_le_ldsw_mmu,
768 [MO_LEUL] = helper_le_ldul_mmu,
769 [MO_LEQ] = helper_le_ldq_mmu,
770 [MO_BEUW] = helper_be_lduw_mmu,
771 [MO_BESW] = helper_be_ldsw_mmu,
772 [MO_BEUL] = helper_be_ldul_mmu,
773 [MO_BEQ] = helper_be_ldq_mmu,
774 };
775 static void * const qemu_st_helpers[16] = {
776 [MO_UB] = helper_ret_stb_mmu,
777 [MO_LEUW] = helper_le_stw_mmu,
778 [MO_LEUL] = helper_le_stl_mmu,
779 [MO_LEQ] = helper_le_stq_mmu,
780 [MO_BEUW] = helper_be_stw_mmu,
781 [MO_BEUL] = helper_be_stl_mmu,
782 [MO_BEQ] = helper_be_stq_mmu,
783 };
784
785 int i;
786 TCGReg ra;
787
788 for (i = 0; i < 16; ++i) {
789 if (qemu_ld_helpers[i] == NULL) {
790 continue;
791 }
792
793 /* May as well align the trampoline. */
794 while ((uintptr_t)s->code_ptr & 15) {
795 tcg_out_nop(s);
796 }
797 qemu_ld_trampoline[i] = s->code_ptr;
798
799 if (SPARC64 || TARGET_LONG_BITS == 32) {
800 ra = TCG_REG_O3;
801 } else {
802 /* Install the high part of the address. */
803 tcg_out_arithi(s, TCG_REG_O1, TCG_REG_O2, 32, SHIFT_SRLX);
804 ra = TCG_REG_O4;
805 }
806
807 /* Set the retaddr operand. */
808 tcg_out_mov(s, TCG_TYPE_PTR, ra, TCG_REG_O7);
809 /* Set the env operand. */
810 tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_O0, TCG_AREG0);
811 /* Tail call. */
812 tcg_out_call_nodelay(s, qemu_ld_helpers[i]);
813 tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_O7, ra);
814 }
815
816 for (i = 0; i < 16; ++i) {
817 if (qemu_st_helpers[i] == NULL) {
818 continue;
819 }
820
821 /* May as well align the trampoline. */
822 while ((uintptr_t)s->code_ptr & 15) {
823 tcg_out_nop(s);
824 }
825 qemu_st_trampoline[i] = s->code_ptr;
826
827 if (SPARC64) {
828 ra = TCG_REG_O4;
829 } else {
830 ra = TCG_REG_O1;
831 if (TARGET_LONG_BITS == 64) {
832 /* Install the high part of the address. */
833 tcg_out_arithi(s, ra, ra + 1, 32, SHIFT_SRLX);
834 ra += 2;
835 } else {
836 ra += 1;
837 }
838 if ((i & MO_SIZE) == MO_64) {
839 /* Install the high part of the data. */
840 tcg_out_arithi(s, ra, ra + 1, 32, SHIFT_SRLX);
841 ra += 2;
842 } else {
843 ra += 1;
844 }
845 /* Skip the mem_index argument. */
846 ra += 1;
847 }
848
849 /* Set the retaddr operand. */
850 if (ra >= TCG_REG_O6) {
851 tcg_out_st(s, TCG_TYPE_PTR, TCG_REG_O7, TCG_REG_CALL_STACK,
852 TCG_TARGET_CALL_STACK_OFFSET);
853 ra = TCG_REG_G1;
854 }
855 tcg_out_mov(s, TCG_TYPE_PTR, ra, TCG_REG_O7);
856 /* Set the env operand. */
857 tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_O0, TCG_AREG0);
858 /* Tail call. */
859 tcg_out_call_nodelay(s, qemu_st_helpers[i]);
860 tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_O7, ra);
861 }
862 }
863 #endif
864
865 /* Generate global QEMU prologue and epilogue code */
866 static void tcg_target_qemu_prologue(TCGContext *s)
867 {
868 int tmp_buf_size, frame_size;
869
870 /* The TCG temp buffer is at the top of the frame, immediately
871 below the frame pointer. */
872 tmp_buf_size = CPU_TEMP_BUF_NLONGS * (int)sizeof(long);
873 tcg_set_frame(s, TCG_REG_I6, TCG_TARGET_STACK_BIAS - tmp_buf_size,
874 tmp_buf_size);
875
876 /* TCG_TARGET_CALL_STACK_OFFSET includes the stack bias, but is
877 otherwise the minimal frame usable by callees. */
878 frame_size = TCG_TARGET_CALL_STACK_OFFSET - TCG_TARGET_STACK_BIAS;
879 frame_size += TCG_STATIC_CALL_ARGS_SIZE + tmp_buf_size;
880 frame_size += TCG_TARGET_STACK_ALIGN - 1;
881 frame_size &= -TCG_TARGET_STACK_ALIGN;
882 tcg_out32(s, SAVE | INSN_RD(TCG_REG_O6) | INSN_RS1(TCG_REG_O6) |
883 INSN_IMM13(-frame_size));
884
885 #ifdef CONFIG_USE_GUEST_BASE
886 if (GUEST_BASE != 0) {
887 tcg_out_movi(s, TCG_TYPE_PTR, TCG_GUEST_BASE_REG, GUEST_BASE);
888 tcg_regset_set_reg(s->reserved_regs, TCG_GUEST_BASE_REG);
889 }
890 #endif
891
892 tcg_out_arithi(s, TCG_REG_G0, TCG_REG_I1, 0, JMPL);
893 /* delay slot */
894 tcg_out_nop(s);
895
896 /* No epilogue required. We issue ret + restore directly in the TB. */
897
898 #ifdef CONFIG_SOFTMMU
899 build_trampolines(s);
900 #endif
901 }
902
903 #if defined(CONFIG_SOFTMMU)
904 /* Perform the TLB load and compare.
905
906 Inputs:
907 ADDRLO and ADDRHI contain the possible two parts of the address.
908
909 MEM_INDEX and S_BITS are the memory context and log2 size of the load.
910
911 WHICH is the offset into the CPUTLBEntry structure of the slot to read.
912 This should be offsetof addr_read or addr_write.
913
914 The result of the TLB comparison is in %[ix]cc. The sanitized address
915 is in the returned register, maybe %o0. The TLB addend is in %o1. */
916
917 static TCGReg tcg_out_tlb_load(TCGContext *s, TCGReg addr, int mem_index,
918 TCGMemOp s_bits, int which)
919 {
920 const TCGReg r0 = TCG_REG_O0;
921 const TCGReg r1 = TCG_REG_O1;
922 const TCGReg r2 = TCG_REG_O2;
923 int tlb_ofs;
924
925 /* Shift the page number down. */
926 tcg_out_arithi(s, r1, addr, TARGET_PAGE_BITS, SHIFT_SRL);
927
928 /* Mask out the page offset, except for the required alignment. */
929 tcg_out_movi(s, TCG_TYPE_TL, TCG_REG_T1,
930 TARGET_PAGE_MASK | ((1 << s_bits) - 1));
931
932 /* Mask the tlb index. */
933 tcg_out_arithi(s, r1, r1, CPU_TLB_SIZE - 1, ARITH_AND);
934
935 /* Mask page, part 2. */
936 tcg_out_arith(s, r0, addr, TCG_REG_T1, ARITH_AND);
937
938 /* Shift the tlb index into place. */
939 tcg_out_arithi(s, r1, r1, CPU_TLB_ENTRY_BITS, SHIFT_SLL);
940
941 /* Relative to the current ENV. */
942 tcg_out_arith(s, r1, TCG_AREG0, r1, ARITH_ADD);
943
944 /* Find a base address that can load both tlb comparator and addend. */
945 tlb_ofs = offsetof(CPUArchState, tlb_table[mem_index][0]);
946 if (!check_fit_ptr(tlb_ofs + sizeof(CPUTLBEntry), 13)) {
947 if (tlb_ofs & ~0x3ff) {
948 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_T1, tlb_ofs & ~0x3ff);
949 tcg_out_arith(s, r1, r1, TCG_REG_T1, ARITH_ADD);
950 }
951 tlb_ofs &= 0x3ff;
952 }
953
954 /* Load the tlb comparator and the addend. */
955 tcg_out_ld(s, TCG_TYPE_TL, r2, r1, tlb_ofs + which);
956 tcg_out_ld(s, TCG_TYPE_PTR, r1, r1, tlb_ofs+offsetof(CPUTLBEntry, addend));
957
958 /* subcc arg0, arg2, %g0 */
959 tcg_out_cmp(s, r0, r2, 0);
960
961 /* If the guest address must be zero-extended, do so now. */
962 if (SPARC64 && TARGET_LONG_BITS == 32) {
963 tcg_out_arithi(s, r0, addr, 0, SHIFT_SRL);
964 return r0;
965 }
966 return addr;
967 }
968 #endif /* CONFIG_SOFTMMU */
969
970 static const int qemu_ld_opc[16] = {
971 [MO_UB] = LDUB,
972 [MO_SB] = LDSB,
973
974 [MO_BEUW] = LDUH,
975 [MO_BESW] = LDSH,
976 [MO_BEUL] = LDUW,
977 [MO_BESL] = LDSW,
978 [MO_BEQ] = LDX,
979
980 [MO_LEUW] = LDUH_LE,
981 [MO_LESW] = LDSH_LE,
982 [MO_LEUL] = LDUW_LE,
983 [MO_LESL] = LDSW_LE,
984 [MO_LEQ] = LDX_LE,
985 };
986
987 static const int qemu_st_opc[16] = {
988 [MO_UB] = STB,
989
990 [MO_BEUW] = STH,
991 [MO_BEUL] = STW,
992 [MO_BEQ] = STX,
993
994 [MO_LEUW] = STH_LE,
995 [MO_LEUL] = STW_LE,
996 [MO_LEQ] = STX_LE,
997 };
998
999 static void tcg_out_qemu_ld(TCGContext *s, TCGReg data, TCGReg addr,
1000 TCGMemOp memop, int memi, bool is_64)
1001 {
1002 #ifdef CONFIG_SOFTMMU
1003 TCGMemOp s_bits = memop & MO_SIZE;
1004 TCGReg addrz, param;
1005 tcg_insn_unit *func;
1006 tcg_insn_unit *label_ptr;
1007
1008 addrz = tcg_out_tlb_load(s, addr, memi, s_bits,
1009 offsetof(CPUTLBEntry, addr_read));
1010
1011 /* The fast path is exactly one insn. Thus we can perform the
1012 entire TLB Hit in the (annulled) delay slot of the branch
1013 over the TLB Miss case. */
1014
1015 /* beq,a,pt %[xi]cc, label0 */
1016 label_ptr = s->code_ptr;
1017 tcg_out_bpcc0(s, COND_E, BPCC_A | BPCC_PT
1018 | (TARGET_LONG_BITS == 64 ? BPCC_XCC : BPCC_ICC), 0);
1019 /* delay slot */
1020 tcg_out_ldst_rr(s, data, addrz, TCG_REG_O1, qemu_ld_opc[memop]);
1021
1022 /* TLB Miss. */
1023
1024 param = TCG_REG_O1;
1025 if (!SPARC64 && TARGET_LONG_BITS == 64) {
1026 /* Skip the high-part; we'll perform the extract in the trampoline. */
1027 param++;
1028 }
1029 tcg_out_mov(s, TCG_TYPE_REG, param++, addr);
1030
1031 /* We use the helpers to extend SB and SW data, leaving the case
1032 of SL needing explicit extending below. */
1033 if ((memop & ~MO_BSWAP) == MO_SL) {
1034 func = qemu_ld_trampoline[memop & ~MO_SIGN];
1035 } else {
1036 func = qemu_ld_trampoline[memop];
1037 }
1038 assert(func != NULL);
1039 tcg_out_call_nodelay(s, func);
1040 /* delay slot */
1041 tcg_out_movi(s, TCG_TYPE_I32, param, memi);
1042
1043 /* Recall that all of the helpers return 64-bit results.
1044 Which complicates things for sparcv8plus. */
1045 if (SPARC64) {
1046 /* We let the helper sign-extend SB and SW, but leave SL for here. */
1047 if (is_64 && (memop & ~MO_BSWAP) == MO_SL) {
1048 tcg_out_arithi(s, data, TCG_REG_O0, 0, SHIFT_SRA);
1049 } else {
1050 tcg_out_mov(s, TCG_TYPE_REG, data, TCG_REG_O0);
1051 }
1052 } else {
1053 if (s_bits == MO_64) {
1054 tcg_out_arithi(s, TCG_REG_O0, TCG_REG_O0, 32, SHIFT_SLLX);
1055 tcg_out_arithi(s, TCG_REG_O1, TCG_REG_O1, 0, SHIFT_SRL);
1056 tcg_out_arith(s, data, TCG_REG_O0, TCG_REG_O1, ARITH_OR);
1057 } else if (is_64) {
1058 /* Re-extend from 32-bit rather than reassembling when we
1059 know the high register must be an extension. */
1060 tcg_out_arithi(s, data, TCG_REG_O1, 0,
1061 memop & MO_SIGN ? SHIFT_SRA : SHIFT_SRL);
1062 } else {
1063 tcg_out_mov(s, TCG_TYPE_I32, data, TCG_REG_O1);
1064 }
1065 }
1066
1067 *label_ptr |= INSN_OFF19(tcg_ptr_byte_diff(s->code_ptr, label_ptr));
1068 #else
1069 if (SPARC64 && TARGET_LONG_BITS == 32) {
1070 tcg_out_arithi(s, TCG_REG_T1, addr, 0, SHIFT_SRL);
1071 addr = TCG_REG_T1;
1072 }
1073 tcg_out_ldst_rr(s, data, addr,
1074 (GUEST_BASE ? TCG_GUEST_BASE_REG : TCG_REG_G0),
1075 qemu_ld_opc[memop]);
1076 #endif /* CONFIG_SOFTMMU */
1077 }
1078
1079 static void tcg_out_qemu_st(TCGContext *s, TCGReg data, TCGReg addr,
1080 TCGMemOp memop, int memi)
1081 {
1082 #ifdef CONFIG_SOFTMMU
1083 TCGMemOp s_bits = memop & MO_SIZE;
1084 TCGReg addrz, param;
1085 tcg_insn_unit *func;
1086 tcg_insn_unit *label_ptr;
1087
1088 addrz = tcg_out_tlb_load(s, addr, memi, s_bits,
1089 offsetof(CPUTLBEntry, addr_write));
1090
1091 /* The fast path is exactly one insn. Thus we can perform the entire
1092 TLB Hit in the (annulled) delay slot of the branch over TLB Miss. */
1093 /* beq,a,pt %[xi]cc, label0 */
1094 label_ptr = s->code_ptr;
1095 tcg_out_bpcc0(s, COND_E, BPCC_A | BPCC_PT
1096 | (TARGET_LONG_BITS == 64 ? BPCC_XCC : BPCC_ICC), 0);
1097 /* delay slot */
1098 tcg_out_ldst_rr(s, data, addrz, TCG_REG_O1, qemu_st_opc[memop]);
1099
1100 /* TLB Miss. */
1101
1102 param = TCG_REG_O1;
1103 if (!SPARC64 && TARGET_LONG_BITS == 64) {
1104 /* Skip the high-part; we'll perform the extract in the trampoline. */
1105 param++;
1106 }
1107 tcg_out_mov(s, TCG_TYPE_REG, param++, addr);
1108 if (!SPARC64 && s_bits == MO_64) {
1109 /* Skip the high-part; we'll perform the extract in the trampoline. */
1110 param++;
1111 }
1112 tcg_out_mov(s, TCG_TYPE_REG, param++, data);
1113
1114 func = qemu_st_trampoline[memop];
1115 assert(func != NULL);
1116 tcg_out_call_nodelay(s, func);
1117 /* delay slot */
1118 tcg_out_movi(s, TCG_TYPE_REG, param, memi);
1119
1120 *label_ptr |= INSN_OFF19(tcg_ptr_byte_diff(s->code_ptr, label_ptr));
1121 #else
1122 if (SPARC64 && TARGET_LONG_BITS == 32) {
1123 tcg_out_arithi(s, TCG_REG_T1, addr, 0, SHIFT_SRL);
1124 addr = TCG_REG_T1;
1125 }
1126 tcg_out_ldst_rr(s, data, addr,
1127 (GUEST_BASE ? TCG_GUEST_BASE_REG : TCG_REG_G0),
1128 qemu_st_opc[memop]);
1129 #endif /* CONFIG_SOFTMMU */
1130 }
1131
1132 static void tcg_out_op(TCGContext *s, TCGOpcode opc,
1133 const TCGArg args[TCG_MAX_OP_ARGS],
1134 const int const_args[TCG_MAX_OP_ARGS])
1135 {
1136 TCGArg a0, a1, a2;
1137 int c, c2;
1138
1139 /* Hoist the loads of the most common arguments. */
1140 a0 = args[0];
1141 a1 = args[1];
1142 a2 = args[2];
1143 c2 = const_args[2];
1144
1145 switch (opc) {
1146 case INDEX_op_exit_tb:
1147 if (check_fit_ptr(a0, 13)) {
1148 tcg_out_arithi(s, TCG_REG_G0, TCG_REG_I7, 8, RETURN);
1149 tcg_out_movi_imm13(s, TCG_REG_O0, a0);
1150 } else {
1151 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_I0, a0 & ~0x3ff);
1152 tcg_out_arithi(s, TCG_REG_G0, TCG_REG_I7, 8, RETURN);
1153 tcg_out_arithi(s, TCG_REG_O0, TCG_REG_O0, a0 & 0x3ff, ARITH_OR);
1154 }
1155 break;
1156 case INDEX_op_goto_tb:
1157 if (s->tb_jmp_offset) {
1158 /* direct jump method */
1159 s->tb_jmp_offset[a0] = tcg_current_code_size(s);
1160 /* Make sure to preserve links during retranslation. */
1161 tcg_out32(s, CALL | (*s->code_ptr & ~INSN_OP(-1)));
1162 } else {
1163 /* indirect jump method */
1164 tcg_out_ld_ptr(s, TCG_REG_T1, (uintptr_t)(s->tb_next + a0));
1165 tcg_out_arithi(s, TCG_REG_G0, TCG_REG_T1, 0, JMPL);
1166 }
1167 tcg_out_nop(s);
1168 s->tb_next_offset[a0] = tcg_current_code_size(s);
1169 break;
1170 case INDEX_op_br:
1171 tcg_out_bpcc(s, COND_A, BPCC_PT, a0);
1172 tcg_out_nop(s);
1173 break;
1174
1175 #define OP_32_64(x) \
1176 glue(glue(case INDEX_op_, x), _i32): \
1177 glue(glue(case INDEX_op_, x), _i64)
1178
1179 OP_32_64(ld8u):
1180 tcg_out_ldst(s, a0, a1, a2, LDUB);
1181 break;
1182 OP_32_64(ld8s):
1183 tcg_out_ldst(s, a0, a1, a2, LDSB);
1184 break;
1185 OP_32_64(ld16u):
1186 tcg_out_ldst(s, a0, a1, a2, LDUH);
1187 break;
1188 OP_32_64(ld16s):
1189 tcg_out_ldst(s, a0, a1, a2, LDSH);
1190 break;
1191 case INDEX_op_ld_i32:
1192 case INDEX_op_ld32u_i64:
1193 tcg_out_ldst(s, a0, a1, a2, LDUW);
1194 break;
1195 OP_32_64(st8):
1196 tcg_out_ldst(s, a0, a1, a2, STB);
1197 break;
1198 OP_32_64(st16):
1199 tcg_out_ldst(s, a0, a1, a2, STH);
1200 break;
1201 case INDEX_op_st_i32:
1202 case INDEX_op_st32_i64:
1203 tcg_out_ldst(s, a0, a1, a2, STW);
1204 break;
1205 OP_32_64(add):
1206 c = ARITH_ADD;
1207 goto gen_arith;
1208 OP_32_64(sub):
1209 c = ARITH_SUB;
1210 goto gen_arith;
1211 OP_32_64(and):
1212 c = ARITH_AND;
1213 goto gen_arith;
1214 OP_32_64(andc):
1215 c = ARITH_ANDN;
1216 goto gen_arith;
1217 OP_32_64(or):
1218 c = ARITH_OR;
1219 goto gen_arith;
1220 OP_32_64(orc):
1221 c = ARITH_ORN;
1222 goto gen_arith;
1223 OP_32_64(xor):
1224 c = ARITH_XOR;
1225 goto gen_arith;
1226 case INDEX_op_shl_i32:
1227 c = SHIFT_SLL;
1228 do_shift32:
1229 /* Limit immediate shift count lest we create an illegal insn. */
1230 tcg_out_arithc(s, a0, a1, a2 & 31, c2, c);
1231 break;
1232 case INDEX_op_shr_i32:
1233 c = SHIFT_SRL;
1234 goto do_shift32;
1235 case INDEX_op_sar_i32:
1236 c = SHIFT_SRA;
1237 goto do_shift32;
1238 case INDEX_op_mul_i32:
1239 c = ARITH_UMUL;
1240 goto gen_arith;
1241
1242 OP_32_64(neg):
1243 c = ARITH_SUB;
1244 goto gen_arith1;
1245 OP_32_64(not):
1246 c = ARITH_ORN;
1247 goto gen_arith1;
1248
1249 case INDEX_op_div_i32:
1250 tcg_out_div32(s, a0, a1, a2, c2, 0);
1251 break;
1252 case INDEX_op_divu_i32:
1253 tcg_out_div32(s, a0, a1, a2, c2, 1);
1254 break;
1255
1256 case INDEX_op_brcond_i32:
1257 tcg_out_brcond_i32(s, a2, a0, a1, const_args[1], args[3]);
1258 break;
1259 case INDEX_op_setcond_i32:
1260 tcg_out_setcond_i32(s, args[3], a0, a1, a2, c2);
1261 break;
1262 case INDEX_op_movcond_i32:
1263 tcg_out_movcond_i32(s, args[5], a0, a1, a2, c2, args[3], const_args[3]);
1264 break;
1265
1266 case INDEX_op_add2_i32:
1267 tcg_out_addsub2(s, a0, a1, a2, args[3], args[4], const_args[4],
1268 args[5], const_args[5], ARITH_ADDCC, ARITH_ADDX);
1269 break;
1270 case INDEX_op_sub2_i32:
1271 tcg_out_addsub2(s, a0, a1, a2, args[3], args[4], const_args[4],
1272 args[5], const_args[5], ARITH_SUBCC, ARITH_SUBX);
1273 break;
1274 case INDEX_op_mulu2_i32:
1275 c = ARITH_UMUL;
1276 goto do_mul2;
1277 case INDEX_op_muls2_i32:
1278 c = ARITH_SMUL;
1279 do_mul2:
1280 /* The 32-bit multiply insns produce a full 64-bit result. If the
1281 destination register can hold it, we can avoid the slower RDY. */
1282 tcg_out_arithc(s, a0, a2, args[3], const_args[3], c);
1283 if (SPARC64 || a0 <= TCG_REG_O7) {
1284 tcg_out_arithi(s, a1, a0, 32, SHIFT_SRLX);
1285 } else {
1286 tcg_out_rdy(s, a1);
1287 }
1288 break;
1289
1290 case INDEX_op_qemu_ld_i32:
1291 tcg_out_qemu_ld(s, a0, a1, a2, args[3], false);
1292 break;
1293 case INDEX_op_qemu_ld_i64:
1294 tcg_out_qemu_ld(s, a0, a1, a2, args[3], true);
1295 break;
1296 case INDEX_op_qemu_st_i32:
1297 case INDEX_op_qemu_st_i64:
1298 tcg_out_qemu_st(s, a0, a1, a2, args[3]);
1299 break;
1300
1301 case INDEX_op_ld32s_i64:
1302 tcg_out_ldst(s, a0, a1, a2, LDSW);
1303 break;
1304 case INDEX_op_ld_i64:
1305 tcg_out_ldst(s, a0, a1, a2, LDX);
1306 break;
1307 case INDEX_op_st_i64:
1308 tcg_out_ldst(s, a0, a1, a2, STX);
1309 break;
1310 case INDEX_op_shl_i64:
1311 c = SHIFT_SLLX;
1312 do_shift64:
1313 /* Limit immediate shift count lest we create an illegal insn. */
1314 tcg_out_arithc(s, a0, a1, a2 & 63, c2, c);
1315 break;
1316 case INDEX_op_shr_i64:
1317 c = SHIFT_SRLX;
1318 goto do_shift64;
1319 case INDEX_op_sar_i64:
1320 c = SHIFT_SRAX;
1321 goto do_shift64;
1322 case INDEX_op_mul_i64:
1323 c = ARITH_MULX;
1324 goto gen_arith;
1325 case INDEX_op_div_i64:
1326 c = ARITH_SDIVX;
1327 goto gen_arith;
1328 case INDEX_op_divu_i64:
1329 c = ARITH_UDIVX;
1330 goto gen_arith;
1331 case INDEX_op_ext32s_i64:
1332 tcg_out_arithi(s, a0, a1, 0, SHIFT_SRA);
1333 break;
1334 case INDEX_op_ext32u_i64:
1335 tcg_out_arithi(s, a0, a1, 0, SHIFT_SRL);
1336 break;
1337 case INDEX_op_trunc_shr_i32:
1338 if (a2 == 0) {
1339 tcg_out_mov(s, TCG_TYPE_I32, a0, a1);
1340 } else {
1341 tcg_out_arithi(s, a0, a1, a2, SHIFT_SRLX);
1342 }
1343 break;
1344
1345 case INDEX_op_brcond_i64:
1346 tcg_out_brcond_i64(s, a2, a0, a1, const_args[1], args[3]);
1347 break;
1348 case INDEX_op_setcond_i64:
1349 tcg_out_setcond_i64(s, args[3], a0, a1, a2, c2);
1350 break;
1351 case INDEX_op_movcond_i64:
1352 tcg_out_movcond_i64(s, args[5], a0, a1, a2, c2, args[3], const_args[3]);
1353 break;
1354
1355 gen_arith:
1356 tcg_out_arithc(s, a0, a1, a2, c2, c);
1357 break;
1358
1359 gen_arith1:
1360 tcg_out_arithc(s, a0, TCG_REG_G0, a1, const_args[1], c);
1361 break;
1362
1363 case INDEX_op_mov_i32: /* Always emitted via tcg_out_mov. */
1364 case INDEX_op_mov_i64:
1365 case INDEX_op_movi_i32: /* Always emitted via tcg_out_movi. */
1366 case INDEX_op_movi_i64:
1367 case INDEX_op_call: /* Always emitted via tcg_out_call. */
1368 default:
1369 tcg_abort();
1370 }
1371 }
1372
1373 static const TCGTargetOpDef sparc_op_defs[] = {
1374 { INDEX_op_exit_tb, { } },
1375 { INDEX_op_goto_tb, { } },
1376 { INDEX_op_br, { } },
1377
1378 { INDEX_op_ld8u_i32, { "r", "r" } },
1379 { INDEX_op_ld8s_i32, { "r", "r" } },
1380 { INDEX_op_ld16u_i32, { "r", "r" } },
1381 { INDEX_op_ld16s_i32, { "r", "r" } },
1382 { INDEX_op_ld_i32, { "r", "r" } },
1383 { INDEX_op_st8_i32, { "rZ", "r" } },
1384 { INDEX_op_st16_i32, { "rZ", "r" } },
1385 { INDEX_op_st_i32, { "rZ", "r" } },
1386
1387 { INDEX_op_add_i32, { "r", "rZ", "rJ" } },
1388 { INDEX_op_mul_i32, { "r", "rZ", "rJ" } },
1389 { INDEX_op_div_i32, { "r", "rZ", "rJ" } },
1390 { INDEX_op_divu_i32, { "r", "rZ", "rJ" } },
1391 { INDEX_op_sub_i32, { "r", "rZ", "rJ" } },
1392 { INDEX_op_and_i32, { "r", "rZ", "rJ" } },
1393 { INDEX_op_andc_i32, { "r", "rZ", "rJ" } },
1394 { INDEX_op_or_i32, { "r", "rZ", "rJ" } },
1395 { INDEX_op_orc_i32, { "r", "rZ", "rJ" } },
1396 { INDEX_op_xor_i32, { "r", "rZ", "rJ" } },
1397
1398 { INDEX_op_shl_i32, { "r", "rZ", "rJ" } },
1399 { INDEX_op_shr_i32, { "r", "rZ", "rJ" } },
1400 { INDEX_op_sar_i32, { "r", "rZ", "rJ" } },
1401
1402 { INDEX_op_neg_i32, { "r", "rJ" } },
1403 { INDEX_op_not_i32, { "r", "rJ" } },
1404
1405 { INDEX_op_brcond_i32, { "rZ", "rJ" } },
1406 { INDEX_op_setcond_i32, { "r", "rZ", "rJ" } },
1407 { INDEX_op_movcond_i32, { "r", "rZ", "rJ", "rI", "0" } },
1408
1409 { INDEX_op_add2_i32, { "r", "r", "rZ", "rZ", "rJ", "rJ" } },
1410 { INDEX_op_sub2_i32, { "r", "r", "rZ", "rZ", "rJ", "rJ" } },
1411 { INDEX_op_mulu2_i32, { "r", "r", "rZ", "rJ" } },
1412 { INDEX_op_muls2_i32, { "r", "r", "rZ", "rJ" } },
1413
1414 { INDEX_op_ld8u_i64, { "R", "r" } },
1415 { INDEX_op_ld8s_i64, { "R", "r" } },
1416 { INDEX_op_ld16u_i64, { "R", "r" } },
1417 { INDEX_op_ld16s_i64, { "R", "r" } },
1418 { INDEX_op_ld32u_i64, { "R", "r" } },
1419 { INDEX_op_ld32s_i64, { "R", "r" } },
1420 { INDEX_op_ld_i64, { "R", "r" } },
1421 { INDEX_op_st8_i64, { "RZ", "r" } },
1422 { INDEX_op_st16_i64, { "RZ", "r" } },
1423 { INDEX_op_st32_i64, { "RZ", "r" } },
1424 { INDEX_op_st_i64, { "RZ", "r" } },
1425
1426 { INDEX_op_add_i64, { "R", "RZ", "RJ" } },
1427 { INDEX_op_mul_i64, { "R", "RZ", "RJ" } },
1428 { INDEX_op_div_i64, { "R", "RZ", "RJ" } },
1429 { INDEX_op_divu_i64, { "R", "RZ", "RJ" } },
1430 { INDEX_op_sub_i64, { "R", "RZ", "RJ" } },
1431 { INDEX_op_and_i64, { "R", "RZ", "RJ" } },
1432 { INDEX_op_andc_i64, { "R", "RZ", "RJ" } },
1433 { INDEX_op_or_i64, { "R", "RZ", "RJ" } },
1434 { INDEX_op_orc_i64, { "R", "RZ", "RJ" } },
1435 { INDEX_op_xor_i64, { "R", "RZ", "RJ" } },
1436
1437 { INDEX_op_shl_i64, { "R", "RZ", "RJ" } },
1438 { INDEX_op_shr_i64, { "R", "RZ", "RJ" } },
1439 { INDEX_op_sar_i64, { "R", "RZ", "RJ" } },
1440
1441 { INDEX_op_neg_i64, { "R", "RJ" } },
1442 { INDEX_op_not_i64, { "R", "RJ" } },
1443
1444 { INDEX_op_ext32s_i64, { "R", "r" } },
1445 { INDEX_op_ext32u_i64, { "R", "r" } },
1446 { INDEX_op_trunc_shr_i32, { "r", "R" } },
1447
1448 { INDEX_op_brcond_i64, { "RZ", "RJ" } },
1449 { INDEX_op_setcond_i64, { "R", "RZ", "RJ" } },
1450 { INDEX_op_movcond_i64, { "R", "RZ", "RJ", "RI", "0" } },
1451
1452 { INDEX_op_qemu_ld_i32, { "r", "A" } },
1453 { INDEX_op_qemu_ld_i64, { "R", "A" } },
1454 { INDEX_op_qemu_st_i32, { "sZ", "A" } },
1455 { INDEX_op_qemu_st_i64, { "SZ", "A" } },
1456
1457 { -1 },
1458 };
1459
1460 static void tcg_target_init(TCGContext *s)
1461 {
1462 tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I32], 0, 0xffffffff);
1463 tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I64], 0, ALL_64);
1464
1465 tcg_regset_set32(tcg_target_call_clobber_regs, 0,
1466 (1 << TCG_REG_G1) |
1467 (1 << TCG_REG_G2) |
1468 (1 << TCG_REG_G3) |
1469 (1 << TCG_REG_G4) |
1470 (1 << TCG_REG_G5) |
1471 (1 << TCG_REG_G6) |
1472 (1 << TCG_REG_G7) |
1473 (1 << TCG_REG_O0) |
1474 (1 << TCG_REG_O1) |
1475 (1 << TCG_REG_O2) |
1476 (1 << TCG_REG_O3) |
1477 (1 << TCG_REG_O4) |
1478 (1 << TCG_REG_O5) |
1479 (1 << TCG_REG_O7));
1480
1481 tcg_regset_clear(s->reserved_regs);
1482 tcg_regset_set_reg(s->reserved_regs, TCG_REG_G0); /* zero */
1483 tcg_regset_set_reg(s->reserved_regs, TCG_REG_G6); /* reserved for os */
1484 tcg_regset_set_reg(s->reserved_regs, TCG_REG_G7); /* thread pointer */
1485 tcg_regset_set_reg(s->reserved_regs, TCG_REG_I6); /* frame pointer */
1486 tcg_regset_set_reg(s->reserved_regs, TCG_REG_I7); /* return address */
1487 tcg_regset_set_reg(s->reserved_regs, TCG_REG_O6); /* stack pointer */
1488 tcg_regset_set_reg(s->reserved_regs, TCG_REG_T1); /* for internal use */
1489 tcg_regset_set_reg(s->reserved_regs, TCG_REG_T2); /* for internal use */
1490
1491 tcg_add_target_add_op_defs(sparc_op_defs);
1492 }
1493
1494 #if SPARC64
1495 # define ELF_HOST_MACHINE EM_SPARCV9
1496 #else
1497 # define ELF_HOST_MACHINE EM_SPARC32PLUS
1498 # define ELF_HOST_FLAGS EF_SPARC_32PLUS
1499 #endif
1500
1501 typedef struct {
1502 DebugFrameHeader h;
1503 uint8_t fde_def_cfa[SPARC64 ? 4 : 2];
1504 uint8_t fde_win_save;
1505 uint8_t fde_ret_save[3];
1506 } DebugFrame;
1507
1508 static const DebugFrame debug_frame = {
1509 .h.cie.len = sizeof(DebugFrameCIE)-4, /* length after .len member */
1510 .h.cie.id = -1,
1511 .h.cie.version = 1,
1512 .h.cie.code_align = 1,
1513 .h.cie.data_align = -sizeof(void *) & 0x7f,
1514 .h.cie.return_column = 15, /* o7 */
1515
1516 /* Total FDE size does not include the "len" member. */
1517 .h.fde.len = sizeof(DebugFrame) - offsetof(DebugFrame, h.fde.cie_offset),
1518
1519 .fde_def_cfa = {
1520 #if SPARC64
1521 12, 30, /* DW_CFA_def_cfa i6, 2047 */
1522 (2047 & 0x7f) | 0x80, (2047 >> 7)
1523 #else
1524 13, 30 /* DW_CFA_def_cfa_register i6 */
1525 #endif
1526 },
1527 .fde_win_save = 0x2d, /* DW_CFA_GNU_window_save */
1528 .fde_ret_save = { 9, 15, 31 }, /* DW_CFA_register o7, i7 */
1529 };
1530
1531 void tcg_register_jit(void *buf, size_t buf_size)
1532 {
1533 tcg_register_jit_int(buf, buf_size, &debug_frame, sizeof(debug_frame));
1534 }
1535
1536 void tb_set_jmp_target1(uintptr_t jmp_addr, uintptr_t addr)
1537 {
1538 uint32_t *ptr = (uint32_t *)jmp_addr;
1539 uintptr_t disp = addr - jmp_addr;
1540
1541 /* We can reach the entire address space for 32-bit. For 64-bit
1542 the code_gen_buffer can't be larger than 2GB. */
1543 assert(disp == (int32_t)disp);
1544
1545 *ptr = CALL | (uint32_t)disp >> 2;
1546 flush_icache_range(jmp_addr, jmp_addr + 4);
1547 }
QEMU modified to work with kvm