Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging
[qemu.git] / tcg / sparc / tcg-target.c.inc
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-pool.c.inc"
26
27 #ifdef CONFIG_DEBUG_TCG
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 #ifndef CONFIG_SOFTMMU
87 # define TCG_GUEST_BASE_REG TCG_REG_I5
88 #endif
89
90 #define TCG_REG_TB  TCG_REG_I1
91 #define USE_REG_TB  (sizeof(void *) > 4)
92
93 static const int tcg_target_reg_alloc_order[] = {
94     TCG_REG_L0,
95     TCG_REG_L1,
96     TCG_REG_L2,
97     TCG_REG_L3,
98     TCG_REG_L4,
99     TCG_REG_L5,
100     TCG_REG_L6,
101     TCG_REG_L7,
102
103     TCG_REG_I0,
104     TCG_REG_I1,
105     TCG_REG_I2,
106     TCG_REG_I3,
107     TCG_REG_I4,
108     TCG_REG_I5,
109
110     TCG_REG_G2,
111     TCG_REG_G3,
112     TCG_REG_G4,
113     TCG_REG_G5,
114
115     TCG_REG_O0,
116     TCG_REG_O1,
117     TCG_REG_O2,
118     TCG_REG_O3,
119     TCG_REG_O4,
120     TCG_REG_O5,
121 };
122
123 static const int tcg_target_call_iarg_regs[6] = {
124     TCG_REG_O0,
125     TCG_REG_O1,
126     TCG_REG_O2,
127     TCG_REG_O3,
128     TCG_REG_O4,
129     TCG_REG_O5,
130 };
131
132 static const int tcg_target_call_oarg_regs[] = {
133     TCG_REG_O0,
134     TCG_REG_O1,
135     TCG_REG_O2,
136     TCG_REG_O3,
137 };
138
139 #define INSN_OP(x)  ((x) << 30)
140 #define INSN_OP2(x) ((x) << 22)
141 #define INSN_OP3(x) ((x) << 19)
142 #define INSN_OPF(x) ((x) << 5)
143 #define INSN_RD(x)  ((x) << 25)
144 #define INSN_RS1(x) ((x) << 14)
145 #define INSN_RS2(x) (x)
146 #define INSN_ASI(x) ((x) << 5)
147
148 #define INSN_IMM10(x) ((1 << 13) | ((x) & 0x3ff))
149 #define INSN_IMM11(x) ((1 << 13) | ((x) & 0x7ff))
150 #define INSN_IMM13(x) ((1 << 13) | ((x) & 0x1fff))
151 #define INSN_OFF16(x) ((((x) >> 2) & 0x3fff) | ((((x) >> 16) & 3) << 20))
152 #define INSN_OFF19(x) (((x) >> 2) & 0x07ffff)
153 #define INSN_COND(x) ((x) << 25)
154
155 #define COND_N     0x0
156 #define COND_E     0x1
157 #define COND_LE    0x2
158 #define COND_L     0x3
159 #define COND_LEU   0x4
160 #define COND_CS    0x5
161 #define COND_NEG   0x6
162 #define COND_VS    0x7
163 #define COND_A     0x8
164 #define COND_NE    0x9
165 #define COND_G     0xa
166 #define COND_GE    0xb
167 #define COND_GU    0xc
168 #define COND_CC    0xd
169 #define COND_POS   0xe
170 #define COND_VC    0xf
171 #define BA         (INSN_OP(0) | INSN_COND(COND_A) | INSN_OP2(0x2))
172
173 #define RCOND_Z    1
174 #define RCOND_LEZ  2
175 #define RCOND_LZ   3
176 #define RCOND_NZ   5
177 #define RCOND_GZ   6
178 #define RCOND_GEZ  7
179
180 #define MOVCC_ICC  (1 << 18)
181 #define MOVCC_XCC  (1 << 18 | 1 << 12)
182
183 #define BPCC_ICC   0
184 #define BPCC_XCC   (2 << 20)
185 #define BPCC_PT    (1 << 19)
186 #define BPCC_PN    0
187 #define BPCC_A     (1 << 29)
188
189 #define BPR_PT     BPCC_PT
190
191 #define ARITH_ADD  (INSN_OP(2) | INSN_OP3(0x00))
192 #define ARITH_ADDCC (INSN_OP(2) | INSN_OP3(0x10))
193 #define ARITH_AND  (INSN_OP(2) | INSN_OP3(0x01))
194 #define ARITH_ANDN (INSN_OP(2) | INSN_OP3(0x05))
195 #define ARITH_OR   (INSN_OP(2) | INSN_OP3(0x02))
196 #define ARITH_ORCC (INSN_OP(2) | INSN_OP3(0x12))
197 #define ARITH_ORN  (INSN_OP(2) | INSN_OP3(0x06))
198 #define ARITH_XOR  (INSN_OP(2) | INSN_OP3(0x03))
199 #define ARITH_SUB  (INSN_OP(2) | INSN_OP3(0x04))
200 #define ARITH_SUBCC (INSN_OP(2) | INSN_OP3(0x14))
201 #define ARITH_ADDC (INSN_OP(2) | INSN_OP3(0x08))
202 #define ARITH_SUBC (INSN_OP(2) | INSN_OP3(0x0c))
203 #define ARITH_UMUL (INSN_OP(2) | INSN_OP3(0x0a))
204 #define ARITH_SMUL (INSN_OP(2) | INSN_OP3(0x0b))
205 #define ARITH_UDIV (INSN_OP(2) | INSN_OP3(0x0e))
206 #define ARITH_SDIV (INSN_OP(2) | INSN_OP3(0x0f))
207 #define ARITH_MULX (INSN_OP(2) | INSN_OP3(0x09))
208 #define ARITH_UDIVX (INSN_OP(2) | INSN_OP3(0x0d))
209 #define ARITH_SDIVX (INSN_OP(2) | INSN_OP3(0x2d))
210 #define ARITH_MOVCC (INSN_OP(2) | INSN_OP3(0x2c))
211 #define ARITH_MOVR (INSN_OP(2) | INSN_OP3(0x2f))
212
213 #define ARITH_ADDXC (INSN_OP(2) | INSN_OP3(0x36) | INSN_OPF(0x11))
214 #define ARITH_UMULXHI (INSN_OP(2) | INSN_OP3(0x36) | INSN_OPF(0x16))
215
216 #define SHIFT_SLL  (INSN_OP(2) | INSN_OP3(0x25))
217 #define SHIFT_SRL  (INSN_OP(2) | INSN_OP3(0x26))
218 #define SHIFT_SRA  (INSN_OP(2) | INSN_OP3(0x27))
219
220 #define SHIFT_SLLX (INSN_OP(2) | INSN_OP3(0x25) | (1 << 12))
221 #define SHIFT_SRLX (INSN_OP(2) | INSN_OP3(0x26) | (1 << 12))
222 #define SHIFT_SRAX (INSN_OP(2) | INSN_OP3(0x27) | (1 << 12))
223
224 #define RDY        (INSN_OP(2) | INSN_OP3(0x28) | INSN_RS1(0))
225 #define WRY        (INSN_OP(2) | INSN_OP3(0x30) | INSN_RD(0))
226 #define JMPL       (INSN_OP(2) | INSN_OP3(0x38))
227 #define RETURN     (INSN_OP(2) | INSN_OP3(0x39))
228 #define SAVE       (INSN_OP(2) | INSN_OP3(0x3c))
229 #define RESTORE    (INSN_OP(2) | INSN_OP3(0x3d))
230 #define SETHI      (INSN_OP(0) | INSN_OP2(0x4))
231 #define CALL       INSN_OP(1)
232 #define LDUB       (INSN_OP(3) | INSN_OP3(0x01))
233 #define LDSB       (INSN_OP(3) | INSN_OP3(0x09))
234 #define LDUH       (INSN_OP(3) | INSN_OP3(0x02))
235 #define LDSH       (INSN_OP(3) | INSN_OP3(0x0a))
236 #define LDUW       (INSN_OP(3) | INSN_OP3(0x00))
237 #define LDSW       (INSN_OP(3) | INSN_OP3(0x08))
238 #define LDX        (INSN_OP(3) | INSN_OP3(0x0b))
239 #define STB        (INSN_OP(3) | INSN_OP3(0x05))
240 #define STH        (INSN_OP(3) | INSN_OP3(0x06))
241 #define STW        (INSN_OP(3) | INSN_OP3(0x04))
242 #define STX        (INSN_OP(3) | INSN_OP3(0x0e))
243 #define LDUBA      (INSN_OP(3) | INSN_OP3(0x11))
244 #define LDSBA      (INSN_OP(3) | INSN_OP3(0x19))
245 #define LDUHA      (INSN_OP(3) | INSN_OP3(0x12))
246 #define LDSHA      (INSN_OP(3) | INSN_OP3(0x1a))
247 #define LDUWA      (INSN_OP(3) | INSN_OP3(0x10))
248 #define LDSWA      (INSN_OP(3) | INSN_OP3(0x18))
249 #define LDXA       (INSN_OP(3) | INSN_OP3(0x1b))
250 #define STBA       (INSN_OP(3) | INSN_OP3(0x15))
251 #define STHA       (INSN_OP(3) | INSN_OP3(0x16))
252 #define STWA       (INSN_OP(3) | INSN_OP3(0x14))
253 #define STXA       (INSN_OP(3) | INSN_OP3(0x1e))
254
255 #define MEMBAR     (INSN_OP(2) | INSN_OP3(0x28) | INSN_RS1(15) | (1 << 13))
256
257 #define NOP        (SETHI | INSN_RD(TCG_REG_G0) | 0)
258
259 #ifndef ASI_PRIMARY_LITTLE
260 #define ASI_PRIMARY_LITTLE 0x88
261 #endif
262
263 #define LDUH_LE    (LDUHA | INSN_ASI(ASI_PRIMARY_LITTLE))
264 #define LDSH_LE    (LDSHA | INSN_ASI(ASI_PRIMARY_LITTLE))
265 #define LDUW_LE    (LDUWA | INSN_ASI(ASI_PRIMARY_LITTLE))
266 #define LDSW_LE    (LDSWA | INSN_ASI(ASI_PRIMARY_LITTLE))
267 #define LDX_LE     (LDXA  | INSN_ASI(ASI_PRIMARY_LITTLE))
268
269 #define STH_LE     (STHA  | INSN_ASI(ASI_PRIMARY_LITTLE))
270 #define STW_LE     (STWA  | INSN_ASI(ASI_PRIMARY_LITTLE))
271 #define STX_LE     (STXA  | INSN_ASI(ASI_PRIMARY_LITTLE))
272
273 #ifndef use_vis3_instructions
274 bool use_vis3_instructions;
275 #endif
276
277 static inline int check_fit_i64(int64_t val, unsigned int bits)
278 {
279     return val == sextract64(val, 0, bits);
280 }
281
282 static inline int check_fit_i32(int32_t val, unsigned int bits)
283 {
284     return val == sextract32(val, 0, bits);
285 }
286
287 #define check_fit_tl    check_fit_i64
288 #if SPARC64
289 # define check_fit_ptr  check_fit_i64
290 #else
291 # define check_fit_ptr  check_fit_i32
292 #endif
293
294 static bool patch_reloc(tcg_insn_unit *code_ptr, int type,
295                         intptr_t value, intptr_t addend)
296 {
297     uint32_t insn = *code_ptr;
298     intptr_t pcrel;
299
300     value += addend;
301     pcrel = tcg_ptr_byte_diff((tcg_insn_unit *)value, code_ptr);
302
303     switch (type) {
304     case R_SPARC_WDISP16:
305         assert(check_fit_ptr(pcrel >> 2, 16));
306         insn &= ~INSN_OFF16(-1);
307         insn |= INSN_OFF16(pcrel);
308         break;
309     case R_SPARC_WDISP19:
310         assert(check_fit_ptr(pcrel >> 2, 19));
311         insn &= ~INSN_OFF19(-1);
312         insn |= INSN_OFF19(pcrel);
313         break;
314     default:
315         g_assert_not_reached();
316     }
317
318     *code_ptr = insn;
319     return true;
320 }
321
322 /* parse target specific constraints */
323 static const char *target_parse_constraint(TCGArgConstraint *ct,
324                                            const char *ct_str, TCGType type)
325 {
326     switch (*ct_str++) {
327     case 'r':
328         ct->ct |= TCG_CT_REG;
329         ct->u.regs = 0xffffffff;
330         break;
331     case 'R':
332         ct->ct |= TCG_CT_REG;
333         ct->u.regs = ALL_64;
334         break;
335     case 'A': /* qemu_ld/st address constraint */
336         ct->ct |= TCG_CT_REG;
337         ct->u.regs = TARGET_LONG_BITS == 64 ? ALL_64 : 0xffffffff;
338     reserve_helpers:
339         tcg_regset_reset_reg(ct->u.regs, TCG_REG_O0);
340         tcg_regset_reset_reg(ct->u.regs, TCG_REG_O1);
341         tcg_regset_reset_reg(ct->u.regs, TCG_REG_O2);
342         break;
343     case 's': /* qemu_st data 32-bit constraint */
344         ct->ct |= TCG_CT_REG;
345         ct->u.regs = 0xffffffff;
346         goto reserve_helpers;
347     case 'S': /* qemu_st data 64-bit constraint */
348         ct->ct |= TCG_CT_REG;
349         ct->u.regs = ALL_64;
350         goto reserve_helpers;
351     case 'I':
352         ct->ct |= TCG_CT_CONST_S11;
353         break;
354     case 'J':
355         ct->ct |= TCG_CT_CONST_S13;
356         break;
357     case 'Z':
358         ct->ct |= TCG_CT_CONST_ZERO;
359         break;
360     default:
361         return NULL;
362     }
363     return ct_str;
364 }
365
366 /* test if a constant matches the constraint */
367 static inline int tcg_target_const_match(tcg_target_long val, TCGType type,
368                                          const TCGArgConstraint *arg_ct)
369 {
370     int ct = arg_ct->ct;
371
372     if (ct & TCG_CT_CONST) {
373         return 1;
374     }
375
376     if (type == TCG_TYPE_I32) {
377         val = (int32_t)val;
378     }
379
380     if ((ct & TCG_CT_CONST_ZERO) && val == 0) {
381         return 1;
382     } else if ((ct & TCG_CT_CONST_S11) && check_fit_tl(val, 11)) {
383         return 1;
384     } else if ((ct & TCG_CT_CONST_S13) && check_fit_tl(val, 13)) {
385         return 1;
386     } else {
387         return 0;
388     }
389 }
390
391 static inline void tcg_out_arith(TCGContext *s, TCGReg rd, TCGReg rs1,
392                                  TCGReg rs2, int op)
393 {
394     tcg_out32(s, op | INSN_RD(rd) | INSN_RS1(rs1) | INSN_RS2(rs2));
395 }
396
397 static inline void tcg_out_arithi(TCGContext *s, TCGReg rd, TCGReg rs1,
398                                   int32_t offset, int op)
399 {
400     tcg_out32(s, op | INSN_RD(rd) | INSN_RS1(rs1) | INSN_IMM13(offset));
401 }
402
403 static void tcg_out_arithc(TCGContext *s, TCGReg rd, TCGReg rs1,
404                            int32_t val2, int val2const, int op)
405 {
406     tcg_out32(s, op | INSN_RD(rd) | INSN_RS1(rs1)
407               | (val2const ? INSN_IMM13(val2) : INSN_RS2(val2)));
408 }
409
410 static inline bool tcg_out_mov(TCGContext *s, TCGType type,
411                                TCGReg ret, TCGReg arg)
412 {
413     if (ret != arg) {
414         tcg_out_arith(s, ret, arg, TCG_REG_G0, ARITH_OR);
415     }
416     return true;
417 }
418
419 static inline void tcg_out_sethi(TCGContext *s, TCGReg ret, uint32_t arg)
420 {
421     tcg_out32(s, SETHI | INSN_RD(ret) | ((arg & 0xfffffc00) >> 10));
422 }
423
424 static inline void tcg_out_movi_imm13(TCGContext *s, TCGReg ret, int32_t arg)
425 {
426     tcg_out_arithi(s, ret, TCG_REG_G0, arg, ARITH_OR);
427 }
428
429 static void tcg_out_movi_int(TCGContext *s, TCGType type, TCGReg ret,
430                              tcg_target_long arg, bool in_prologue)
431 {
432     tcg_target_long hi, lo = (int32_t)arg;
433     tcg_target_long test, lsb;
434
435     /* Make sure we test 32-bit constants for imm13 properly.  */
436     if (type == TCG_TYPE_I32) {
437         arg = lo;
438     }
439
440     /* A 13-bit constant sign-extended to 64-bits.  */
441     if (check_fit_tl(arg, 13)) {
442         tcg_out_movi_imm13(s, ret, arg);
443         return;
444     }
445
446     /* A 13-bit constant relative to the TB.  */
447     if (!in_prologue && USE_REG_TB) {
448         test = arg - (uintptr_t)s->code_gen_ptr;
449         if (check_fit_ptr(test, 13)) {
450             tcg_out_arithi(s, ret, TCG_REG_TB, test, ARITH_ADD);
451             return;
452         }
453     }
454
455     /* A 32-bit constant, or 32-bit zero-extended to 64-bits.  */
456     if (type == TCG_TYPE_I32 || arg == (uint32_t)arg) {
457         tcg_out_sethi(s, ret, arg);
458         if (arg & 0x3ff) {
459             tcg_out_arithi(s, ret, ret, arg & 0x3ff, ARITH_OR);
460         }
461         return;
462     }
463
464     /* A 32-bit constant sign-extended to 64-bits.  */
465     if (arg == lo) {
466         tcg_out_sethi(s, ret, ~arg);
467         tcg_out_arithi(s, ret, ret, (arg & 0x3ff) | -0x400, ARITH_XOR);
468         return;
469     }
470
471     /* A 21-bit constant, shifted.  */
472     lsb = ctz64(arg);
473     test = (tcg_target_long)arg >> lsb;
474     if (check_fit_tl(test, 13)) {
475         tcg_out_movi_imm13(s, ret, test);
476         tcg_out_arithi(s, ret, ret, lsb, SHIFT_SLLX);
477         return;
478     } else if (lsb > 10 && test == extract64(test, 0, 21)) {
479         tcg_out_sethi(s, ret, test << 10);
480         tcg_out_arithi(s, ret, ret, lsb - 10, SHIFT_SLLX);
481         return;
482     }
483
484     /* A 64-bit constant decomposed into 2 32-bit pieces.  */
485     if (check_fit_i32(lo, 13)) {
486         hi = (arg - lo) >> 32;
487         tcg_out_movi(s, TCG_TYPE_I32, ret, hi);
488         tcg_out_arithi(s, ret, ret, 32, SHIFT_SLLX);
489         tcg_out_arithi(s, ret, ret, lo, ARITH_ADD);
490     } else {
491         hi = arg >> 32;
492         tcg_out_movi(s, TCG_TYPE_I32, ret, hi);
493         tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_T2, lo);
494         tcg_out_arithi(s, ret, ret, 32, SHIFT_SLLX);
495         tcg_out_arith(s, ret, ret, TCG_REG_T2, ARITH_OR);
496     }
497 }
498
499 static inline void tcg_out_movi(TCGContext *s, TCGType type,
500                                 TCGReg ret, tcg_target_long arg)
501 {
502     tcg_out_movi_int(s, type, ret, arg, false);
503 }
504
505 static inline void tcg_out_ldst_rr(TCGContext *s, TCGReg data, TCGReg a1,
506                                    TCGReg a2, int op)
507 {
508     tcg_out32(s, op | INSN_RD(data) | INSN_RS1(a1) | INSN_RS2(a2));
509 }
510
511 static void tcg_out_ldst(TCGContext *s, TCGReg ret, TCGReg addr,
512                          intptr_t offset, int op)
513 {
514     if (check_fit_ptr(offset, 13)) {
515         tcg_out32(s, op | INSN_RD(ret) | INSN_RS1(addr) |
516                   INSN_IMM13(offset));
517     } else {
518         tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_T1, offset);
519         tcg_out_ldst_rr(s, ret, addr, TCG_REG_T1, op);
520     }
521 }
522
523 static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret,
524                               TCGReg arg1, intptr_t arg2)
525 {
526     tcg_out_ldst(s, ret, arg1, arg2, (type == TCG_TYPE_I32 ? LDUW : LDX));
527 }
528
529 static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
530                               TCGReg arg1, intptr_t arg2)
531 {
532     tcg_out_ldst(s, arg, arg1, arg2, (type == TCG_TYPE_I32 ? STW : STX));
533 }
534
535 static inline bool tcg_out_sti(TCGContext *s, TCGType type, TCGArg val,
536                                TCGReg base, intptr_t ofs)
537 {
538     if (val == 0) {
539         tcg_out_st(s, type, TCG_REG_G0, base, ofs);
540         return true;
541     }
542     return false;
543 }
544
545 static void tcg_out_ld_ptr(TCGContext *s, TCGReg ret, uintptr_t arg)
546 {
547     intptr_t diff = arg - (uintptr_t)s->code_gen_ptr;
548     if (USE_REG_TB && check_fit_ptr(diff, 13)) {
549         tcg_out_ld(s, TCG_TYPE_PTR, ret, TCG_REG_TB, diff);
550         return;
551     }
552     tcg_out_movi(s, TCG_TYPE_PTR, ret, arg & ~0x3ff);
553     tcg_out_ld(s, TCG_TYPE_PTR, ret, ret, arg & 0x3ff);
554 }
555
556 static inline void tcg_out_sety(TCGContext *s, TCGReg rs)
557 {
558     tcg_out32(s, WRY | INSN_RS1(TCG_REG_G0) | INSN_RS2(rs));
559 }
560
561 static inline void tcg_out_rdy(TCGContext *s, TCGReg rd)
562 {
563     tcg_out32(s, RDY | INSN_RD(rd));
564 }
565
566 static void tcg_out_div32(TCGContext *s, TCGReg rd, TCGReg rs1,
567                           int32_t val2, int val2const, int uns)
568 {
569     /* Load Y with the sign/zero extension of RS1 to 64-bits.  */
570     if (uns) {
571         tcg_out_sety(s, TCG_REG_G0);
572     } else {
573         tcg_out_arithi(s, TCG_REG_T1, rs1, 31, SHIFT_SRA);
574         tcg_out_sety(s, TCG_REG_T1);
575     }
576
577     tcg_out_arithc(s, rd, rs1, val2, val2const,
578                    uns ? ARITH_UDIV : ARITH_SDIV);
579 }
580
581 static inline void tcg_out_nop(TCGContext *s)
582 {
583     tcg_out32(s, NOP);
584 }
585
586 static const uint8_t tcg_cond_to_bcond[] = {
587     [TCG_COND_EQ] = COND_E,
588     [TCG_COND_NE] = COND_NE,
589     [TCG_COND_LT] = COND_L,
590     [TCG_COND_GE] = COND_GE,
591     [TCG_COND_LE] = COND_LE,
592     [TCG_COND_GT] = COND_G,
593     [TCG_COND_LTU] = COND_CS,
594     [TCG_COND_GEU] = COND_CC,
595     [TCG_COND_LEU] = COND_LEU,
596     [TCG_COND_GTU] = COND_GU,
597 };
598
599 static const uint8_t tcg_cond_to_rcond[] = {
600     [TCG_COND_EQ] = RCOND_Z,
601     [TCG_COND_NE] = RCOND_NZ,
602     [TCG_COND_LT] = RCOND_LZ,
603     [TCG_COND_GT] = RCOND_GZ,
604     [TCG_COND_LE] = RCOND_LEZ,
605     [TCG_COND_GE] = RCOND_GEZ
606 };
607
608 static void tcg_out_bpcc0(TCGContext *s, int scond, int flags, int off19)
609 {
610     tcg_out32(s, INSN_OP(0) | INSN_OP2(1) | INSN_COND(scond) | flags | off19);
611 }
612
613 static void tcg_out_bpcc(TCGContext *s, int scond, int flags, TCGLabel *l)
614 {
615     int off19 = 0;
616
617     if (l->has_value) {
618         off19 = INSN_OFF19(tcg_pcrel_diff(s, l->u.value_ptr));
619     } else {
620         tcg_out_reloc(s, s->code_ptr, R_SPARC_WDISP19, l, 0);
621     }
622     tcg_out_bpcc0(s, scond, flags, off19);
623 }
624
625 static void tcg_out_cmp(TCGContext *s, TCGReg c1, int32_t c2, int c2const)
626 {
627     tcg_out_arithc(s, TCG_REG_G0, c1, c2, c2const, ARITH_SUBCC);
628 }
629
630 static void tcg_out_brcond_i32(TCGContext *s, TCGCond cond, TCGReg arg1,
631                                int32_t arg2, int const_arg2, TCGLabel *l)
632 {
633     tcg_out_cmp(s, arg1, arg2, const_arg2);
634     tcg_out_bpcc(s, tcg_cond_to_bcond[cond], BPCC_ICC | BPCC_PT, l);
635     tcg_out_nop(s);
636 }
637
638 static void tcg_out_movcc(TCGContext *s, TCGCond cond, int cc, TCGReg ret,
639                           int32_t v1, int v1const)
640 {
641     tcg_out32(s, ARITH_MOVCC | cc | INSN_RD(ret)
642               | INSN_RS1(tcg_cond_to_bcond[cond])
643               | (v1const ? INSN_IMM11(v1) : INSN_RS2(v1)));
644 }
645
646 static void tcg_out_movcond_i32(TCGContext *s, TCGCond cond, TCGReg ret,
647                                 TCGReg c1, int32_t c2, int c2const,
648                                 int32_t v1, int v1const)
649 {
650     tcg_out_cmp(s, c1, c2, c2const);
651     tcg_out_movcc(s, cond, MOVCC_ICC, ret, v1, v1const);
652 }
653
654 static void tcg_out_brcond_i64(TCGContext *s, TCGCond cond, TCGReg arg1,
655                                int32_t arg2, int const_arg2, TCGLabel *l)
656 {
657     /* For 64-bit signed comparisons vs zero, we can avoid the compare.  */
658     if (arg2 == 0 && !is_unsigned_cond(cond)) {
659         int off16 = 0;
660
661         if (l->has_value) {
662             off16 = INSN_OFF16(tcg_pcrel_diff(s, l->u.value_ptr));
663         } else {
664             tcg_out_reloc(s, s->code_ptr, R_SPARC_WDISP16, l, 0);
665         }
666         tcg_out32(s, INSN_OP(0) | INSN_OP2(3) | BPR_PT | INSN_RS1(arg1)
667                   | INSN_COND(tcg_cond_to_rcond[cond]) | off16);
668     } else {
669         tcg_out_cmp(s, arg1, arg2, const_arg2);
670         tcg_out_bpcc(s, tcg_cond_to_bcond[cond], BPCC_XCC | BPCC_PT, l);
671     }
672     tcg_out_nop(s);
673 }
674
675 static void tcg_out_movr(TCGContext *s, TCGCond cond, TCGReg ret, TCGReg c1,
676                          int32_t v1, int v1const)
677 {
678     tcg_out32(s, ARITH_MOVR | INSN_RD(ret) | INSN_RS1(c1)
679               | (tcg_cond_to_rcond[cond] << 10)
680               | (v1const ? INSN_IMM10(v1) : INSN_RS2(v1)));
681 }
682
683 static void tcg_out_movcond_i64(TCGContext *s, TCGCond cond, TCGReg ret,
684                                 TCGReg c1, int32_t c2, int c2const,
685                                 int32_t v1, int v1const)
686 {
687     /* For 64-bit signed comparisons vs zero, we can avoid the compare.
688        Note that the immediate range is one bit smaller, so we must check
689        for that as well.  */
690     if (c2 == 0 && !is_unsigned_cond(cond)
691         && (!v1const || check_fit_i32(v1, 10))) {
692         tcg_out_movr(s, cond, ret, c1, v1, v1const);
693     } else {
694         tcg_out_cmp(s, c1, c2, c2const);
695         tcg_out_movcc(s, cond, MOVCC_XCC, ret, v1, v1const);
696     }
697 }
698
699 static void tcg_out_setcond_i32(TCGContext *s, TCGCond cond, TCGReg ret,
700                                 TCGReg c1, int32_t c2, int c2const)
701 {
702     /* For 32-bit comparisons, we can play games with ADDC/SUBC.  */
703     switch (cond) {
704     case TCG_COND_LTU:
705     case TCG_COND_GEU:
706         /* The result of the comparison is in the carry bit.  */
707         break;
708
709     case TCG_COND_EQ:
710     case TCG_COND_NE:
711         /* For equality, we can transform to inequality vs zero.  */
712         if (c2 != 0) {
713             tcg_out_arithc(s, TCG_REG_T1, c1, c2, c2const, ARITH_XOR);
714             c2 = TCG_REG_T1;
715         } else {
716             c2 = c1;
717         }
718         c1 = TCG_REG_G0, c2const = 0;
719         cond = (cond == TCG_COND_EQ ? TCG_COND_GEU : TCG_COND_LTU);
720         break;
721
722     case TCG_COND_GTU:
723     case TCG_COND_LEU:
724         /* If we don't need to load a constant into a register, we can
725            swap the operands on GTU/LEU.  There's no benefit to loading
726            the constant into a temporary register.  */
727         if (!c2const || c2 == 0) {
728             TCGReg t = c1;
729             c1 = c2;
730             c2 = t;
731             c2const = 0;
732             cond = tcg_swap_cond(cond);
733             break;
734         }
735         /* FALLTHRU */
736
737     default:
738         tcg_out_cmp(s, c1, c2, c2const);
739         tcg_out_movi_imm13(s, ret, 0);
740         tcg_out_movcc(s, cond, MOVCC_ICC, ret, 1, 1);
741         return;
742     }
743
744     tcg_out_cmp(s, c1, c2, c2const);
745     if (cond == TCG_COND_LTU) {
746         tcg_out_arithi(s, ret, TCG_REG_G0, 0, ARITH_ADDC);
747     } else {
748         tcg_out_arithi(s, ret, TCG_REG_G0, -1, ARITH_SUBC);
749     }
750 }
751
752 static void tcg_out_setcond_i64(TCGContext *s, TCGCond cond, TCGReg ret,
753                                 TCGReg c1, int32_t c2, int c2const)
754 {
755     if (use_vis3_instructions) {
756         switch (cond) {
757         case TCG_COND_NE:
758             if (c2 != 0) {
759                 break;
760             }
761             c2 = c1, c2const = 0, c1 = TCG_REG_G0;
762             /* FALLTHRU */
763         case TCG_COND_LTU:
764             tcg_out_cmp(s, c1, c2, c2const);
765             tcg_out_arith(s, ret, TCG_REG_G0, TCG_REG_G0, ARITH_ADDXC);
766             return;
767         default:
768             break;
769         }
770     }
771
772     /* For 64-bit signed comparisons vs zero, we can avoid the compare
773        if the input does not overlap the output.  */
774     if (c2 == 0 && !is_unsigned_cond(cond) && c1 != ret) {
775         tcg_out_movi_imm13(s, ret, 0);
776         tcg_out_movr(s, cond, ret, c1, 1, 1);
777     } else {
778         tcg_out_cmp(s, c1, c2, c2const);
779         tcg_out_movi_imm13(s, ret, 0);
780         tcg_out_movcc(s, cond, MOVCC_XCC, ret, 1, 1);
781     }
782 }
783
784 static void tcg_out_addsub2_i32(TCGContext *s, TCGReg rl, TCGReg rh,
785                                 TCGReg al, TCGReg ah, int32_t bl, int blconst,
786                                 int32_t bh, int bhconst, int opl, int oph)
787 {
788     TCGReg tmp = TCG_REG_T1;
789
790     /* Note that the low parts are fully consumed before tmp is set.  */
791     if (rl != ah && (bhconst || rl != bh)) {
792         tmp = rl;
793     }
794
795     tcg_out_arithc(s, tmp, al, bl, blconst, opl);
796     tcg_out_arithc(s, rh, ah, bh, bhconst, oph);
797     tcg_out_mov(s, TCG_TYPE_I32, rl, tmp);
798 }
799
800 static void tcg_out_addsub2_i64(TCGContext *s, TCGReg rl, TCGReg rh,
801                                 TCGReg al, TCGReg ah, int32_t bl, int blconst,
802                                 int32_t bh, int bhconst, bool is_sub)
803 {
804     TCGReg tmp = TCG_REG_T1;
805
806     /* Note that the low parts are fully consumed before tmp is set.  */
807     if (rl != ah && (bhconst || rl != bh)) {
808         tmp = rl;
809     }
810
811     tcg_out_arithc(s, tmp, al, bl, blconst, is_sub ? ARITH_SUBCC : ARITH_ADDCC);
812
813     if (use_vis3_instructions && !is_sub) {
814         /* Note that ADDXC doesn't accept immediates.  */
815         if (bhconst && bh != 0) {
816            tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_T2, bh);
817            bh = TCG_REG_T2;
818         }
819         tcg_out_arith(s, rh, ah, bh, ARITH_ADDXC);
820     } else if (bh == TCG_REG_G0) {
821         /* If we have a zero, we can perform the operation in two insns,
822            with the arithmetic first, and a conditional move into place.  */
823         if (rh == ah) {
824             tcg_out_arithi(s, TCG_REG_T2, ah, 1,
825                            is_sub ? ARITH_SUB : ARITH_ADD);
826             tcg_out_movcc(s, TCG_COND_LTU, MOVCC_XCC, rh, TCG_REG_T2, 0);
827         } else {
828             tcg_out_arithi(s, rh, ah, 1, is_sub ? ARITH_SUB : ARITH_ADD);
829             tcg_out_movcc(s, TCG_COND_GEU, MOVCC_XCC, rh, ah, 0);
830         }
831     } else {
832         /* Otherwise adjust BH as if there is carry into T2 ... */
833         if (bhconst) {
834             tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_T2, bh + (is_sub ? -1 : 1));
835         } else {
836             tcg_out_arithi(s, TCG_REG_T2, bh, 1,
837                            is_sub ? ARITH_SUB : ARITH_ADD);
838         }
839         /* ... smoosh T2 back to original BH if carry is clear ... */
840         tcg_out_movcc(s, TCG_COND_GEU, MOVCC_XCC, TCG_REG_T2, bh, bhconst);
841         /* ... and finally perform the arithmetic with the new operand.  */
842         tcg_out_arith(s, rh, ah, TCG_REG_T2, is_sub ? ARITH_SUB : ARITH_ADD);
843     }
844
845     tcg_out_mov(s, TCG_TYPE_I64, rl, tmp);
846 }
847
848 static void tcg_out_call_nodelay(TCGContext *s, tcg_insn_unit *dest,
849                                  bool in_prologue)
850 {
851     ptrdiff_t disp = tcg_pcrel_diff(s, dest);
852
853     if (disp == (int32_t)disp) {
854         tcg_out32(s, CALL | (uint32_t)disp >> 2);
855     } else {
856         uintptr_t desti = (uintptr_t)dest;
857         tcg_out_movi_int(s, TCG_TYPE_PTR, TCG_REG_T1,
858                          desti & ~0xfff, in_prologue);
859         tcg_out_arithi(s, TCG_REG_O7, TCG_REG_T1, desti & 0xfff, JMPL);
860     }
861 }
862
863 static void tcg_out_call(TCGContext *s, tcg_insn_unit *dest)
864 {
865     tcg_out_call_nodelay(s, dest, false);
866     tcg_out_nop(s);
867 }
868
869 static void tcg_out_mb(TCGContext *s, TCGArg a0)
870 {
871     /* Note that the TCG memory order constants mirror the Sparc MEMBAR.  */
872     tcg_out32(s, MEMBAR | (a0 & TCG_MO_ALL));
873 }
874
875 #ifdef CONFIG_SOFTMMU
876 static tcg_insn_unit *qemu_ld_trampoline[16];
877 static tcg_insn_unit *qemu_st_trampoline[16];
878
879 static void emit_extend(TCGContext *s, TCGReg r, int op)
880 {
881     /* Emit zero extend of 8, 16 or 32 bit data as
882      * required by the MO_* value op; do nothing for 64 bit.
883      */
884     switch (op & MO_SIZE) {
885     case MO_8:
886         tcg_out_arithi(s, r, r, 0xff, ARITH_AND);
887         break;
888     case MO_16:
889         tcg_out_arithi(s, r, r, 16, SHIFT_SLL);
890         tcg_out_arithi(s, r, r, 16, SHIFT_SRL);
891         break;
892     case MO_32:
893         if (SPARC64) {
894             tcg_out_arith(s, r, r, 0, SHIFT_SRL);
895         }
896         break;
897     case MO_64:
898         break;
899     }
900 }
901
902 static void build_trampolines(TCGContext *s)
903 {
904     static void * const qemu_ld_helpers[16] = {
905         [MO_UB]   = helper_ret_ldub_mmu,
906         [MO_SB]   = helper_ret_ldsb_mmu,
907         [MO_LEUW] = helper_le_lduw_mmu,
908         [MO_LESW] = helper_le_ldsw_mmu,
909         [MO_LEUL] = helper_le_ldul_mmu,
910         [MO_LEQ]  = helper_le_ldq_mmu,
911         [MO_BEUW] = helper_be_lduw_mmu,
912         [MO_BESW] = helper_be_ldsw_mmu,
913         [MO_BEUL] = helper_be_ldul_mmu,
914         [MO_BEQ]  = helper_be_ldq_mmu,
915     };
916     static void * const qemu_st_helpers[16] = {
917         [MO_UB]   = helper_ret_stb_mmu,
918         [MO_LEUW] = helper_le_stw_mmu,
919         [MO_LEUL] = helper_le_stl_mmu,
920         [MO_LEQ]  = helper_le_stq_mmu,
921         [MO_BEUW] = helper_be_stw_mmu,
922         [MO_BEUL] = helper_be_stl_mmu,
923         [MO_BEQ]  = helper_be_stq_mmu,
924     };
925
926     int i;
927     TCGReg ra;
928
929     for (i = 0; i < 16; ++i) {
930         if (qemu_ld_helpers[i] == NULL) {
931             continue;
932         }
933
934         /* May as well align the trampoline.  */
935         while ((uintptr_t)s->code_ptr & 15) {
936             tcg_out_nop(s);
937         }
938         qemu_ld_trampoline[i] = s->code_ptr;
939
940         if (SPARC64 || TARGET_LONG_BITS == 32) {
941             ra = TCG_REG_O3;
942         } else {
943             /* Install the high part of the address.  */
944             tcg_out_arithi(s, TCG_REG_O1, TCG_REG_O2, 32, SHIFT_SRLX);
945             ra = TCG_REG_O4;
946         }
947
948         /* Set the retaddr operand.  */
949         tcg_out_mov(s, TCG_TYPE_PTR, ra, TCG_REG_O7);
950         /* Set the env operand.  */
951         tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_O0, TCG_AREG0);
952         /* Tail call.  */
953         tcg_out_call_nodelay(s, qemu_ld_helpers[i], true);
954         tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_O7, ra);
955     }
956
957     for (i = 0; i < 16; ++i) {
958         if (qemu_st_helpers[i] == NULL) {
959             continue;
960         }
961
962         /* May as well align the trampoline.  */
963         while ((uintptr_t)s->code_ptr & 15) {
964             tcg_out_nop(s);
965         }
966         qemu_st_trampoline[i] = s->code_ptr;
967
968         if (SPARC64) {
969             emit_extend(s, TCG_REG_O2, i);
970             ra = TCG_REG_O4;
971         } else {
972             ra = TCG_REG_O1;
973             if (TARGET_LONG_BITS == 64) {
974                 /* Install the high part of the address.  */
975                 tcg_out_arithi(s, ra, ra + 1, 32, SHIFT_SRLX);
976                 ra += 2;
977             } else {
978                 ra += 1;
979             }
980             if ((i & MO_SIZE) == MO_64) {
981                 /* Install the high part of the data.  */
982                 tcg_out_arithi(s, ra, ra + 1, 32, SHIFT_SRLX);
983                 ra += 2;
984             } else {
985                 emit_extend(s, ra, i);
986                 ra += 1;
987             }
988             /* Skip the oi argument.  */
989             ra += 1;
990         }
991                 
992         /* Set the retaddr operand.  */
993         if (ra >= TCG_REG_O6) {
994             tcg_out_st(s, TCG_TYPE_PTR, TCG_REG_O7, TCG_REG_CALL_STACK,
995                        TCG_TARGET_CALL_STACK_OFFSET);
996             ra = TCG_REG_G1;
997         }
998         tcg_out_mov(s, TCG_TYPE_PTR, ra, TCG_REG_O7);
999         /* Set the env operand.  */
1000         tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_O0, TCG_AREG0);
1001         /* Tail call.  */
1002         tcg_out_call_nodelay(s, qemu_st_helpers[i], true);
1003         tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_O7, ra);
1004     }
1005 }
1006 #endif
1007
1008 /* Generate global QEMU prologue and epilogue code */
1009 static void tcg_target_qemu_prologue(TCGContext *s)
1010 {
1011     int tmp_buf_size, frame_size;
1012
1013     /* The TCG temp buffer is at the top of the frame, immediately
1014        below the frame pointer.  */
1015     tmp_buf_size = CPU_TEMP_BUF_NLONGS * (int)sizeof(long);
1016     tcg_set_frame(s, TCG_REG_I6, TCG_TARGET_STACK_BIAS - tmp_buf_size,
1017                   tmp_buf_size);
1018
1019     /* TCG_TARGET_CALL_STACK_OFFSET includes the stack bias, but is
1020        otherwise the minimal frame usable by callees.  */
1021     frame_size = TCG_TARGET_CALL_STACK_OFFSET - TCG_TARGET_STACK_BIAS;
1022     frame_size += TCG_STATIC_CALL_ARGS_SIZE + tmp_buf_size;
1023     frame_size += TCG_TARGET_STACK_ALIGN - 1;
1024     frame_size &= -TCG_TARGET_STACK_ALIGN;
1025     tcg_out32(s, SAVE | INSN_RD(TCG_REG_O6) | INSN_RS1(TCG_REG_O6) |
1026               INSN_IMM13(-frame_size));
1027
1028 #ifndef CONFIG_SOFTMMU
1029     if (guest_base != 0) {
1030         tcg_out_movi_int(s, TCG_TYPE_PTR, TCG_GUEST_BASE_REG, guest_base, true);
1031         tcg_regset_set_reg(s->reserved_regs, TCG_GUEST_BASE_REG);
1032     }
1033 #endif
1034
1035     /* We choose TCG_REG_TB such that no move is required.  */
1036     if (USE_REG_TB) {
1037         QEMU_BUILD_BUG_ON(TCG_REG_TB != TCG_REG_I1);
1038         tcg_regset_set_reg(s->reserved_regs, TCG_REG_TB);
1039     }
1040
1041     tcg_out_arithi(s, TCG_REG_G0, TCG_REG_I1, 0, JMPL);
1042     /* delay slot */
1043     tcg_out_nop(s);
1044
1045     /* Epilogue for goto_ptr.  */
1046     s->code_gen_epilogue = s->code_ptr;
1047     tcg_out_arithi(s, TCG_REG_G0, TCG_REG_I7, 8, RETURN);
1048     /* delay slot */
1049     tcg_out_movi_imm13(s, TCG_REG_O0, 0);
1050
1051 #ifdef CONFIG_SOFTMMU
1052     build_trampolines(s);
1053 #endif
1054 }
1055
1056 static void tcg_out_nop_fill(tcg_insn_unit *p, int count)
1057 {
1058     int i;
1059     for (i = 0; i < count; ++i) {
1060         p[i] = NOP;
1061     }
1062 }
1063
1064 #if defined(CONFIG_SOFTMMU)
1065
1066 /* We expect to use a 13-bit negative offset from ENV.  */
1067 QEMU_BUILD_BUG_ON(TLB_MASK_TABLE_OFS(0) > 0);
1068 QEMU_BUILD_BUG_ON(TLB_MASK_TABLE_OFS(0) < -(1 << 12));
1069
1070 /* Perform the TLB load and compare.
1071
1072    Inputs:
1073    ADDRLO and ADDRHI contain the possible two parts of the address.
1074
1075    MEM_INDEX and S_BITS are the memory context and log2 size of the load.
1076
1077    WHICH is the offset into the CPUTLBEntry structure of the slot to read.
1078    This should be offsetof addr_read or addr_write.
1079
1080    The result of the TLB comparison is in %[ix]cc.  The sanitized address
1081    is in the returned register, maybe %o0.  The TLB addend is in %o1.  */
1082
1083 static TCGReg tcg_out_tlb_load(TCGContext *s, TCGReg addr, int mem_index,
1084                                MemOp opc, int which)
1085 {
1086     int fast_off = TLB_MASK_TABLE_OFS(mem_index);
1087     int mask_off = fast_off + offsetof(CPUTLBDescFast, mask);
1088     int table_off = fast_off + offsetof(CPUTLBDescFast, table);
1089     const TCGReg r0 = TCG_REG_O0;
1090     const TCGReg r1 = TCG_REG_O1;
1091     const TCGReg r2 = TCG_REG_O2;
1092     unsigned s_bits = opc & MO_SIZE;
1093     unsigned a_bits = get_alignment_bits(opc);
1094     tcg_target_long compare_mask;
1095
1096     /* Load tlb_mask[mmu_idx] and tlb_table[mmu_idx].  */
1097     tcg_out_ld(s, TCG_TYPE_PTR, r0, TCG_AREG0, mask_off);
1098     tcg_out_ld(s, TCG_TYPE_PTR, r1, TCG_AREG0, table_off);
1099
1100     /* Extract the page index, shifted into place for tlb index.  */
1101     tcg_out_arithi(s, r2, addr, TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS,
1102                    SHIFT_SRL);
1103     tcg_out_arith(s, r2, r2, r0, ARITH_AND);
1104
1105     /* Add the tlb_table pointer, creating the CPUTLBEntry address into R2.  */
1106     tcg_out_arith(s, r2, r2, r1, ARITH_ADD);
1107
1108     /* Load the tlb comparator and the addend.  */
1109     tcg_out_ld(s, TCG_TYPE_TL, r0, r2, which);
1110     tcg_out_ld(s, TCG_TYPE_PTR, r1, r2, offsetof(CPUTLBEntry, addend));
1111
1112     /* Mask out the page offset, except for the required alignment.
1113        We don't support unaligned accesses.  */
1114     if (a_bits < s_bits) {
1115         a_bits = s_bits;
1116     }
1117     compare_mask = (tcg_target_ulong)TARGET_PAGE_MASK | ((1 << a_bits) - 1);
1118     if (check_fit_tl(compare_mask, 13)) {
1119         tcg_out_arithi(s, r2, addr, compare_mask, ARITH_AND);
1120     } else {
1121         tcg_out_movi(s, TCG_TYPE_TL, r2, compare_mask);
1122         tcg_out_arith(s, r2, addr, r2, ARITH_AND);
1123     }
1124     tcg_out_cmp(s, r0, r2, 0);
1125
1126     /* If the guest address must be zero-extended, do so now.  */
1127     if (SPARC64 && TARGET_LONG_BITS == 32) {
1128         tcg_out_arithi(s, r0, addr, 0, SHIFT_SRL);
1129         return r0;
1130     }
1131     return addr;
1132 }
1133 #endif /* CONFIG_SOFTMMU */
1134
1135 static const int qemu_ld_opc[16] = {
1136     [MO_UB]   = LDUB,
1137     [MO_SB]   = LDSB,
1138
1139     [MO_BEUW] = LDUH,
1140     [MO_BESW] = LDSH,
1141     [MO_BEUL] = LDUW,
1142     [MO_BESL] = LDSW,
1143     [MO_BEQ]  = LDX,
1144
1145     [MO_LEUW] = LDUH_LE,
1146     [MO_LESW] = LDSH_LE,
1147     [MO_LEUL] = LDUW_LE,
1148     [MO_LESL] = LDSW_LE,
1149     [MO_LEQ]  = LDX_LE,
1150 };
1151
1152 static const int qemu_st_opc[16] = {
1153     [MO_UB]   = STB,
1154
1155     [MO_BEUW] = STH,
1156     [MO_BEUL] = STW,
1157     [MO_BEQ]  = STX,
1158
1159     [MO_LEUW] = STH_LE,
1160     [MO_LEUL] = STW_LE,
1161     [MO_LEQ]  = STX_LE,
1162 };
1163
1164 static void tcg_out_qemu_ld(TCGContext *s, TCGReg data, TCGReg addr,
1165                             TCGMemOpIdx oi, bool is_64)
1166 {
1167     MemOp memop = get_memop(oi);
1168 #ifdef CONFIG_SOFTMMU
1169     unsigned memi = get_mmuidx(oi);
1170     TCGReg addrz, param;
1171     tcg_insn_unit *func;
1172     tcg_insn_unit *label_ptr;
1173
1174     addrz = tcg_out_tlb_load(s, addr, memi, memop,
1175                              offsetof(CPUTLBEntry, addr_read));
1176
1177     /* The fast path is exactly one insn.  Thus we can perform the
1178        entire TLB Hit in the (annulled) delay slot of the branch
1179        over the TLB Miss case.  */
1180
1181     /* beq,a,pt %[xi]cc, label0 */
1182     label_ptr = s->code_ptr;
1183     tcg_out_bpcc0(s, COND_E, BPCC_A | BPCC_PT
1184                   | (TARGET_LONG_BITS == 64 ? BPCC_XCC : BPCC_ICC), 0);
1185     /* delay slot */
1186     tcg_out_ldst_rr(s, data, addrz, TCG_REG_O1,
1187                     qemu_ld_opc[memop & (MO_BSWAP | MO_SSIZE)]);
1188
1189     /* TLB Miss.  */
1190
1191     param = TCG_REG_O1;
1192     if (!SPARC64 && TARGET_LONG_BITS == 64) {
1193         /* Skip the high-part; we'll perform the extract in the trampoline.  */
1194         param++;
1195     }
1196     tcg_out_mov(s, TCG_TYPE_REG, param++, addrz);
1197
1198     /* We use the helpers to extend SB and SW data, leaving the case
1199        of SL needing explicit extending below.  */
1200     if ((memop & MO_SSIZE) == MO_SL) {
1201         func = qemu_ld_trampoline[memop & (MO_BSWAP | MO_SIZE)];
1202     } else {
1203         func = qemu_ld_trampoline[memop & (MO_BSWAP | MO_SSIZE)];
1204     }
1205     tcg_debug_assert(func != NULL);
1206     tcg_out_call_nodelay(s, func, false);
1207     /* delay slot */
1208     tcg_out_movi(s, TCG_TYPE_I32, param, oi);
1209
1210     /* Recall that all of the helpers return 64-bit results.
1211        Which complicates things for sparcv8plus.  */
1212     if (SPARC64) {
1213         /* We let the helper sign-extend SB and SW, but leave SL for here.  */
1214         if (is_64 && (memop & MO_SSIZE) == MO_SL) {
1215             tcg_out_arithi(s, data, TCG_REG_O0, 0, SHIFT_SRA);
1216         } else {
1217             tcg_out_mov(s, TCG_TYPE_REG, data, TCG_REG_O0);
1218         }
1219     } else {
1220         if ((memop & MO_SIZE) == MO_64) {
1221             tcg_out_arithi(s, TCG_REG_O0, TCG_REG_O0, 32, SHIFT_SLLX);
1222             tcg_out_arithi(s, TCG_REG_O1, TCG_REG_O1, 0, SHIFT_SRL);
1223             tcg_out_arith(s, data, TCG_REG_O0, TCG_REG_O1, ARITH_OR);
1224         } else if (is_64) {
1225             /* Re-extend from 32-bit rather than reassembling when we
1226                know the high register must be an extension.  */
1227             tcg_out_arithi(s, data, TCG_REG_O1, 0,
1228                            memop & MO_SIGN ? SHIFT_SRA : SHIFT_SRL);
1229         } else {
1230             tcg_out_mov(s, TCG_TYPE_I32, data, TCG_REG_O1);
1231         }
1232     }
1233
1234     *label_ptr |= INSN_OFF19(tcg_ptr_byte_diff(s->code_ptr, label_ptr));
1235 #else
1236     if (SPARC64 && TARGET_LONG_BITS == 32) {
1237         tcg_out_arithi(s, TCG_REG_T1, addr, 0, SHIFT_SRL);
1238         addr = TCG_REG_T1;
1239     }
1240     tcg_out_ldst_rr(s, data, addr,
1241                     (guest_base ? TCG_GUEST_BASE_REG : TCG_REG_G0),
1242                     qemu_ld_opc[memop & (MO_BSWAP | MO_SSIZE)]);
1243 #endif /* CONFIG_SOFTMMU */
1244 }
1245
1246 static void tcg_out_qemu_st(TCGContext *s, TCGReg data, TCGReg addr,
1247                             TCGMemOpIdx oi)
1248 {
1249     MemOp memop = get_memop(oi);
1250 #ifdef CONFIG_SOFTMMU
1251     unsigned memi = get_mmuidx(oi);
1252     TCGReg addrz, param;
1253     tcg_insn_unit *func;
1254     tcg_insn_unit *label_ptr;
1255
1256     addrz = tcg_out_tlb_load(s, addr, memi, memop,
1257                              offsetof(CPUTLBEntry, addr_write));
1258
1259     /* The fast path is exactly one insn.  Thus we can perform the entire
1260        TLB Hit in the (annulled) delay slot of the branch over TLB Miss.  */
1261     /* beq,a,pt %[xi]cc, label0 */
1262     label_ptr = s->code_ptr;
1263     tcg_out_bpcc0(s, COND_E, BPCC_A | BPCC_PT
1264                   | (TARGET_LONG_BITS == 64 ? BPCC_XCC : BPCC_ICC), 0);
1265     /* delay slot */
1266     tcg_out_ldst_rr(s, data, addrz, TCG_REG_O1,
1267                     qemu_st_opc[memop & (MO_BSWAP | MO_SIZE)]);
1268
1269     /* TLB Miss.  */
1270
1271     param = TCG_REG_O1;
1272     if (!SPARC64 && TARGET_LONG_BITS == 64) {
1273         /* Skip the high-part; we'll perform the extract in the trampoline.  */
1274         param++;
1275     }
1276     tcg_out_mov(s, TCG_TYPE_REG, param++, addrz);
1277     if (!SPARC64 && (memop & MO_SIZE) == MO_64) {
1278         /* Skip the high-part; we'll perform the extract in the trampoline.  */
1279         param++;
1280     }
1281     tcg_out_mov(s, TCG_TYPE_REG, param++, data);
1282
1283     func = qemu_st_trampoline[memop & (MO_BSWAP | MO_SIZE)];
1284     tcg_debug_assert(func != NULL);
1285     tcg_out_call_nodelay(s, func, false);
1286     /* delay slot */
1287     tcg_out_movi(s, TCG_TYPE_I32, param, oi);
1288
1289     *label_ptr |= INSN_OFF19(tcg_ptr_byte_diff(s->code_ptr, label_ptr));
1290 #else
1291     if (SPARC64 && TARGET_LONG_BITS == 32) {
1292         tcg_out_arithi(s, TCG_REG_T1, addr, 0, SHIFT_SRL);
1293         addr = TCG_REG_T1;
1294     }
1295     tcg_out_ldst_rr(s, data, addr,
1296                     (guest_base ? TCG_GUEST_BASE_REG : TCG_REG_G0),
1297                     qemu_st_opc[memop & (MO_BSWAP | MO_SIZE)]);
1298 #endif /* CONFIG_SOFTMMU */
1299 }
1300
1301 static void tcg_out_op(TCGContext *s, TCGOpcode opc,
1302                        const TCGArg args[TCG_MAX_OP_ARGS],
1303                        const int const_args[TCG_MAX_OP_ARGS])
1304 {
1305     TCGArg a0, a1, a2;
1306     int c, c2;
1307
1308     /* Hoist the loads of the most common arguments.  */
1309     a0 = args[0];
1310     a1 = args[1];
1311     a2 = args[2];
1312     c2 = const_args[2];
1313
1314     switch (opc) {
1315     case INDEX_op_exit_tb:
1316         if (check_fit_ptr(a0, 13)) {
1317             tcg_out_arithi(s, TCG_REG_G0, TCG_REG_I7, 8, RETURN);
1318             tcg_out_movi_imm13(s, TCG_REG_O0, a0);
1319             break;
1320         } else if (USE_REG_TB) {
1321             intptr_t tb_diff = a0 - (uintptr_t)s->code_gen_ptr;
1322             if (check_fit_ptr(tb_diff, 13)) {
1323                 tcg_out_arithi(s, TCG_REG_G0, TCG_REG_I7, 8, RETURN);
1324                 /* Note that TCG_REG_TB has been unwound to O1.  */
1325                 tcg_out_arithi(s, TCG_REG_O0, TCG_REG_O1, tb_diff, ARITH_ADD);
1326                 break;
1327             }
1328         }
1329         tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_I0, a0 & ~0x3ff);
1330         tcg_out_arithi(s, TCG_REG_G0, TCG_REG_I7, 8, RETURN);
1331         tcg_out_arithi(s, TCG_REG_O0, TCG_REG_O0, a0 & 0x3ff, ARITH_OR);
1332         break;
1333     case INDEX_op_goto_tb:
1334         if (s->tb_jmp_insn_offset) {
1335             /* direct jump method */
1336             if (USE_REG_TB) {
1337                 /* make sure the patch is 8-byte aligned.  */
1338                 if ((intptr_t)s->code_ptr & 4) {
1339                     tcg_out_nop(s);
1340                 }
1341                 s->tb_jmp_insn_offset[a0] = tcg_current_code_size(s);
1342                 tcg_out_sethi(s, TCG_REG_T1, 0);
1343                 tcg_out_arithi(s, TCG_REG_T1, TCG_REG_T1, 0, ARITH_OR);
1344                 tcg_out_arith(s, TCG_REG_G0, TCG_REG_TB, TCG_REG_T1, JMPL);
1345                 tcg_out_arith(s, TCG_REG_TB, TCG_REG_TB, TCG_REG_T1, ARITH_ADD);
1346             } else {
1347                 s->tb_jmp_insn_offset[a0] = tcg_current_code_size(s);
1348                 tcg_out32(s, CALL);
1349                 tcg_out_nop(s);
1350             }
1351         } else {
1352             /* indirect jump method */
1353             tcg_out_ld_ptr(s, TCG_REG_TB,
1354                            (uintptr_t)(s->tb_jmp_target_addr + a0));
1355             tcg_out_arithi(s, TCG_REG_G0, TCG_REG_TB, 0, JMPL);
1356             tcg_out_nop(s);
1357         }
1358         set_jmp_reset_offset(s, a0);
1359
1360         /* For the unlinked path of goto_tb, we need to reset
1361            TCG_REG_TB to the beginning of this TB.  */
1362         if (USE_REG_TB) {
1363             c = -tcg_current_code_size(s);
1364             if (check_fit_i32(c, 13)) {
1365                 tcg_out_arithi(s, TCG_REG_TB, TCG_REG_TB, c, ARITH_ADD);
1366             } else {
1367                 tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_T1, c);
1368                 tcg_out_arith(s, TCG_REG_TB, TCG_REG_TB,
1369                               TCG_REG_T1, ARITH_ADD);
1370             }
1371         }
1372         break;
1373     case INDEX_op_goto_ptr:
1374         tcg_out_arithi(s, TCG_REG_G0, a0, 0, JMPL);
1375         if (USE_REG_TB) {
1376             tcg_out_arith(s, TCG_REG_TB, a0, TCG_REG_G0, ARITH_OR);
1377         } else {
1378             tcg_out_nop(s);
1379         }
1380         break;
1381     case INDEX_op_br:
1382         tcg_out_bpcc(s, COND_A, BPCC_PT, arg_label(a0));
1383         tcg_out_nop(s);
1384         break;
1385
1386 #define OP_32_64(x)                             \
1387         glue(glue(case INDEX_op_, x), _i32):    \
1388         glue(glue(case INDEX_op_, x), _i64)
1389
1390     OP_32_64(ld8u):
1391         tcg_out_ldst(s, a0, a1, a2, LDUB);
1392         break;
1393     OP_32_64(ld8s):
1394         tcg_out_ldst(s, a0, a1, a2, LDSB);
1395         break;
1396     OP_32_64(ld16u):
1397         tcg_out_ldst(s, a0, a1, a2, LDUH);
1398         break;
1399     OP_32_64(ld16s):
1400         tcg_out_ldst(s, a0, a1, a2, LDSH);
1401         break;
1402     case INDEX_op_ld_i32:
1403     case INDEX_op_ld32u_i64:
1404         tcg_out_ldst(s, a0, a1, a2, LDUW);
1405         break;
1406     OP_32_64(st8):
1407         tcg_out_ldst(s, a0, a1, a2, STB);
1408         break;
1409     OP_32_64(st16):
1410         tcg_out_ldst(s, a0, a1, a2, STH);
1411         break;
1412     case INDEX_op_st_i32:
1413     case INDEX_op_st32_i64:
1414         tcg_out_ldst(s, a0, a1, a2, STW);
1415         break;
1416     OP_32_64(add):
1417         c = ARITH_ADD;
1418         goto gen_arith;
1419     OP_32_64(sub):
1420         c = ARITH_SUB;
1421         goto gen_arith;
1422     OP_32_64(and):
1423         c = ARITH_AND;
1424         goto gen_arith;
1425     OP_32_64(andc):
1426         c = ARITH_ANDN;
1427         goto gen_arith;
1428     OP_32_64(or):
1429         c = ARITH_OR;
1430         goto gen_arith;
1431     OP_32_64(orc):
1432         c = ARITH_ORN;
1433         goto gen_arith;
1434     OP_32_64(xor):
1435         c = ARITH_XOR;
1436         goto gen_arith;
1437     case INDEX_op_shl_i32:
1438         c = SHIFT_SLL;
1439     do_shift32:
1440         /* Limit immediate shift count lest we create an illegal insn.  */
1441         tcg_out_arithc(s, a0, a1, a2 & 31, c2, c);
1442         break;
1443     case INDEX_op_shr_i32:
1444         c = SHIFT_SRL;
1445         goto do_shift32;
1446     case INDEX_op_sar_i32:
1447         c = SHIFT_SRA;
1448         goto do_shift32;
1449     case INDEX_op_mul_i32:
1450         c = ARITH_UMUL;
1451         goto gen_arith;
1452
1453     OP_32_64(neg):
1454         c = ARITH_SUB;
1455         goto gen_arith1;
1456     OP_32_64(not):
1457         c = ARITH_ORN;
1458         goto gen_arith1;
1459
1460     case INDEX_op_div_i32:
1461         tcg_out_div32(s, a0, a1, a2, c2, 0);
1462         break;
1463     case INDEX_op_divu_i32:
1464         tcg_out_div32(s, a0, a1, a2, c2, 1);
1465         break;
1466
1467     case INDEX_op_brcond_i32:
1468         tcg_out_brcond_i32(s, a2, a0, a1, const_args[1], arg_label(args[3]));
1469         break;
1470     case INDEX_op_setcond_i32:
1471         tcg_out_setcond_i32(s, args[3], a0, a1, a2, c2);
1472         break;
1473     case INDEX_op_movcond_i32:
1474         tcg_out_movcond_i32(s, args[5], a0, a1, a2, c2, args[3], const_args[3]);
1475         break;
1476
1477     case INDEX_op_add2_i32:
1478         tcg_out_addsub2_i32(s, args[0], args[1], args[2], args[3],
1479                             args[4], const_args[4], args[5], const_args[5],
1480                             ARITH_ADDCC, ARITH_ADDC);
1481         break;
1482     case INDEX_op_sub2_i32:
1483         tcg_out_addsub2_i32(s, args[0], args[1], args[2], args[3],
1484                             args[4], const_args[4], args[5], const_args[5],
1485                             ARITH_SUBCC, ARITH_SUBC);
1486         break;
1487     case INDEX_op_mulu2_i32:
1488         c = ARITH_UMUL;
1489         goto do_mul2;
1490     case INDEX_op_muls2_i32:
1491         c = ARITH_SMUL;
1492     do_mul2:
1493         /* The 32-bit multiply insns produce a full 64-bit result.  If the
1494            destination register can hold it, we can avoid the slower RDY.  */
1495         tcg_out_arithc(s, a0, a2, args[3], const_args[3], c);
1496         if (SPARC64 || a0 <= TCG_REG_O7) {
1497             tcg_out_arithi(s, a1, a0, 32, SHIFT_SRLX);
1498         } else {
1499             tcg_out_rdy(s, a1);
1500         }
1501         break;
1502
1503     case INDEX_op_qemu_ld_i32:
1504         tcg_out_qemu_ld(s, a0, a1, a2, false);
1505         break;
1506     case INDEX_op_qemu_ld_i64:
1507         tcg_out_qemu_ld(s, a0, a1, a2, true);
1508         break;
1509     case INDEX_op_qemu_st_i32:
1510     case INDEX_op_qemu_st_i64:
1511         tcg_out_qemu_st(s, a0, a1, a2);
1512         break;
1513
1514     case INDEX_op_ld32s_i64:
1515         tcg_out_ldst(s, a0, a1, a2, LDSW);
1516         break;
1517     case INDEX_op_ld_i64:
1518         tcg_out_ldst(s, a0, a1, a2, LDX);
1519         break;
1520     case INDEX_op_st_i64:
1521         tcg_out_ldst(s, a0, a1, a2, STX);
1522         break;
1523     case INDEX_op_shl_i64:
1524         c = SHIFT_SLLX;
1525     do_shift64:
1526         /* Limit immediate shift count lest we create an illegal insn.  */
1527         tcg_out_arithc(s, a0, a1, a2 & 63, c2, c);
1528         break;
1529     case INDEX_op_shr_i64:
1530         c = SHIFT_SRLX;
1531         goto do_shift64;
1532     case INDEX_op_sar_i64:
1533         c = SHIFT_SRAX;
1534         goto do_shift64;
1535     case INDEX_op_mul_i64:
1536         c = ARITH_MULX;
1537         goto gen_arith;
1538     case INDEX_op_div_i64:
1539         c = ARITH_SDIVX;
1540         goto gen_arith;
1541     case INDEX_op_divu_i64:
1542         c = ARITH_UDIVX;
1543         goto gen_arith;
1544     case INDEX_op_ext_i32_i64:
1545     case INDEX_op_ext32s_i64:
1546         tcg_out_arithi(s, a0, a1, 0, SHIFT_SRA);
1547         break;
1548     case INDEX_op_extu_i32_i64:
1549     case INDEX_op_ext32u_i64:
1550         tcg_out_arithi(s, a0, a1, 0, SHIFT_SRL);
1551         break;
1552     case INDEX_op_extrl_i64_i32:
1553         tcg_out_mov(s, TCG_TYPE_I32, a0, a1);
1554         break;
1555     case INDEX_op_extrh_i64_i32:
1556         tcg_out_arithi(s, a0, a1, 32, SHIFT_SRLX);
1557         break;
1558
1559     case INDEX_op_brcond_i64:
1560         tcg_out_brcond_i64(s, a2, a0, a1, const_args[1], arg_label(args[3]));
1561         break;
1562     case INDEX_op_setcond_i64:
1563         tcg_out_setcond_i64(s, args[3], a0, a1, a2, c2);
1564         break;
1565     case INDEX_op_movcond_i64:
1566         tcg_out_movcond_i64(s, args[5], a0, a1, a2, c2, args[3], const_args[3]);
1567         break;
1568     case INDEX_op_add2_i64:
1569         tcg_out_addsub2_i64(s, args[0], args[1], args[2], args[3], args[4],
1570                             const_args[4], args[5], const_args[5], false);
1571         break;
1572     case INDEX_op_sub2_i64:
1573         tcg_out_addsub2_i64(s, args[0], args[1], args[2], args[3], args[4],
1574                             const_args[4], args[5], const_args[5], true);
1575         break;
1576     case INDEX_op_muluh_i64:
1577         tcg_out_arith(s, args[0], args[1], args[2], ARITH_UMULXHI);
1578         break;
1579
1580     gen_arith:
1581         tcg_out_arithc(s, a0, a1, a2, c2, c);
1582         break;
1583
1584     gen_arith1:
1585         tcg_out_arithc(s, a0, TCG_REG_G0, a1, const_args[1], c);
1586         break;
1587
1588     case INDEX_op_mb:
1589         tcg_out_mb(s, a0);
1590         break;
1591
1592     case INDEX_op_mov_i32:  /* Always emitted via tcg_out_mov.  */
1593     case INDEX_op_mov_i64:
1594     case INDEX_op_movi_i32: /* Always emitted via tcg_out_movi.  */
1595     case INDEX_op_movi_i64:
1596     case INDEX_op_call:     /* Always emitted via tcg_out_call.  */
1597     default:
1598         tcg_abort();
1599     }
1600 }
1601
1602 static const TCGTargetOpDef *tcg_target_op_def(TCGOpcode op)
1603 {
1604     static const TCGTargetOpDef r = { .args_ct_str = { "r" } };
1605     static const TCGTargetOpDef r_r = { .args_ct_str = { "r", "r" } };
1606     static const TCGTargetOpDef R_r = { .args_ct_str = { "R", "r" } };
1607     static const TCGTargetOpDef r_R = { .args_ct_str = { "r", "R" } };
1608     static const TCGTargetOpDef R_R = { .args_ct_str = { "R", "R" } };
1609     static const TCGTargetOpDef r_A = { .args_ct_str = { "r", "A" } };
1610     static const TCGTargetOpDef R_A = { .args_ct_str = { "R", "A" } };
1611     static const TCGTargetOpDef rZ_r = { .args_ct_str = { "rZ", "r" } };
1612     static const TCGTargetOpDef RZ_r = { .args_ct_str = { "RZ", "r" } };
1613     static const TCGTargetOpDef sZ_A = { .args_ct_str = { "sZ", "A" } };
1614     static const TCGTargetOpDef SZ_A = { .args_ct_str = { "SZ", "A" } };
1615     static const TCGTargetOpDef rZ_rJ = { .args_ct_str = { "rZ", "rJ" } };
1616     static const TCGTargetOpDef RZ_RJ = { .args_ct_str = { "RZ", "RJ" } };
1617     static const TCGTargetOpDef R_R_R = { .args_ct_str = { "R", "R", "R" } };
1618     static const TCGTargetOpDef r_rZ_rJ
1619         = { .args_ct_str = { "r", "rZ", "rJ" } };
1620     static const TCGTargetOpDef R_RZ_RJ
1621         = { .args_ct_str = { "R", "RZ", "RJ" } };
1622     static const TCGTargetOpDef r_r_rZ_rJ
1623         = { .args_ct_str = { "r", "r", "rZ", "rJ" } };
1624     static const TCGTargetOpDef movc_32
1625         = { .args_ct_str = { "r", "rZ", "rJ", "rI", "0" } };
1626     static const TCGTargetOpDef movc_64
1627         = { .args_ct_str = { "R", "RZ", "RJ", "RI", "0" } };
1628     static const TCGTargetOpDef add2_32
1629         = { .args_ct_str = { "r", "r", "rZ", "rZ", "rJ", "rJ" } };
1630     static const TCGTargetOpDef add2_64
1631         = { .args_ct_str = { "R", "R", "RZ", "RZ", "RJ", "RI" } };
1632
1633     switch (op) {
1634     case INDEX_op_goto_ptr:
1635         return &r;
1636
1637     case INDEX_op_ld8u_i32:
1638     case INDEX_op_ld8s_i32:
1639     case INDEX_op_ld16u_i32:
1640     case INDEX_op_ld16s_i32:
1641     case INDEX_op_ld_i32:
1642     case INDEX_op_neg_i32:
1643     case INDEX_op_not_i32:
1644         return &r_r;
1645
1646     case INDEX_op_st8_i32:
1647     case INDEX_op_st16_i32:
1648     case INDEX_op_st_i32:
1649         return &rZ_r;
1650
1651     case INDEX_op_add_i32:
1652     case INDEX_op_mul_i32:
1653     case INDEX_op_div_i32:
1654     case INDEX_op_divu_i32:
1655     case INDEX_op_sub_i32:
1656     case INDEX_op_and_i32:
1657     case INDEX_op_andc_i32:
1658     case INDEX_op_or_i32:
1659     case INDEX_op_orc_i32:
1660     case INDEX_op_xor_i32:
1661     case INDEX_op_shl_i32:
1662     case INDEX_op_shr_i32:
1663     case INDEX_op_sar_i32:
1664     case INDEX_op_setcond_i32:
1665         return &r_rZ_rJ;
1666
1667     case INDEX_op_brcond_i32:
1668         return &rZ_rJ;
1669     case INDEX_op_movcond_i32:
1670         return &movc_32;
1671     case INDEX_op_add2_i32:
1672     case INDEX_op_sub2_i32:
1673         return &add2_32;
1674     case INDEX_op_mulu2_i32:
1675     case INDEX_op_muls2_i32:
1676         return &r_r_rZ_rJ;
1677
1678     case INDEX_op_ld8u_i64:
1679     case INDEX_op_ld8s_i64:
1680     case INDEX_op_ld16u_i64:
1681     case INDEX_op_ld16s_i64:
1682     case INDEX_op_ld32u_i64:
1683     case INDEX_op_ld32s_i64:
1684     case INDEX_op_ld_i64:
1685     case INDEX_op_ext_i32_i64:
1686     case INDEX_op_extu_i32_i64:
1687         return &R_r;
1688
1689     case INDEX_op_st8_i64:
1690     case INDEX_op_st16_i64:
1691     case INDEX_op_st32_i64:
1692     case INDEX_op_st_i64:
1693         return &RZ_r;
1694
1695     case INDEX_op_add_i64:
1696     case INDEX_op_mul_i64:
1697     case INDEX_op_div_i64:
1698     case INDEX_op_divu_i64:
1699     case INDEX_op_sub_i64:
1700     case INDEX_op_and_i64:
1701     case INDEX_op_andc_i64:
1702     case INDEX_op_or_i64:
1703     case INDEX_op_orc_i64:
1704     case INDEX_op_xor_i64:
1705     case INDEX_op_shl_i64:
1706     case INDEX_op_shr_i64:
1707     case INDEX_op_sar_i64:
1708     case INDEX_op_setcond_i64:
1709         return &R_RZ_RJ;
1710
1711     case INDEX_op_neg_i64:
1712     case INDEX_op_not_i64:
1713     case INDEX_op_ext32s_i64:
1714     case INDEX_op_ext32u_i64:
1715         return &R_R;
1716
1717     case INDEX_op_extrl_i64_i32:
1718     case INDEX_op_extrh_i64_i32:
1719         return &r_R;
1720
1721     case INDEX_op_brcond_i64:
1722         return &RZ_RJ;
1723     case INDEX_op_movcond_i64:
1724         return &movc_64;
1725     case INDEX_op_add2_i64:
1726     case INDEX_op_sub2_i64:
1727         return &add2_64;
1728     case INDEX_op_muluh_i64:
1729         return &R_R_R;
1730
1731     case INDEX_op_qemu_ld_i32:
1732         return &r_A;
1733     case INDEX_op_qemu_ld_i64:
1734         return &R_A;
1735     case INDEX_op_qemu_st_i32:
1736         return &sZ_A;
1737     case INDEX_op_qemu_st_i64:
1738         return &SZ_A;
1739
1740     default:
1741         return NULL;
1742     }
1743 }
1744
1745 static void tcg_target_init(TCGContext *s)
1746 {
1747     /* Only probe for the platform and capabilities if we havn't already
1748        determined maximum values at compile time.  */
1749 #ifndef use_vis3_instructions
1750     {
1751         unsigned long hwcap = qemu_getauxval(AT_HWCAP);
1752         use_vis3_instructions = (hwcap & HWCAP_SPARC_VIS3) != 0;
1753     }
1754 #endif
1755
1756     tcg_target_available_regs[TCG_TYPE_I32] = 0xffffffff;
1757     tcg_target_available_regs[TCG_TYPE_I64] = ALL_64;
1758
1759     tcg_target_call_clobber_regs = 0;
1760     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_G1);
1761     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_G2);
1762     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_G3);
1763     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_G4);
1764     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_G5);
1765     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_G6);
1766     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_G7);
1767     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_O0);
1768     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_O1);
1769     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_O2);
1770     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_O3);
1771     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_O4);
1772     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_O5);
1773     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_O6);
1774     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_O7);
1775
1776     s->reserved_regs = 0;
1777     tcg_regset_set_reg(s->reserved_regs, TCG_REG_G0); /* zero */
1778     tcg_regset_set_reg(s->reserved_regs, TCG_REG_G6); /* reserved for os */
1779     tcg_regset_set_reg(s->reserved_regs, TCG_REG_G7); /* thread pointer */
1780     tcg_regset_set_reg(s->reserved_regs, TCG_REG_I6); /* frame pointer */
1781     tcg_regset_set_reg(s->reserved_regs, TCG_REG_I7); /* return address */
1782     tcg_regset_set_reg(s->reserved_regs, TCG_REG_O6); /* stack pointer */
1783     tcg_regset_set_reg(s->reserved_regs, TCG_REG_T1); /* for internal use */
1784     tcg_regset_set_reg(s->reserved_regs, TCG_REG_T2); /* for internal use */
1785 }
1786
1787 #if SPARC64
1788 # define ELF_HOST_MACHINE  EM_SPARCV9
1789 #else
1790 # define ELF_HOST_MACHINE  EM_SPARC32PLUS
1791 # define ELF_HOST_FLAGS    EF_SPARC_32PLUS
1792 #endif
1793
1794 typedef struct {
1795     DebugFrameHeader h;
1796     uint8_t fde_def_cfa[SPARC64 ? 4 : 2];
1797     uint8_t fde_win_save;
1798     uint8_t fde_ret_save[3];
1799 } DebugFrame;
1800
1801 static const DebugFrame debug_frame = {
1802     .h.cie.len = sizeof(DebugFrameCIE)-4, /* length after .len member */
1803     .h.cie.id = -1,
1804     .h.cie.version = 1,
1805     .h.cie.code_align = 1,
1806     .h.cie.data_align = -sizeof(void *) & 0x7f,
1807     .h.cie.return_column = 15,            /* o7 */
1808
1809     /* Total FDE size does not include the "len" member.  */
1810     .h.fde.len = sizeof(DebugFrame) - offsetof(DebugFrame, h.fde.cie_offset),
1811
1812     .fde_def_cfa = {
1813 #if SPARC64
1814         12, 30,                         /* DW_CFA_def_cfa i6, 2047 */
1815         (2047 & 0x7f) | 0x80, (2047 >> 7)
1816 #else
1817         13, 30                          /* DW_CFA_def_cfa_register i6 */
1818 #endif
1819     },
1820     .fde_win_save = 0x2d,               /* DW_CFA_GNU_window_save */
1821     .fde_ret_save = { 9, 15, 31 },      /* DW_CFA_register o7, i7 */
1822 };
1823
1824 void tcg_register_jit(void *buf, size_t buf_size)
1825 {
1826     tcg_register_jit_int(buf, buf_size, &debug_frame, sizeof(debug_frame));
1827 }
1828
1829 void tb_target_set_jmp_target(uintptr_t tc_ptr, uintptr_t jmp_addr,
1830                               uintptr_t addr)
1831 {
1832     intptr_t tb_disp = addr - tc_ptr;
1833     intptr_t br_disp = addr - jmp_addr;
1834     tcg_insn_unit i1, i2;
1835
1836     /* We can reach the entire address space for ILP32.
1837        For LP64, the code_gen_buffer can't be larger than 2GB.  */
1838     tcg_debug_assert(tb_disp == (int32_t)tb_disp);
1839     tcg_debug_assert(br_disp == (int32_t)br_disp);
1840
1841     if (!USE_REG_TB) {
1842         qatomic_set((uint32_t *)jmp_addr,
1843                     deposit32(CALL, 0, 30, br_disp >> 2));
1844         flush_icache_range(jmp_addr, jmp_addr + 4);
1845         return;
1846     }
1847
1848     /* This does not exercise the range of the branch, but we do
1849        still need to be able to load the new value of TCG_REG_TB.
1850        But this does still happen quite often.  */
1851     if (check_fit_ptr(tb_disp, 13)) {
1852         /* ba,pt %icc, addr */
1853         i1 = (INSN_OP(0) | INSN_OP2(1) | INSN_COND(COND_A)
1854               | BPCC_ICC | BPCC_PT | INSN_OFF19(br_disp));
1855         i2 = (ARITH_ADD | INSN_RD(TCG_REG_TB) | INSN_RS1(TCG_REG_TB)
1856               | INSN_IMM13(tb_disp));
1857     } else if (tb_disp >= 0) {
1858         i1 = SETHI | INSN_RD(TCG_REG_T1) | ((tb_disp & 0xfffffc00) >> 10);
1859         i2 = (ARITH_OR | INSN_RD(TCG_REG_T1) | INSN_RS1(TCG_REG_T1)
1860               | INSN_IMM13(tb_disp & 0x3ff));
1861     } else {
1862         i1 = SETHI | INSN_RD(TCG_REG_T1) | ((~tb_disp & 0xfffffc00) >> 10);
1863         i2 = (ARITH_XOR | INSN_RD(TCG_REG_T1) | INSN_RS1(TCG_REG_T1)
1864               | INSN_IMM13((tb_disp & 0x3ff) | -0x400));
1865     }
1866
1867     qatomic_set((uint64_t *)jmp_addr, deposit64(i2, 32, 32, i1));
1868     flush_icache_range(jmp_addr, jmp_addr + 8);
1869 }