xref: /qemu/tcg/tci/tcg-target.c.inc (revision 92eecfff) 
1/*
2 * Tiny Code Generator for QEMU
3 *
4 * Copyright (c) 2009, 2011 Stefan Weil
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/* TODO list:
26 * - See TODO comments in code.
27 */
28
29/* Marker for missing code. */
30#define TODO() \
31    do { \
32        fprintf(stderr, "TODO %s:%u: %s()\n", \
33                __FILE__, __LINE__, __func__); \
34        tcg_abort(); \
35    } while (0)
36
37/* Bitfield n...m (in 32 bit value). */
38#define BITS(n, m) (((0xffffffffU << (31 - n)) >> (31 - n + m)) << m)
39
40/* Macros used in tcg_target_op_defs. */
41#define R       "r"
42#define RI      "ri"
43#if TCG_TARGET_REG_BITS == 32
44# define R64    "r", "r"
45#else
46# define R64    "r"
47#endif
48#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
49# define L      "L", "L"
50# define S      "S", "S"
51#else
52# define L      "L"
53# define S      "S"
54#endif
55
56/* TODO: documentation. */
57static const TCGTargetOpDef tcg_target_op_defs[] = {
58    { INDEX_op_exit_tb, { NULL } },
59    { INDEX_op_goto_tb, { NULL } },
60    { INDEX_op_br, { NULL } },
61
62    { INDEX_op_ld8u_i32, { R, R } },
63    { INDEX_op_ld8s_i32, { R, R } },
64    { INDEX_op_ld16u_i32, { R, R } },
65    { INDEX_op_ld16s_i32, { R, R } },
66    { INDEX_op_ld_i32, { R, R } },
67    { INDEX_op_st8_i32, { R, R } },
68    { INDEX_op_st16_i32, { R, R } },
69    { INDEX_op_st_i32, { R, R } },
70
71    { INDEX_op_add_i32, { R, RI, RI } },
72    { INDEX_op_sub_i32, { R, RI, RI } },
73    { INDEX_op_mul_i32, { R, RI, RI } },
74#if TCG_TARGET_HAS_div_i32
75    { INDEX_op_div_i32, { R, R, R } },
76    { INDEX_op_divu_i32, { R, R, R } },
77    { INDEX_op_rem_i32, { R, R, R } },
78    { INDEX_op_remu_i32, { R, R, R } },
79#elif TCG_TARGET_HAS_div2_i32
80    { INDEX_op_div2_i32, { R, R, "0", "1", R } },
81    { INDEX_op_divu2_i32, { R, R, "0", "1", R } },
82#endif
83    /* TODO: Does R, RI, RI result in faster code than R, R, RI?
84       If both operands are constants, we can optimize. */
85    { INDEX_op_and_i32, { R, RI, RI } },
86#if TCG_TARGET_HAS_andc_i32
87    { INDEX_op_andc_i32, { R, RI, RI } },
88#endif
89#if TCG_TARGET_HAS_eqv_i32
90    { INDEX_op_eqv_i32, { R, RI, RI } },
91#endif
92#if TCG_TARGET_HAS_nand_i32
93    { INDEX_op_nand_i32, { R, RI, RI } },
94#endif
95#if TCG_TARGET_HAS_nor_i32
96    { INDEX_op_nor_i32, { R, RI, RI } },
97#endif
98    { INDEX_op_or_i32, { R, RI, RI } },
99#if TCG_TARGET_HAS_orc_i32
100    { INDEX_op_orc_i32, { R, RI, RI } },
101#endif
102    { INDEX_op_xor_i32, { R, RI, RI } },
103    { INDEX_op_shl_i32, { R, RI, RI } },
104    { INDEX_op_shr_i32, { R, RI, RI } },
105    { INDEX_op_sar_i32, { R, RI, RI } },
106#if TCG_TARGET_HAS_rot_i32
107    { INDEX_op_rotl_i32, { R, RI, RI } },
108    { INDEX_op_rotr_i32, { R, RI, RI } },
109#endif
110#if TCG_TARGET_HAS_deposit_i32
111    { INDEX_op_deposit_i32, { R, "0", R } },
112#endif
113
114    { INDEX_op_brcond_i32, { R, RI } },
115
116    { INDEX_op_setcond_i32, { R, R, RI } },
117#if TCG_TARGET_REG_BITS == 64
118    { INDEX_op_setcond_i64, { R, R, RI } },
119#endif /* TCG_TARGET_REG_BITS == 64 */
120
121#if TCG_TARGET_REG_BITS == 32
122    /* TODO: Support R, R, R, R, RI, RI? Will it be faster? */
123    { INDEX_op_add2_i32, { R, R, R, R, R, R } },
124    { INDEX_op_sub2_i32, { R, R, R, R, R, R } },
125    { INDEX_op_brcond2_i32, { R, R, RI, RI } },
126    { INDEX_op_mulu2_i32, { R, R, R, R } },
127    { INDEX_op_setcond2_i32, { R, R, R, RI, RI } },
128#endif
129
130#if TCG_TARGET_HAS_not_i32
131    { INDEX_op_not_i32, { R, R } },
132#endif
133#if TCG_TARGET_HAS_neg_i32
134    { INDEX_op_neg_i32, { R, R } },
135#endif
136
137#if TCG_TARGET_REG_BITS == 64
138    { INDEX_op_ld8u_i64, { R, R } },
139    { INDEX_op_ld8s_i64, { R, R } },
140    { INDEX_op_ld16u_i64, { R, R } },
141    { INDEX_op_ld16s_i64, { R, R } },
142    { INDEX_op_ld32u_i64, { R, R } },
143    { INDEX_op_ld32s_i64, { R, R } },
144    { INDEX_op_ld_i64, { R, R } },
145
146    { INDEX_op_st8_i64, { R, R } },
147    { INDEX_op_st16_i64, { R, R } },
148    { INDEX_op_st32_i64, { R, R } },
149    { INDEX_op_st_i64, { R, R } },
150
151    { INDEX_op_add_i64, { R, RI, RI } },
152    { INDEX_op_sub_i64, { R, RI, RI } },
153    { INDEX_op_mul_i64, { R, RI, RI } },
154#if TCG_TARGET_HAS_div_i64
155    { INDEX_op_div_i64, { R, R, R } },
156    { INDEX_op_divu_i64, { R, R, R } },
157    { INDEX_op_rem_i64, { R, R, R } },
158    { INDEX_op_remu_i64, { R, R, R } },
159#elif TCG_TARGET_HAS_div2_i64
160    { INDEX_op_div2_i64, { R, R, "0", "1", R } },
161    { INDEX_op_divu2_i64, { R, R, "0", "1", R } },
162#endif
163    { INDEX_op_and_i64, { R, RI, RI } },
164#if TCG_TARGET_HAS_andc_i64
165    { INDEX_op_andc_i64, { R, RI, RI } },
166#endif
167#if TCG_TARGET_HAS_eqv_i64
168    { INDEX_op_eqv_i64, { R, RI, RI } },
169#endif
170#if TCG_TARGET_HAS_nand_i64
171    { INDEX_op_nand_i64, { R, RI, RI } },
172#endif
173#if TCG_TARGET_HAS_nor_i64
174    { INDEX_op_nor_i64, { R, RI, RI } },
175#endif
176    { INDEX_op_or_i64, { R, RI, RI } },
177#if TCG_TARGET_HAS_orc_i64
178    { INDEX_op_orc_i64, { R, RI, RI } },
179#endif
180    { INDEX_op_xor_i64, { R, RI, RI } },
181    { INDEX_op_shl_i64, { R, RI, RI } },
182    { INDEX_op_shr_i64, { R, RI, RI } },
183    { INDEX_op_sar_i64, { R, RI, RI } },
184#if TCG_TARGET_HAS_rot_i64
185    { INDEX_op_rotl_i64, { R, RI, RI } },
186    { INDEX_op_rotr_i64, { R, RI, RI } },
187#endif
188#if TCG_TARGET_HAS_deposit_i64
189    { INDEX_op_deposit_i64, { R, "0", R } },
190#endif
191    { INDEX_op_brcond_i64, { R, RI } },
192
193#if TCG_TARGET_HAS_ext8s_i64
194    { INDEX_op_ext8s_i64, { R, R } },
195#endif
196#if TCG_TARGET_HAS_ext16s_i64
197    { INDEX_op_ext16s_i64, { R, R } },
198#endif
199#if TCG_TARGET_HAS_ext32s_i64
200    { INDEX_op_ext32s_i64, { R, R } },
201#endif
202#if TCG_TARGET_HAS_ext8u_i64
203    { INDEX_op_ext8u_i64, { R, R } },
204#endif
205#if TCG_TARGET_HAS_ext16u_i64
206    { INDEX_op_ext16u_i64, { R, R } },
207#endif
208#if TCG_TARGET_HAS_ext32u_i64
209    { INDEX_op_ext32u_i64, { R, R } },
210#endif
211    { INDEX_op_ext_i32_i64, { R, R } },
212    { INDEX_op_extu_i32_i64, { R, R } },
213#if TCG_TARGET_HAS_bswap16_i64
214    { INDEX_op_bswap16_i64, { R, R } },
215#endif
216#if TCG_TARGET_HAS_bswap32_i64
217    { INDEX_op_bswap32_i64, { R, R } },
218#endif
219#if TCG_TARGET_HAS_bswap64_i64
220    { INDEX_op_bswap64_i64, { R, R } },
221#endif
222#if TCG_TARGET_HAS_not_i64
223    { INDEX_op_not_i64, { R, R } },
224#endif
225#if TCG_TARGET_HAS_neg_i64
226    { INDEX_op_neg_i64, { R, R } },
227#endif
228#endif /* TCG_TARGET_REG_BITS == 64 */
229
230    { INDEX_op_qemu_ld_i32, { R, L } },
231    { INDEX_op_qemu_ld_i64, { R64, L } },
232
233    { INDEX_op_qemu_st_i32, { R, S } },
234    { INDEX_op_qemu_st_i64, { R64, S } },
235
236#if TCG_TARGET_HAS_ext8s_i32
237    { INDEX_op_ext8s_i32, { R, R } },
238#endif
239#if TCG_TARGET_HAS_ext16s_i32
240    { INDEX_op_ext16s_i32, { R, R } },
241#endif
242#if TCG_TARGET_HAS_ext8u_i32
243    { INDEX_op_ext8u_i32, { R, R } },
244#endif
245#if TCG_TARGET_HAS_ext16u_i32
246    { INDEX_op_ext16u_i32, { R, R } },
247#endif
248
249#if TCG_TARGET_HAS_bswap16_i32
250    { INDEX_op_bswap16_i32, { R, R } },
251#endif
252#if TCG_TARGET_HAS_bswap32_i32
253    { INDEX_op_bswap32_i32, { R, R } },
254#endif
255
256    { INDEX_op_mb, { } },
257    { -1 },
258};
259
260static const TCGTargetOpDef *tcg_target_op_def(TCGOpcode op)
261{
262    int i, n = ARRAY_SIZE(tcg_target_op_defs);
263
264    for (i = 0; i < n; ++i) {
265        if (tcg_target_op_defs[i].op == op) {
266            return &tcg_target_op_defs[i];
267        }
268    }
269    return NULL;
270}
271
272static const int tcg_target_reg_alloc_order[] = {
273    TCG_REG_R0,
274    TCG_REG_R1,
275    TCG_REG_R2,
276    TCG_REG_R3,
277#if 0 /* used for TCG_REG_CALL_STACK */
278    TCG_REG_R4,
279#endif
280    TCG_REG_R5,
281    TCG_REG_R6,
282    TCG_REG_R7,
283#if TCG_TARGET_NB_REGS >= 16
284    TCG_REG_R8,
285    TCG_REG_R9,
286    TCG_REG_R10,
287    TCG_REG_R11,
288    TCG_REG_R12,
289    TCG_REG_R13,
290    TCG_REG_R14,
291    TCG_REG_R15,
292#endif
293};
294
295#if MAX_OPC_PARAM_IARGS != 6
296# error Fix needed, number of supported input arguments changed!
297#endif
298
299static const int tcg_target_call_iarg_regs[] = {
300    TCG_REG_R0,
301    TCG_REG_R1,
302    TCG_REG_R2,
303    TCG_REG_R3,
304#if 0 /* used for TCG_REG_CALL_STACK */
305    TCG_REG_R4,
306#endif
307    TCG_REG_R5,
308    TCG_REG_R6,
309#if TCG_TARGET_REG_BITS == 32
310    /* 32 bit hosts need 2 * MAX_OPC_PARAM_IARGS registers. */
311    TCG_REG_R7,
312#if TCG_TARGET_NB_REGS >= 16
313    TCG_REG_R8,
314    TCG_REG_R9,
315    TCG_REG_R10,
316    TCG_REG_R11,
317    TCG_REG_R12,
318#else
319# error Too few input registers available
320#endif
321#endif
322};
323
324static const int tcg_target_call_oarg_regs[] = {
325    TCG_REG_R0,
326#if TCG_TARGET_REG_BITS == 32
327    TCG_REG_R1
328#endif
329};
330
331#ifdef CONFIG_DEBUG_TCG
332static const char *const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
333    "r00",
334    "r01",
335    "r02",
336    "r03",
337    "r04",
338    "r05",
339    "r06",
340    "r07",
341#if TCG_TARGET_NB_REGS >= 16
342    "r08",
343    "r09",
344    "r10",
345    "r11",
346    "r12",
347    "r13",
348    "r14",
349    "r15",
350#if TCG_TARGET_NB_REGS >= 32
351    "r16",
352    "r17",
353    "r18",
354    "r19",
355    "r20",
356    "r21",
357    "r22",
358    "r23",
359    "r24",
360    "r25",
361    "r26",
362    "r27",
363    "r28",
364    "r29",
365    "r30",
366    "r31"
367#endif
368#endif
369};
370#endif
371
372static bool patch_reloc(tcg_insn_unit *code_ptr, int type,
373                        intptr_t value, intptr_t addend)
374{
375    /* tcg_out_reloc always uses the same type, addend. */
376    tcg_debug_assert(type == sizeof(tcg_target_long));
377    tcg_debug_assert(addend == 0);
378    tcg_debug_assert(value != 0);
379    if (TCG_TARGET_REG_BITS == 32) {
380        tcg_patch32(code_ptr, value);
381    } else {
382        tcg_patch64(code_ptr, value);
383    }
384    return true;
385}
386
387/* Parse target specific constraints. */
388static const char *target_parse_constraint(TCGArgConstraint *ct,
389                                           const char *ct_str, TCGType type)
390{
391    switch (*ct_str++) {
392    case 'r':
393    case 'L':                   /* qemu_ld constraint */
394    case 'S':                   /* qemu_st constraint */
395        ct->regs = BIT(TCG_TARGET_NB_REGS) - 1;
396        break;
397    default:
398        return NULL;
399    }
400    return ct_str;
401}
402
403#if defined(CONFIG_DEBUG_TCG_INTERPRETER)
404/* Show current bytecode. Used by tcg interpreter. */
405void tci_disas(uint8_t opc)
406{
407    const TCGOpDef *def = &tcg_op_defs[opc];
408    fprintf(stderr, "TCG %s %u, %u, %u\n",
409            def->name, def->nb_oargs, def->nb_iargs, def->nb_cargs);
410}
411#endif
412
413/* Write value (native size). */
414static void tcg_out_i(TCGContext *s, tcg_target_ulong v)
415{
416    if (TCG_TARGET_REG_BITS == 32) {
417        tcg_out32(s, v);
418    } else {
419        tcg_out64(s, v);
420    }
421}
422
423/* Write opcode. */
424static void tcg_out_op_t(TCGContext *s, TCGOpcode op)
425{
426    tcg_out8(s, op);
427    tcg_out8(s, 0);
428}
429
430/* Write register. */
431static void tcg_out_r(TCGContext *s, TCGArg t0)
432{
433    tcg_debug_assert(t0 < TCG_TARGET_NB_REGS);
434    tcg_out8(s, t0);
435}
436
437/* Write register or constant (native size). */
438static void tcg_out_ri(TCGContext *s, int const_arg, TCGArg arg)
439{
440    if (const_arg) {
441        tcg_debug_assert(const_arg == 1);
442        tcg_out8(s, TCG_CONST);
443        tcg_out_i(s, arg);
444    } else {
445        tcg_out_r(s, arg);
446    }
447}
448
449/* Write register or constant (32 bit). */
450static void tcg_out_ri32(TCGContext *s, int const_arg, TCGArg arg)
451{
452    if (const_arg) {
453        tcg_debug_assert(const_arg == 1);
454        tcg_out8(s, TCG_CONST);
455        tcg_out32(s, arg);
456    } else {
457        tcg_out_r(s, arg);
458    }
459}
460
461#if TCG_TARGET_REG_BITS == 64
462/* Write register or constant (64 bit). */
463static void tcg_out_ri64(TCGContext *s, int const_arg, TCGArg arg)
464{
465    if (const_arg) {
466        tcg_debug_assert(const_arg == 1);
467        tcg_out8(s, TCG_CONST);
468        tcg_out64(s, arg);
469    } else {
470        tcg_out_r(s, arg);
471    }
472}
473#endif
474
475/* Write label. */
476static void tci_out_label(TCGContext *s, TCGLabel *label)
477{
478    if (label->has_value) {
479        tcg_out_i(s, label->u.value);
480        tcg_debug_assert(label->u.value);
481    } else {
482        tcg_out_reloc(s, s->code_ptr, sizeof(tcg_target_ulong), label, 0);
483        s->code_ptr += sizeof(tcg_target_ulong);
484    }
485}
486
487static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1,
488                       intptr_t arg2)
489{
490    uint8_t *old_code_ptr = s->code_ptr;
491    if (type == TCG_TYPE_I32) {
492        tcg_out_op_t(s, INDEX_op_ld_i32);
493        tcg_out_r(s, ret);
494        tcg_out_r(s, arg1);
495        tcg_out32(s, arg2);
496    } else {
497        tcg_debug_assert(type == TCG_TYPE_I64);
498#if TCG_TARGET_REG_BITS == 64
499        tcg_out_op_t(s, INDEX_op_ld_i64);
500        tcg_out_r(s, ret);
501        tcg_out_r(s, arg1);
502        tcg_debug_assert(arg2 == (int32_t)arg2);
503        tcg_out32(s, arg2);
504#else
505        TODO();
506#endif
507    }
508    old_code_ptr[1] = s->code_ptr - old_code_ptr;
509}
510
511static bool tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg)
512{
513    uint8_t *old_code_ptr = s->code_ptr;
514    tcg_debug_assert(ret != arg);
515#if TCG_TARGET_REG_BITS == 32
516    tcg_out_op_t(s, INDEX_op_mov_i32);
517#else
518    tcg_out_op_t(s, INDEX_op_mov_i64);
519#endif
520    tcg_out_r(s, ret);
521    tcg_out_r(s, arg);
522    old_code_ptr[1] = s->code_ptr - old_code_ptr;
523    return true;
524}
525
526static void tcg_out_movi(TCGContext *s, TCGType type,
527                         TCGReg t0, tcg_target_long arg)
528{
529    uint8_t *old_code_ptr = s->code_ptr;
530    uint32_t arg32 = arg;
531    if (type == TCG_TYPE_I32 || arg == arg32) {
532        tcg_out_op_t(s, INDEX_op_movi_i32);
533        tcg_out_r(s, t0);
534        tcg_out32(s, arg32);
535    } else {
536        tcg_debug_assert(type == TCG_TYPE_I64);
537#if TCG_TARGET_REG_BITS == 64
538        tcg_out_op_t(s, INDEX_op_movi_i64);
539        tcg_out_r(s, t0);
540        tcg_out64(s, arg);
541#else
542        TODO();
543#endif
544    }
545    old_code_ptr[1] = s->code_ptr - old_code_ptr;
546}
547
548static inline void tcg_out_call(TCGContext *s, tcg_insn_unit *arg)
549{
550    uint8_t *old_code_ptr = s->code_ptr;
551    tcg_out_op_t(s, INDEX_op_call);
552    tcg_out_ri(s, 1, (uintptr_t)arg);
553    old_code_ptr[1] = s->code_ptr - old_code_ptr;
554}
555
556static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args,
557                       const int *const_args)
558{
559    uint8_t *old_code_ptr = s->code_ptr;
560
561    tcg_out_op_t(s, opc);
562
563    switch (opc) {
564    case INDEX_op_exit_tb:
565        tcg_out64(s, args[0]);
566        break;
567    case INDEX_op_goto_tb:
568        if (s->tb_jmp_insn_offset) {
569            /* Direct jump method. */
570            /* Align for atomic patching and thread safety */
571            s->code_ptr = QEMU_ALIGN_PTR_UP(s->code_ptr, 4);
572            s->tb_jmp_insn_offset[args[0]] = tcg_current_code_size(s);
573            tcg_out32(s, 0);
574        } else {
575            /* Indirect jump method. */
576            TODO();
577        }
578        set_jmp_reset_offset(s, args[0]);
579        break;
580    case INDEX_op_br:
581        tci_out_label(s, arg_label(args[0]));
582        break;
583    case INDEX_op_setcond_i32:
584        tcg_out_r(s, args[0]);
585        tcg_out_r(s, args[1]);
586        tcg_out_ri32(s, const_args[2], args[2]);
587        tcg_out8(s, args[3]);   /* condition */
588        break;
589#if TCG_TARGET_REG_BITS == 32
590    case INDEX_op_setcond2_i32:
591        /* setcond2_i32 cond, t0, t1_low, t1_high, t2_low, t2_high */
592        tcg_out_r(s, args[0]);
593        tcg_out_r(s, args[1]);
594        tcg_out_r(s, args[2]);
595        tcg_out_ri32(s, const_args[3], args[3]);
596        tcg_out_ri32(s, const_args[4], args[4]);
597        tcg_out8(s, args[5]);   /* condition */
598        break;
599#elif TCG_TARGET_REG_BITS == 64
600    case INDEX_op_setcond_i64:
601        tcg_out_r(s, args[0]);
602        tcg_out_r(s, args[1]);
603        tcg_out_ri64(s, const_args[2], args[2]);
604        tcg_out8(s, args[3]);   /* condition */
605        break;
606#endif
607    case INDEX_op_ld8u_i32:
608    case INDEX_op_ld8s_i32:
609    case INDEX_op_ld16u_i32:
610    case INDEX_op_ld16s_i32:
611    case INDEX_op_ld_i32:
612    case INDEX_op_st8_i32:
613    case INDEX_op_st16_i32:
614    case INDEX_op_st_i32:
615    case INDEX_op_ld8u_i64:
616    case INDEX_op_ld8s_i64:
617    case INDEX_op_ld16u_i64:
618    case INDEX_op_ld16s_i64:
619    case INDEX_op_ld32u_i64:
620    case INDEX_op_ld32s_i64:
621    case INDEX_op_ld_i64:
622    case INDEX_op_st8_i64:
623    case INDEX_op_st16_i64:
624    case INDEX_op_st32_i64:
625    case INDEX_op_st_i64:
626        tcg_out_r(s, args[0]);
627        tcg_out_r(s, args[1]);
628        tcg_debug_assert(args[2] == (int32_t)args[2]);
629        tcg_out32(s, args[2]);
630        break;
631    case INDEX_op_add_i32:
632    case INDEX_op_sub_i32:
633    case INDEX_op_mul_i32:
634    case INDEX_op_and_i32:
635    case INDEX_op_andc_i32:     /* Optional (TCG_TARGET_HAS_andc_i32). */
636    case INDEX_op_eqv_i32:      /* Optional (TCG_TARGET_HAS_eqv_i32). */
637    case INDEX_op_nand_i32:     /* Optional (TCG_TARGET_HAS_nand_i32). */
638    case INDEX_op_nor_i32:      /* Optional (TCG_TARGET_HAS_nor_i32). */
639    case INDEX_op_or_i32:
640    case INDEX_op_orc_i32:      /* Optional (TCG_TARGET_HAS_orc_i32). */
641    case INDEX_op_xor_i32:
642    case INDEX_op_shl_i32:
643    case INDEX_op_shr_i32:
644    case INDEX_op_sar_i32:
645    case INDEX_op_rotl_i32:     /* Optional (TCG_TARGET_HAS_rot_i32). */
646    case INDEX_op_rotr_i32:     /* Optional (TCG_TARGET_HAS_rot_i32). */
647        tcg_out_r(s, args[0]);
648        tcg_out_ri32(s, const_args[1], args[1]);
649        tcg_out_ri32(s, const_args[2], args[2]);
650        break;
651    case INDEX_op_deposit_i32:  /* Optional (TCG_TARGET_HAS_deposit_i32). */
652        tcg_out_r(s, args[0]);
653        tcg_out_r(s, args[1]);
654        tcg_out_r(s, args[2]);
655        tcg_debug_assert(args[3] <= UINT8_MAX);
656        tcg_out8(s, args[3]);
657        tcg_debug_assert(args[4] <= UINT8_MAX);
658        tcg_out8(s, args[4]);
659        break;
660
661#if TCG_TARGET_REG_BITS == 64
662    case INDEX_op_add_i64:
663    case INDEX_op_sub_i64:
664    case INDEX_op_mul_i64:
665    case INDEX_op_and_i64:
666    case INDEX_op_andc_i64:     /* Optional (TCG_TARGET_HAS_andc_i64). */
667    case INDEX_op_eqv_i64:      /* Optional (TCG_TARGET_HAS_eqv_i64). */
668    case INDEX_op_nand_i64:     /* Optional (TCG_TARGET_HAS_nand_i64). */
669    case INDEX_op_nor_i64:      /* Optional (TCG_TARGET_HAS_nor_i64). */
670    case INDEX_op_or_i64:
671    case INDEX_op_orc_i64:      /* Optional (TCG_TARGET_HAS_orc_i64). */
672    case INDEX_op_xor_i64:
673    case INDEX_op_shl_i64:
674    case INDEX_op_shr_i64:
675    case INDEX_op_sar_i64:
676    case INDEX_op_rotl_i64:     /* Optional (TCG_TARGET_HAS_rot_i64). */
677    case INDEX_op_rotr_i64:     /* Optional (TCG_TARGET_HAS_rot_i64). */
678        tcg_out_r(s, args[0]);
679        tcg_out_ri64(s, const_args[1], args[1]);
680        tcg_out_ri64(s, const_args[2], args[2]);
681        break;
682    case INDEX_op_deposit_i64:  /* Optional (TCG_TARGET_HAS_deposit_i64). */
683        tcg_out_r(s, args[0]);
684        tcg_out_r(s, args[1]);
685        tcg_out_r(s, args[2]);
686        tcg_debug_assert(args[3] <= UINT8_MAX);
687        tcg_out8(s, args[3]);
688        tcg_debug_assert(args[4] <= UINT8_MAX);
689        tcg_out8(s, args[4]);
690        break;
691    case INDEX_op_div_i64:      /* Optional (TCG_TARGET_HAS_div_i64). */
692    case INDEX_op_divu_i64:     /* Optional (TCG_TARGET_HAS_div_i64). */
693    case INDEX_op_rem_i64:      /* Optional (TCG_TARGET_HAS_div_i64). */
694    case INDEX_op_remu_i64:     /* Optional (TCG_TARGET_HAS_div_i64). */
695        TODO();
696        break;
697    case INDEX_op_div2_i64:     /* Optional (TCG_TARGET_HAS_div2_i64). */
698    case INDEX_op_divu2_i64:    /* Optional (TCG_TARGET_HAS_div2_i64). */
699        TODO();
700        break;
701    case INDEX_op_brcond_i64:
702        tcg_out_r(s, args[0]);
703        tcg_out_ri64(s, const_args[1], args[1]);
704        tcg_out8(s, args[2]);           /* condition */
705        tci_out_label(s, arg_label(args[3]));
706        break;
707    case INDEX_op_bswap16_i64:  /* Optional (TCG_TARGET_HAS_bswap16_i64). */
708    case INDEX_op_bswap32_i64:  /* Optional (TCG_TARGET_HAS_bswap32_i64). */
709    case INDEX_op_bswap64_i64:  /* Optional (TCG_TARGET_HAS_bswap64_i64). */
710    case INDEX_op_not_i64:      /* Optional (TCG_TARGET_HAS_not_i64). */
711    case INDEX_op_neg_i64:      /* Optional (TCG_TARGET_HAS_neg_i64). */
712    case INDEX_op_ext8s_i64:    /* Optional (TCG_TARGET_HAS_ext8s_i64). */
713    case INDEX_op_ext8u_i64:    /* Optional (TCG_TARGET_HAS_ext8u_i64). */
714    case INDEX_op_ext16s_i64:   /* Optional (TCG_TARGET_HAS_ext16s_i64). */
715    case INDEX_op_ext16u_i64:   /* Optional (TCG_TARGET_HAS_ext16u_i64). */
716    case INDEX_op_ext32s_i64:   /* Optional (TCG_TARGET_HAS_ext32s_i64). */
717    case INDEX_op_ext32u_i64:   /* Optional (TCG_TARGET_HAS_ext32u_i64). */
718    case INDEX_op_ext_i32_i64:
719    case INDEX_op_extu_i32_i64:
720#endif /* TCG_TARGET_REG_BITS == 64 */
721    case INDEX_op_neg_i32:      /* Optional (TCG_TARGET_HAS_neg_i32). */
722    case INDEX_op_not_i32:      /* Optional (TCG_TARGET_HAS_not_i32). */
723    case INDEX_op_ext8s_i32:    /* Optional (TCG_TARGET_HAS_ext8s_i32). */
724    case INDEX_op_ext16s_i32:   /* Optional (TCG_TARGET_HAS_ext16s_i32). */
725    case INDEX_op_ext8u_i32:    /* Optional (TCG_TARGET_HAS_ext8u_i32). */
726    case INDEX_op_ext16u_i32:   /* Optional (TCG_TARGET_HAS_ext16u_i32). */
727    case INDEX_op_bswap16_i32:  /* Optional (TCG_TARGET_HAS_bswap16_i32). */
728    case INDEX_op_bswap32_i32:  /* Optional (TCG_TARGET_HAS_bswap32_i32). */
729        tcg_out_r(s, args[0]);
730        tcg_out_r(s, args[1]);
731        break;
732    case INDEX_op_div_i32:      /* Optional (TCG_TARGET_HAS_div_i32). */
733    case INDEX_op_divu_i32:     /* Optional (TCG_TARGET_HAS_div_i32). */
734    case INDEX_op_rem_i32:      /* Optional (TCG_TARGET_HAS_div_i32). */
735    case INDEX_op_remu_i32:     /* Optional (TCG_TARGET_HAS_div_i32). */
736        tcg_out_r(s, args[0]);
737        tcg_out_ri32(s, const_args[1], args[1]);
738        tcg_out_ri32(s, const_args[2], args[2]);
739        break;
740    case INDEX_op_div2_i32:     /* Optional (TCG_TARGET_HAS_div2_i32). */
741    case INDEX_op_divu2_i32:    /* Optional (TCG_TARGET_HAS_div2_i32). */
742        TODO();
743        break;
744#if TCG_TARGET_REG_BITS == 32
745    case INDEX_op_add2_i32:
746    case INDEX_op_sub2_i32:
747        tcg_out_r(s, args[0]);
748        tcg_out_r(s, args[1]);
749        tcg_out_r(s, args[2]);
750        tcg_out_r(s, args[3]);
751        tcg_out_r(s, args[4]);
752        tcg_out_r(s, args[5]);
753        break;
754    case INDEX_op_brcond2_i32:
755        tcg_out_r(s, args[0]);
756        tcg_out_r(s, args[1]);
757        tcg_out_ri32(s, const_args[2], args[2]);
758        tcg_out_ri32(s, const_args[3], args[3]);
759        tcg_out8(s, args[4]);           /* condition */
760        tci_out_label(s, arg_label(args[5]));
761        break;
762    case INDEX_op_mulu2_i32:
763        tcg_out_r(s, args[0]);
764        tcg_out_r(s, args[1]);
765        tcg_out_r(s, args[2]);
766        tcg_out_r(s, args[3]);
767        break;
768#endif
769    case INDEX_op_brcond_i32:
770        tcg_out_r(s, args[0]);
771        tcg_out_ri32(s, const_args[1], args[1]);
772        tcg_out8(s, args[2]);           /* condition */
773        tci_out_label(s, arg_label(args[3]));
774        break;
775    case INDEX_op_qemu_ld_i32:
776        tcg_out_r(s, *args++);
777        tcg_out_r(s, *args++);
778        if (TARGET_LONG_BITS > TCG_TARGET_REG_BITS) {
779            tcg_out_r(s, *args++);
780        }
781        tcg_out_i(s, *args++);
782        break;
783    case INDEX_op_qemu_ld_i64:
784        tcg_out_r(s, *args++);
785        if (TCG_TARGET_REG_BITS == 32) {
786            tcg_out_r(s, *args++);
787        }
788        tcg_out_r(s, *args++);
789        if (TARGET_LONG_BITS > TCG_TARGET_REG_BITS) {
790            tcg_out_r(s, *args++);
791        }
792        tcg_out_i(s, *args++);
793        break;
794    case INDEX_op_qemu_st_i32:
795        tcg_out_r(s, *args++);
796        tcg_out_r(s, *args++);
797        if (TARGET_LONG_BITS > TCG_TARGET_REG_BITS) {
798            tcg_out_r(s, *args++);
799        }
800        tcg_out_i(s, *args++);
801        break;
802    case INDEX_op_qemu_st_i64:
803        tcg_out_r(s, *args++);
804        if (TCG_TARGET_REG_BITS == 32) {
805            tcg_out_r(s, *args++);
806        }
807        tcg_out_r(s, *args++);
808        if (TARGET_LONG_BITS > TCG_TARGET_REG_BITS) {
809            tcg_out_r(s, *args++);
810        }
811        tcg_out_i(s, *args++);
812        break;
813    case INDEX_op_mb:
814        break;
815    case INDEX_op_mov_i32:  /* Always emitted via tcg_out_mov.  */
816    case INDEX_op_mov_i64:
817    case INDEX_op_movi_i32: /* Always emitted via tcg_out_movi.  */
818    case INDEX_op_movi_i64:
819    case INDEX_op_call:     /* Always emitted via tcg_out_call.  */
820    default:
821        tcg_abort();
822    }
823    old_code_ptr[1] = s->code_ptr - old_code_ptr;
824}
825
826static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1,
827                       intptr_t arg2)
828{
829    uint8_t *old_code_ptr = s->code_ptr;
830    if (type == TCG_TYPE_I32) {
831        tcg_out_op_t(s, INDEX_op_st_i32);
832        tcg_out_r(s, arg);
833        tcg_out_r(s, arg1);
834        tcg_out32(s, arg2);
835    } else {
836        tcg_debug_assert(type == TCG_TYPE_I64);
837#if TCG_TARGET_REG_BITS == 64
838        tcg_out_op_t(s, INDEX_op_st_i64);
839        tcg_out_r(s, arg);
840        tcg_out_r(s, arg1);
841        tcg_out32(s, arg2);
842#else
843        TODO();
844#endif
845    }
846    old_code_ptr[1] = s->code_ptr - old_code_ptr;
847}
848
849static inline bool tcg_out_sti(TCGContext *s, TCGType type, TCGArg val,
850                               TCGReg base, intptr_t ofs)
851{
852    return false;
853}
854
855/* Test if a constant matches the constraint. */
856static int tcg_target_const_match(tcg_target_long val, TCGType type,
857                                  const TCGArgConstraint *arg_ct)
858{
859    /* No need to return 0 or 1, 0 or != 0 is good enough. */
860    return arg_ct->ct & TCG_CT_CONST;
861}
862
863static void tcg_target_init(TCGContext *s)
864{
865#if defined(CONFIG_DEBUG_TCG_INTERPRETER)
866    const char *envval = getenv("DEBUG_TCG");
867    if (envval) {
868        qemu_set_log(strtol(envval, NULL, 0));
869    }
870#endif
871
872    /* The current code uses uint8_t for tcg operations. */
873    tcg_debug_assert(tcg_op_defs_max <= UINT8_MAX);
874
875    /* Registers available for 32 bit operations. */
876    tcg_target_available_regs[TCG_TYPE_I32] = BIT(TCG_TARGET_NB_REGS) - 1;
877    /* Registers available for 64 bit operations. */
878    tcg_target_available_regs[TCG_TYPE_I64] = BIT(TCG_TARGET_NB_REGS) - 1;
879    /* TODO: Which registers should be set here? */
880    tcg_target_call_clobber_regs = BIT(TCG_TARGET_NB_REGS) - 1;
881
882    s->reserved_regs = 0;
883    tcg_regset_set_reg(s->reserved_regs, TCG_REG_CALL_STACK);
884
885    /* We use negative offsets from "sp" so that we can distinguish
886       stores that might pretend to be call arguments.  */
887    tcg_set_frame(s, TCG_REG_CALL_STACK,
888                  -CPU_TEMP_BUF_NLONGS * sizeof(long),
889                  CPU_TEMP_BUF_NLONGS * sizeof(long));
890}
891
892/* Generate global QEMU prologue and epilogue code. */
893static inline void tcg_target_qemu_prologue(TCGContext *s)
894{
895}
896