tcg/tci/tcg-target.c.inc

   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 static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
  41 {
  42     switch (op) {
  43     case INDEX_op_ld8u_i32:
  44     case INDEX_op_ld8s_i32:
  45     case INDEX_op_ld16u_i32:
  46     case INDEX_op_ld16s_i32:
  47     case INDEX_op_ld_i32:
  48     case INDEX_op_ld8u_i64:
  49     case INDEX_op_ld8s_i64:
  50     case INDEX_op_ld16u_i64:
  51     case INDEX_op_ld16s_i64:
  52     case INDEX_op_ld32u_i64:
  53     case INDEX_op_ld32s_i64:
  54     case INDEX_op_ld_i64:
  55     case INDEX_op_not_i32:
  56     case INDEX_op_not_i64:
  57     case INDEX_op_neg_i32:
  58     case INDEX_op_neg_i64:
  59     case INDEX_op_ext8s_i32:
  60     case INDEX_op_ext8s_i64:
  61     case INDEX_op_ext16s_i32:
  62     case INDEX_op_ext16s_i64:
  63     case INDEX_op_ext8u_i32:
  64     case INDEX_op_ext8u_i64:
  65     case INDEX_op_ext16u_i32:
  66     case INDEX_op_ext16u_i64:
  67     case INDEX_op_ext32s_i64:
  68     case INDEX_op_ext32u_i64:
  69     case INDEX_op_ext_i32_i64:
  70     case INDEX_op_extu_i32_i64:
  71     case INDEX_op_bswap16_i32:
  72     case INDEX_op_bswap16_i64:
  73     case INDEX_op_bswap32_i32:
  74     case INDEX_op_bswap32_i64:
  75     case INDEX_op_bswap64_i64:
  76         return C_O1_I1(r, r);
  77
  78     case INDEX_op_st8_i32:
  79     case INDEX_op_st16_i32:
  80     case INDEX_op_st_i32:
  81     case INDEX_op_st8_i64:
  82     case INDEX_op_st16_i64:
  83     case INDEX_op_st32_i64:
  84     case INDEX_op_st_i64:
  85         return C_O0_I2(r, r);
  86
  87     case INDEX_op_div_i32:
  88     case INDEX_op_div_i64:
  89     case INDEX_op_divu_i32:
  90     case INDEX_op_divu_i64:
  91     case INDEX_op_rem_i32:
  92     case INDEX_op_rem_i64:
  93     case INDEX_op_remu_i32:
  94     case INDEX_op_remu_i64:
  95     case INDEX_op_add_i32:
  96     case INDEX_op_add_i64:
  97     case INDEX_op_sub_i32:
  98     case INDEX_op_sub_i64:
  99     case INDEX_op_mul_i32:
 100     case INDEX_op_mul_i64:
 101     case INDEX_op_and_i32:
 102     case INDEX_op_and_i64:
 103     case INDEX_op_andc_i32:
 104     case INDEX_op_andc_i64:
 105     case INDEX_op_eqv_i32:
 106     case INDEX_op_eqv_i64:
 107     case INDEX_op_nand_i32:
 108     case INDEX_op_nand_i64:
 109     case INDEX_op_nor_i32:
 110     case INDEX_op_nor_i64:
 111     case INDEX_op_or_i32:
 112     case INDEX_op_or_i64:
 113     case INDEX_op_orc_i32:
 114     case INDEX_op_orc_i64:
 115     case INDEX_op_xor_i32:
 116     case INDEX_op_xor_i64:
 117     case INDEX_op_shl_i32:
 118     case INDEX_op_shl_i64:
 119     case INDEX_op_shr_i32:
 120     case INDEX_op_shr_i64:
 121     case INDEX_op_sar_i32:
 122     case INDEX_op_sar_i64:
 123     case INDEX_op_rotl_i32:
 124     case INDEX_op_rotl_i64:
 125     case INDEX_op_rotr_i32:
 126     case INDEX_op_rotr_i64:
 127     case INDEX_op_setcond_i32:
 128     case INDEX_op_setcond_i64:
 129     case INDEX_op_deposit_i32:
 130     case INDEX_op_deposit_i64:
 131         return C_O1_I2(r, r, r);
 132
 133     case INDEX_op_brcond_i32:
 134     case INDEX_op_brcond_i64:
 135         return C_O0_I2(r, r);
 136
 137 #if TCG_TARGET_REG_BITS == 32
 138     /* TODO: Support R, R, R, R, RI, RI? Will it be faster? */
 139     case INDEX_op_add2_i32:
 140     case INDEX_op_sub2_i32:
 141         return C_O2_I4(r, r, r, r, r, r);
 142     case INDEX_op_brcond2_i32:
 143         return C_O0_I4(r, r, r, r);
 144     case INDEX_op_mulu2_i32:
 145         return C_O2_I2(r, r, r, r);
 146     case INDEX_op_setcond2_i32:
 147         return C_O1_I4(r, r, r, r, r);
 148 #endif
 149
 150     case INDEX_op_qemu_ld_i32:
 151         return (TARGET_LONG_BITS <= TCG_TARGET_REG_BITS
 152                 ? C_O1_I1(r, r)
 153                 : C_O1_I2(r, r, r));
 154     case INDEX_op_qemu_ld_i64:
 155         return (TCG_TARGET_REG_BITS == 64 ? C_O1_I1(r, r)
 156                 : TARGET_LONG_BITS <= TCG_TARGET_REG_BITS ? C_O2_I1(r, r, r)
 157                 : C_O2_I2(r, r, r, r));
 158     case INDEX_op_qemu_st_i32:
 159         return (TARGET_LONG_BITS <= TCG_TARGET_REG_BITS
 160                 ? C_O0_I2(r, r)
 161                 : C_O0_I3(r, r, r));
 162     case INDEX_op_qemu_st_i64:
 163         return (TCG_TARGET_REG_BITS == 64 ? C_O0_I2(r, r)
 164                 : TARGET_LONG_BITS <= TCG_TARGET_REG_BITS ? C_O0_I3(r, r, r)
 165                 : C_O0_I4(r, r, r, r));
 166
 167     default:
 168         g_assert_not_reached();
 169     }
 170 }
 171
 172 static const int tcg_target_reg_alloc_order[] = {
 173     TCG_REG_R0,
 174     TCG_REG_R1,
 175     TCG_REG_R2,
 176     TCG_REG_R3,
 177     TCG_REG_R4,
 178     TCG_REG_R5,
 179     TCG_REG_R6,
 180     TCG_REG_R7,
 181     TCG_REG_R8,
 182     TCG_REG_R9,
 183     TCG_REG_R10,
 184     TCG_REG_R11,
 185     TCG_REG_R12,
 186     TCG_REG_R13,
 187     TCG_REG_R14,
 188     TCG_REG_R15,
 189 };
 190
 191 #if MAX_OPC_PARAM_IARGS != 6
 192 # error Fix needed, number of supported input arguments changed!
 193 #endif
 194
 195 static const int tcg_target_call_iarg_regs[] = {
 196     TCG_REG_R0,
 197     TCG_REG_R1,
 198     TCG_REG_R2,
 199     TCG_REG_R3,
 200     TCG_REG_R4,
 201     TCG_REG_R5,
 202 #if TCG_TARGET_REG_BITS == 32
 203     /* 32 bit hosts need 2 * MAX_OPC_PARAM_IARGS registers. */
 204     TCG_REG_R6,
 205     TCG_REG_R7,
 206     TCG_REG_R8,
 207     TCG_REG_R9,
 208     TCG_REG_R10,
 209     TCG_REG_R11,
 210 #endif
 211 };
 212
 213 static const int tcg_target_call_oarg_regs[] = {
 214     TCG_REG_R0,
 215 #if TCG_TARGET_REG_BITS == 32
 216     TCG_REG_R1
 217 #endif
 218 };
 219
 220 #ifdef CONFIG_DEBUG_TCG
 221 static const char *const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
 222     "r00",
 223     "r01",
 224     "r02",
 225     "r03",
 226     "r04",
 227     "r05",
 228     "r06",
 229     "r07",
 230     "r08",
 231     "r09",
 232     "r10",
 233     "r11",
 234     "r12",
 235     "r13",
 236     "r14",
 237     "r15",
 238 };
 239 #endif
 240
 241 static bool patch_reloc(tcg_insn_unit *code_ptr, int type,
 242                         intptr_t value, intptr_t addend)
 243 {
 244     /* tcg_out_reloc always uses the same type, addend. */
 245     tcg_debug_assert(type == sizeof(tcg_target_long));
 246     tcg_debug_assert(addend == 0);
 247     tcg_debug_assert(value != 0);
 248     if (TCG_TARGET_REG_BITS == 32) {
 249         tcg_patch32(code_ptr, value);
 250     } else {
 251         tcg_patch64(code_ptr, value);
 252     }
 253     return true;
 254 }
 255
 256 /* Write value (native size). */
 257 static void tcg_out_i(TCGContext *s, tcg_target_ulong v)
 258 {
 259     if (TCG_TARGET_REG_BITS == 32) {
 260         tcg_out32(s, v);
 261     } else {
 262         tcg_out64(s, v);
 263     }
 264 }
 265
 266 /* Write opcode. */
 267 static void tcg_out_op_t(TCGContext *s, TCGOpcode op)
 268 {
 269     tcg_out8(s, op);
 270     tcg_out8(s, 0);
 271 }
 272
 273 /* Write register. */
 274 static void tcg_out_r(TCGContext *s, TCGArg t0)
 275 {
 276     tcg_debug_assert(t0 < TCG_TARGET_NB_REGS);
 277     tcg_out8(s, t0);
 278 }
 279
 280 /* Write label. */
 281 static void tci_out_label(TCGContext *s, TCGLabel *label)
 282 {
 283     if (label->has_value) {
 284         tcg_out_i(s, label->u.value);
 285         tcg_debug_assert(label->u.value);
 286     } else {
 287         tcg_out_reloc(s, s->code_ptr, sizeof(tcg_target_ulong), label, 0);
 288         s->code_ptr += sizeof(tcg_target_ulong);
 289     }
 290 }
 291
 292 static void stack_bounds_check(TCGReg base, target_long offset)
 293 {
 294     if (base == TCG_REG_CALL_STACK) {
 295         tcg_debug_assert(offset < 0);
 296         tcg_debug_assert(offset >= -(CPU_TEMP_BUF_NLONGS * sizeof(long)));
 297     }
 298 }
 299
 300 static void tcg_out_op_l(TCGContext *s, TCGOpcode op, TCGLabel *l0)
 301 {
 302     uint8_t *old_code_ptr = s->code_ptr;
 303
 304     tcg_out_op_t(s, op);
 305     tci_out_label(s, l0);
 306
 307     old_code_ptr[1] = s->code_ptr - old_code_ptr;
 308 }
 309
 310 static void tcg_out_op_p(TCGContext *s, TCGOpcode op, void *p0)
 311 {
 312     uint8_t *old_code_ptr = s->code_ptr;
 313
 314     tcg_out_op_t(s, op);
 315     tcg_out_i(s, (uintptr_t)p0);
 316
 317     old_code_ptr[1] = s->code_ptr - old_code_ptr;
 318 }
 319
 320 static void tcg_out_op_rr(TCGContext *s, TCGOpcode op, TCGReg r0, TCGReg r1)
 321 {
 322     uint8_t *old_code_ptr = s->code_ptr;
 323
 324     tcg_out_op_t(s, op);
 325     tcg_out_r(s, r0);
 326     tcg_out_r(s, r1);
 327
 328     old_code_ptr[1] = s->code_ptr - old_code_ptr;
 329 }
 330
 331 static void tcg_out_op_rrr(TCGContext *s, TCGOpcode op,
 332                            TCGReg r0, TCGReg r1, TCGReg r2)
 333 {
 334     uint8_t *old_code_ptr = s->code_ptr;
 335
 336     tcg_out_op_t(s, op);
 337     tcg_out_r(s, r0);
 338     tcg_out_r(s, r1);
 339     tcg_out_r(s, r2);
 340
 341     old_code_ptr[1] = s->code_ptr - old_code_ptr;
 342 }
 343
 344 static void tcg_out_op_rrs(TCGContext *s, TCGOpcode op,
 345                            TCGReg r0, TCGReg r1, intptr_t i2)
 346 {
 347     uint8_t *old_code_ptr = s->code_ptr;
 348
 349     tcg_out_op_t(s, op);
 350     tcg_out_r(s, r0);
 351     tcg_out_r(s, r1);
 352     tcg_debug_assert(i2 == (int32_t)i2);
 353     tcg_out32(s, i2);
 354
 355     old_code_ptr[1] = s->code_ptr - old_code_ptr;
 356 }
 357
 358 static void tcg_out_op_rrrc(TCGContext *s, TCGOpcode op,
 359                             TCGReg r0, TCGReg r1, TCGReg r2, TCGCond c3)
 360 {
 361     uint8_t *old_code_ptr = s->code_ptr;
 362
 363     tcg_out_op_t(s, op);
 364     tcg_out_r(s, r0);
 365     tcg_out_r(s, r1);
 366     tcg_out_r(s, r2);
 367     tcg_out8(s, c3);
 368
 369     old_code_ptr[1] = s->code_ptr - old_code_ptr;
 370 }
 371
 372 #if TCG_TARGET_REG_BITS == 32
 373 static void tcg_out_op_rrrrrc(TCGContext *s, TCGOpcode op,
 374                               TCGReg r0, TCGReg r1, TCGReg r2,
 375                               TCGReg r3, TCGReg r4, TCGCond c5)
 376 {
 377     uint8_t *old_code_ptr = s->code_ptr;
 378
 379     tcg_out_op_t(s, op);
 380     tcg_out_r(s, r0);
 381     tcg_out_r(s, r1);
 382     tcg_out_r(s, r2);
 383     tcg_out_r(s, r3);
 384     tcg_out_r(s, r4);
 385     tcg_out8(s, c5);
 386
 387     old_code_ptr[1] = s->code_ptr - old_code_ptr;
 388 }
 389 #endif
 390
 391 static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg val, TCGReg base,
 392                        intptr_t offset)
 393 {
 394     stack_bounds_check(base, offset);
 395     switch (type) {
 396     case TCG_TYPE_I32:
 397         tcg_out_op_rrs(s, INDEX_op_ld_i32, val, base, offset);
 398         break;
 399 #if TCG_TARGET_REG_BITS == 64
 400     case TCG_TYPE_I64:
 401         tcg_out_op_rrs(s, INDEX_op_ld_i64, val, base, offset);
 402         break;
 403 #endif
 404     default:
 405         g_assert_not_reached();
 406     }
 407 }
 408
 409 static bool tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg)
 410 {
 411     switch (type) {
 412     case TCG_TYPE_I32:
 413         tcg_out_op_rr(s, INDEX_op_mov_i32, ret, arg);
 414         break;
 415 #if TCG_TARGET_REG_BITS == 64
 416     case TCG_TYPE_I64:
 417         tcg_out_op_rr(s, INDEX_op_mov_i64, ret, arg);
 418         break;
 419 #endif
 420     default:
 421         g_assert_not_reached();
 422     }
 423     return true;
 424 }
 425
 426 static void tcg_out_movi(TCGContext *s, TCGType type,
 427                          TCGReg t0, tcg_target_long arg)
 428 {
 429     uint8_t *old_code_ptr = s->code_ptr;
 430     uint32_t arg32 = arg;
 431     if (type == TCG_TYPE_I32 || arg == arg32) {
 432         tcg_out_op_t(s, INDEX_op_tci_movi_i32);
 433         tcg_out_r(s, t0);
 434         tcg_out32(s, arg32);
 435     } else {
 436         tcg_debug_assert(type == TCG_TYPE_I64);
 437 #if TCG_TARGET_REG_BITS == 64
 438         tcg_out_op_t(s, INDEX_op_tci_movi_i64);
 439         tcg_out_r(s, t0);
 440         tcg_out64(s, arg);
 441 #else
 442         TODO();
 443 #endif
 444     }
 445     old_code_ptr[1] = s->code_ptr - old_code_ptr;
 446 }
 447
 448 static inline void tcg_out_call(TCGContext *s, const tcg_insn_unit *arg)
 449 {
 450     uint8_t *old_code_ptr = s->code_ptr;
 451     tcg_out_op_t(s, INDEX_op_call);
 452     tcg_out_i(s, (uintptr_t)arg);
 453     old_code_ptr[1] = s->code_ptr - old_code_ptr;
 454 }
 455
 456 #if TCG_TARGET_REG_BITS == 64
 457 # define CASE_32_64(x) \
 458         case glue(glue(INDEX_op_, x), _i64): \
 459         case glue(glue(INDEX_op_, x), _i32):
 460 # define CASE_64(x) \
 461         case glue(glue(INDEX_op_, x), _i64):
 462 #else
 463 # define CASE_32_64(x) \
 464         case glue(glue(INDEX_op_, x), _i32):
 465 # define CASE_64(x)
 466 #endif
 467
 468 static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args,
 469                        const int *const_args)
 470 {
 471     uint8_t *old_code_ptr = s->code_ptr;
 472
 473     switch (opc) {
 474     case INDEX_op_exit_tb:
 475         tcg_out_op_p(s, opc, (void *)args[0]);
 476         break;
 477
 478     case INDEX_op_goto_tb:
 479         tcg_debug_assert(s->tb_jmp_insn_offset == 0);
 480         /* indirect jump method. */
 481         tcg_out_op_p(s, opc, s->tb_jmp_target_addr + args[0]);
 482         set_jmp_reset_offset(s, args[0]);
 483         break;
 484
 485     case INDEX_op_br:
 486         tcg_out_op_l(s, opc, arg_label(args[0]));
 487         break;
 488
 489     CASE_32_64(setcond)
 490         tcg_out_op_rrrc(s, opc, args[0], args[1], args[2], args[3]);
 491         break;
 492
 493 #if TCG_TARGET_REG_BITS == 32
 494     case INDEX_op_setcond2_i32:
 495         tcg_out_op_rrrrrc(s, opc, args[0], args[1], args[2],
 496                           args[3], args[4], args[5]);
 497         break;
 498 #endif
 499
 500     CASE_32_64(ld8u)
 501     CASE_32_64(ld8s)
 502     CASE_32_64(ld16u)
 503     CASE_32_64(ld16s)
 504     case INDEX_op_ld_i32:
 505     CASE_64(ld32u)
 506     CASE_64(ld32s)
 507     CASE_64(ld)
 508     CASE_32_64(st8)
 509     CASE_32_64(st16)
 510     case INDEX_op_st_i32:
 511     CASE_64(st32)
 512     CASE_64(st)
 513         stack_bounds_check(args[1], args[2]);
 514         tcg_out_op_rrs(s, opc, args[0], args[1], args[2]);
 515         break;
 516
 517     CASE_32_64(add)
 518     CASE_32_64(sub)
 519     CASE_32_64(mul)
 520     CASE_32_64(and)
 521     CASE_32_64(or)
 522     CASE_32_64(xor)
 523     CASE_32_64(andc)     /* Optional (TCG_TARGET_HAS_andc_*). */
 524     CASE_32_64(orc)      /* Optional (TCG_TARGET_HAS_orc_*). */
 525     CASE_32_64(eqv)      /* Optional (TCG_TARGET_HAS_eqv_*). */
 526     CASE_32_64(nand)     /* Optional (TCG_TARGET_HAS_nand_*). */
 527     CASE_32_64(nor)      /* Optional (TCG_TARGET_HAS_nor_*). */
 528     CASE_32_64(shl)
 529     CASE_32_64(shr)
 530     CASE_32_64(sar)
 531     CASE_32_64(rotl)     /* Optional (TCG_TARGET_HAS_rot_*). */
 532     CASE_32_64(rotr)     /* Optional (TCG_TARGET_HAS_rot_*). */
 533     CASE_32_64(div)      /* Optional (TCG_TARGET_HAS_div_*). */
 534     CASE_32_64(divu)     /* Optional (TCG_TARGET_HAS_div_*). */
 535     CASE_32_64(rem)      /* Optional (TCG_TARGET_HAS_div_*). */
 536     CASE_32_64(remu)     /* Optional (TCG_TARGET_HAS_div_*). */
 537         tcg_out_op_rrr(s, opc, args[0], args[1], args[2]);
 538         break;
 539
 540     CASE_32_64(deposit)  /* Optional (TCG_TARGET_HAS_deposit_*). */
 541         tcg_out_op_t(s, opc);
 542         {
 543             TCGArg pos = args[3], len = args[4];
 544             TCGArg max = opc == INDEX_op_deposit_i32 ? 32 : 64;
 545
 546             tcg_debug_assert(pos < max);
 547             tcg_debug_assert(pos + len <= max);
 548
 549             tcg_out_r(s, args[0]);
 550             tcg_out_r(s, args[1]);
 551             tcg_out_r(s, args[2]);
 552             tcg_out8(s, pos);
 553             tcg_out8(s, len);
 554         }
 555         old_code_ptr[1] = s->code_ptr - old_code_ptr;
 556         break;
 557
 558     CASE_32_64(brcond)
 559         tcg_out_op_t(s, opc);
 560         tcg_out_r(s, args[0]);
 561         tcg_out_r(s, args[1]);
 562         tcg_out8(s, args[2]);           /* condition */
 563         tci_out_label(s, arg_label(args[3]));
 564         old_code_ptr[1] = s->code_ptr - old_code_ptr;
 565         break;
 566
 567     CASE_32_64(neg)      /* Optional (TCG_TARGET_HAS_neg_*). */
 568     CASE_32_64(not)      /* Optional (TCG_TARGET_HAS_not_*). */
 569     CASE_32_64(ext8s)    /* Optional (TCG_TARGET_HAS_ext8s_*). */
 570     CASE_32_64(ext8u)    /* Optional (TCG_TARGET_HAS_ext8u_*). */
 571     CASE_32_64(ext16s)   /* Optional (TCG_TARGET_HAS_ext16s_*). */
 572     CASE_32_64(ext16u)   /* Optional (TCG_TARGET_HAS_ext16u_*). */
 573     CASE_64(ext32s)      /* Optional (TCG_TARGET_HAS_ext32s_i64). */
 574     CASE_64(ext32u)      /* Optional (TCG_TARGET_HAS_ext32u_i64). */
 575     CASE_64(ext_i32)
 576     CASE_64(extu_i32)
 577     CASE_32_64(bswap16)  /* Optional (TCG_TARGET_HAS_bswap16_*). */
 578     CASE_32_64(bswap32)  /* Optional (TCG_TARGET_HAS_bswap32_*). */
 579     CASE_64(bswap64)     /* Optional (TCG_TARGET_HAS_bswap64_i64). */
 580         tcg_out_op_rr(s, opc, args[0], args[1]);
 581         break;
 582
 583 #if TCG_TARGET_REG_BITS == 32
 584     case INDEX_op_add2_i32:
 585     case INDEX_op_sub2_i32:
 586         tcg_out_op_t(s, opc);
 587         tcg_out_r(s, args[0]);
 588         tcg_out_r(s, args[1]);
 589         tcg_out_r(s, args[2]);
 590         tcg_out_r(s, args[3]);
 591         tcg_out_r(s, args[4]);
 592         tcg_out_r(s, args[5]);
 593         old_code_ptr[1] = s->code_ptr - old_code_ptr;
 594         break;
 595     case INDEX_op_brcond2_i32:
 596         tcg_out_op_t(s, opc);
 597         tcg_out_r(s, args[0]);
 598         tcg_out_r(s, args[1]);
 599         tcg_out_r(s, args[2]);
 600         tcg_out_r(s, args[3]);
 601         tcg_out8(s, args[4]);           /* condition */
 602         tci_out_label(s, arg_label(args[5]));
 603         old_code_ptr[1] = s->code_ptr - old_code_ptr;
 604         break;
 605     case INDEX_op_mulu2_i32:
 606         tcg_out_op_t(s, opc);
 607         tcg_out_r(s, args[0]);
 608         tcg_out_r(s, args[1]);
 609         tcg_out_r(s, args[2]);
 610         tcg_out_r(s, args[3]);
 611         old_code_ptr[1] = s->code_ptr - old_code_ptr;
 612         break;
 613 #endif
 614
 615     case INDEX_op_qemu_ld_i32:
 616     case INDEX_op_qemu_st_i32:
 617         tcg_out_op_t(s, opc);
 618         tcg_out_r(s, *args++);
 619         tcg_out_r(s, *args++);
 620         if (TARGET_LONG_BITS > TCG_TARGET_REG_BITS) {
 621             tcg_out_r(s, *args++);
 622         }
 623         tcg_out32(s, *args++);
 624         old_code_ptr[1] = s->code_ptr - old_code_ptr;
 625         break;
 626
 627     case INDEX_op_qemu_ld_i64:
 628     case INDEX_op_qemu_st_i64:
 629         tcg_out_op_t(s, opc);
 630         tcg_out_r(s, *args++);
 631         if (TCG_TARGET_REG_BITS == 32) {
 632             tcg_out_r(s, *args++);
 633         }
 634         tcg_out_r(s, *args++);
 635         if (TARGET_LONG_BITS > TCG_TARGET_REG_BITS) {
 636             tcg_out_r(s, *args++);
 637         }
 638         tcg_out32(s, *args++);
 639         old_code_ptr[1] = s->code_ptr - old_code_ptr;
 640         break;
 641
 642     case INDEX_op_mb:
 643         tcg_out_op_t(s, opc);
 644         old_code_ptr[1] = s->code_ptr - old_code_ptr;
 645         break;
 646
 647     case INDEX_op_mov_i32:  /* Always emitted via tcg_out_mov.  */
 648     case INDEX_op_mov_i64:
 649     case INDEX_op_call:     /* Always emitted via tcg_out_call.  */
 650     default:
 651         tcg_abort();
 652     }
 653 }
 654
 655 static void tcg_out_st(TCGContext *s, TCGType type, TCGReg val, TCGReg base,
 656                        intptr_t offset)
 657 {
 658     stack_bounds_check(base, offset);
 659     switch (type) {
 660     case TCG_TYPE_I32:
 661         tcg_out_op_rrs(s, INDEX_op_st_i32, val, base, offset);
 662         break;
 663 #if TCG_TARGET_REG_BITS == 64
 664     case TCG_TYPE_I64:
 665         tcg_out_op_rrs(s, INDEX_op_st_i64, val, base, offset);
 666         break;
 667 #endif
 668     default:
 669         g_assert_not_reached();
 670     }
 671 }
 672
 673 static inline bool tcg_out_sti(TCGContext *s, TCGType type, TCGArg val,
 674                                TCGReg base, intptr_t ofs)
 675 {
 676     return false;
 677 }
 678
 679 /* Test if a constant matches the constraint. */
 680 static int tcg_target_const_match(tcg_target_long val, TCGType type,
 681                                   const TCGArgConstraint *arg_ct)
 682 {
 683     /* No need to return 0 or 1, 0 or != 0 is good enough. */
 684     return arg_ct->ct & TCG_CT_CONST;
 685 }
 686
 687 static void tcg_target_init(TCGContext *s)
 688 {
 689 #if defined(CONFIG_DEBUG_TCG_INTERPRETER)
 690     const char *envval = getenv("DEBUG_TCG");
 691     if (envval) {
 692         qemu_set_log(strtol(envval, NULL, 0));
 693     }
 694 #endif
 695
 696     /* The current code uses uint8_t for tcg operations. */
 697     tcg_debug_assert(tcg_op_defs_max <= UINT8_MAX);
 698
 699     /* Registers available for 32 bit operations. */
 700     tcg_target_available_regs[TCG_TYPE_I32] = BIT(TCG_TARGET_NB_REGS) - 1;
 701     /* Registers available for 64 bit operations. */
 702     tcg_target_available_regs[TCG_TYPE_I64] = BIT(TCG_TARGET_NB_REGS) - 1;
 703     /* TODO: Which registers should be set here? */
 704     tcg_target_call_clobber_regs = BIT(TCG_TARGET_NB_REGS) - 1;
 705
 706     s->reserved_regs = 0;
 707     tcg_regset_set_reg(s->reserved_regs, TCG_REG_CALL_STACK);
 708
 709     /* We use negative offsets from "sp" so that we can distinguish
 710        stores that might pretend to be call arguments.  */
 711     tcg_set_frame(s, TCG_REG_CALL_STACK,
 712                   -CPU_TEMP_BUF_NLONGS * sizeof(long),
 713                   CPU_TEMP_BUF_NLONGS * sizeof(long));
 714 }
 715
 716 /* Generate global QEMU prologue and epilogue code. */
 717 static inline void tcg_target_qemu_prologue(TCGContext *s)
 718 {
 719 }