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