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 #include "../tcg-pool.c.inc"
  26
  27 static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
  28 {
  29     switch (op) {
  30     case INDEX_op_goto_ptr:
  31         return C_O0_I1(r);
  32
  33     case INDEX_op_ld8u_i32:
  34     case INDEX_op_ld8s_i32:
  35     case INDEX_op_ld16u_i32:
  36     case INDEX_op_ld16s_i32:
  37     case INDEX_op_ld_i32:
  38     case INDEX_op_ld8u_i64:
  39     case INDEX_op_ld8s_i64:
  40     case INDEX_op_ld16u_i64:
  41     case INDEX_op_ld16s_i64:
  42     case INDEX_op_ld32u_i64:
  43     case INDEX_op_ld32s_i64:
  44     case INDEX_op_ld_i64:
  45     case INDEX_op_not_i32:
  46     case INDEX_op_not_i64:
  47     case INDEX_op_neg_i32:
  48     case INDEX_op_neg_i64:
  49     case INDEX_op_ext8s_i32:
  50     case INDEX_op_ext8s_i64:
  51     case INDEX_op_ext16s_i32:
  52     case INDEX_op_ext16s_i64:
  53     case INDEX_op_ext8u_i32:
  54     case INDEX_op_ext8u_i64:
  55     case INDEX_op_ext16u_i32:
  56     case INDEX_op_ext16u_i64:
  57     case INDEX_op_ext32s_i64:
  58     case INDEX_op_ext32u_i64:
  59     case INDEX_op_ext_i32_i64:
  60     case INDEX_op_extu_i32_i64:
  61     case INDEX_op_bswap16_i32:
  62     case INDEX_op_bswap16_i64:
  63     case INDEX_op_bswap32_i32:
  64     case INDEX_op_bswap32_i64:
  65     case INDEX_op_bswap64_i64:
  66     case INDEX_op_extract_i32:
  67     case INDEX_op_extract_i64:
  68     case INDEX_op_sextract_i32:
  69     case INDEX_op_sextract_i64:
  70     case INDEX_op_ctpop_i32:
  71     case INDEX_op_ctpop_i64:
  72         return C_O1_I1(r, r);
  73
  74     case INDEX_op_st8_i32:
  75     case INDEX_op_st16_i32:
  76     case INDEX_op_st_i32:
  77     case INDEX_op_st8_i64:
  78     case INDEX_op_st16_i64:
  79     case INDEX_op_st32_i64:
  80     case INDEX_op_st_i64:
  81         return C_O0_I2(r, r);
  82
  83     case INDEX_op_div_i32:
  84     case INDEX_op_div_i64:
  85     case INDEX_op_divu_i32:
  86     case INDEX_op_divu_i64:
  87     case INDEX_op_rem_i32:
  88     case INDEX_op_rem_i64:
  89     case INDEX_op_remu_i32:
  90     case INDEX_op_remu_i64:
  91     case INDEX_op_add_i32:
  92     case INDEX_op_add_i64:
  93     case INDEX_op_sub_i32:
  94     case INDEX_op_sub_i64:
  95     case INDEX_op_mul_i32:
  96     case INDEX_op_mul_i64:
  97     case INDEX_op_and_i32:
  98     case INDEX_op_and_i64:
  99     case INDEX_op_andc_i32:
 100     case INDEX_op_andc_i64:
 101     case INDEX_op_eqv_i32:
 102     case INDEX_op_eqv_i64:
 103     case INDEX_op_nand_i32:
 104     case INDEX_op_nand_i64:
 105     case INDEX_op_nor_i32:
 106     case INDEX_op_nor_i64:
 107     case INDEX_op_or_i32:
 108     case INDEX_op_or_i64:
 109     case INDEX_op_orc_i32:
 110     case INDEX_op_orc_i64:
 111     case INDEX_op_xor_i32:
 112     case INDEX_op_xor_i64:
 113     case INDEX_op_shl_i32:
 114     case INDEX_op_shl_i64:
 115     case INDEX_op_shr_i32:
 116     case INDEX_op_shr_i64:
 117     case INDEX_op_sar_i32:
 118     case INDEX_op_sar_i64:
 119     case INDEX_op_rotl_i32:
 120     case INDEX_op_rotl_i64:
 121     case INDEX_op_rotr_i32:
 122     case INDEX_op_rotr_i64:
 123     case INDEX_op_setcond_i32:
 124     case INDEX_op_setcond_i64:
 125     case INDEX_op_deposit_i32:
 126     case INDEX_op_deposit_i64:
 127     case INDEX_op_clz_i32:
 128     case INDEX_op_clz_i64:
 129     case INDEX_op_ctz_i32:
 130     case INDEX_op_ctz_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 #endif
 145
 146     case INDEX_op_mulu2_i32:
 147     case INDEX_op_mulu2_i64:
 148     case INDEX_op_muls2_i32:
 149     case INDEX_op_muls2_i64:
 150         return C_O2_I2(r, r, r, r);
 151
 152     case INDEX_op_movcond_i32:
 153     case INDEX_op_movcond_i64:
 154     case INDEX_op_setcond2_i32:
 155         return C_O1_I4(r, r, r, r, r);
 156
 157     case INDEX_op_qemu_ld_i32:
 158         return (TARGET_LONG_BITS <= TCG_TARGET_REG_BITS
 159                 ? C_O1_I1(r, r)
 160                 : C_O1_I2(r, r, r));
 161     case INDEX_op_qemu_ld_i64:
 162         return (TCG_TARGET_REG_BITS == 64 ? C_O1_I1(r, r)
 163                 : TARGET_LONG_BITS <= TCG_TARGET_REG_BITS ? C_O2_I1(r, r, r)
 164                 : C_O2_I2(r, r, r, r));
 165     case INDEX_op_qemu_st_i32:
 166         return (TARGET_LONG_BITS <= TCG_TARGET_REG_BITS
 167                 ? C_O0_I2(r, r)
 168                 : C_O0_I3(r, r, r));
 169     case INDEX_op_qemu_st_i64:
 170         return (TCG_TARGET_REG_BITS == 64 ? C_O0_I2(r, r)
 171                 : TARGET_LONG_BITS <= TCG_TARGET_REG_BITS ? C_O0_I3(r, r, r)
 172                 : C_O0_I4(r, r, r, r));
 173
 174     default:
 175         g_assert_not_reached();
 176     }
 177 }
 178
 179 static const int tcg_target_reg_alloc_order[] = {
 180     TCG_REG_R2,
 181     TCG_REG_R3,
 182     TCG_REG_R4,
 183     TCG_REG_R5,
 184     TCG_REG_R6,
 185     TCG_REG_R7,
 186     TCG_REG_R8,
 187     TCG_REG_R9,
 188     TCG_REG_R10,
 189     TCG_REG_R11,
 190     TCG_REG_R12,
 191     TCG_REG_R13,
 192     TCG_REG_R14,
 193     TCG_REG_R15,
 194     TCG_REG_R1,
 195     TCG_REG_R0,
 196 };
 197
 198 #if MAX_OPC_PARAM_IARGS != 6
 199 # error Fix needed, number of supported input arguments changed!
 200 #endif
 201
 202 /* No call arguments via registers.  All will be stored on the "stack". */
 203 static const int tcg_target_call_iarg_regs[] = { };
 204
 205 static const int tcg_target_call_oarg_regs[] = {
 206     TCG_REG_R0,
 207 #if TCG_TARGET_REG_BITS == 32
 208     TCG_REG_R1
 209 #endif
 210 };
 211
 212 #ifdef CONFIG_DEBUG_TCG
 213 static const char *const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
 214     "r00",
 215     "r01",
 216     "r02",
 217     "r03",
 218     "r04",
 219     "r05",
 220     "r06",
 221     "r07",
 222     "r08",
 223     "r09",
 224     "r10",
 225     "r11",
 226     "r12",
 227     "r13",
 228     "r14",
 229     "r15",
 230 };
 231 #endif
 232
 233 static bool patch_reloc(tcg_insn_unit *code_ptr, int type,
 234                         intptr_t value, intptr_t addend)
 235 {
 236     intptr_t diff = value - (intptr_t)(code_ptr + 1);
 237
 238     tcg_debug_assert(addend == 0);
 239     tcg_debug_assert(type == 20);
 240
 241     if (diff == sextract32(diff, 0, type)) {
 242         tcg_patch32(code_ptr, deposit32(*code_ptr, 32 - type, type, diff));
 243         return true;
 244     }
 245     return false;
 246 }
 247
 248 static void stack_bounds_check(TCGReg base, target_long offset)
 249 {
 250     if (base == TCG_REG_CALL_STACK) {
 251         tcg_debug_assert(offset >= 0);
 252         tcg_debug_assert(offset < (TCG_STATIC_CALL_ARGS_SIZE +
 253                                    TCG_STATIC_FRAME_SIZE));
 254     }
 255 }
 256
 257 static void tcg_out_op_l(TCGContext *s, TCGOpcode op, TCGLabel *l0)
 258 {
 259     tcg_insn_unit insn = 0;
 260
 261     tcg_out_reloc(s, s->code_ptr, 20, l0, 0);
 262     insn = deposit32(insn, 0, 8, op);
 263     tcg_out32(s, insn);
 264 }
 265
 266 static void tcg_out_op_p(TCGContext *s, TCGOpcode op, void *p0)
 267 {
 268     tcg_insn_unit insn = 0;
 269     intptr_t diff;
 270
 271     /* Special case for exit_tb: map null -> 0. */
 272     if (p0 == NULL) {
 273         diff = 0;
 274     } else {
 275         diff = p0 - (void *)(s->code_ptr + 1);
 276         tcg_debug_assert(diff != 0);
 277         if (diff != sextract32(diff, 0, 20)) {
 278             tcg_raise_tb_overflow(s);
 279         }
 280     }
 281     insn = deposit32(insn, 0, 8, op);
 282     insn = deposit32(insn, 12, 20, diff);
 283     tcg_out32(s, insn);
 284 }
 285
 286 static void tcg_out_op_r(TCGContext *s, TCGOpcode op, TCGReg r0)
 287 {
 288     tcg_insn_unit insn = 0;
 289
 290     insn = deposit32(insn, 0, 8, op);
 291     insn = deposit32(insn, 8, 4, r0);
 292     tcg_out32(s, insn);
 293 }
 294
 295 static void tcg_out_op_v(TCGContext *s, TCGOpcode op)
 296 {
 297     tcg_out32(s, (uint8_t)op);
 298 }
 299
 300 static void tcg_out_op_ri(TCGContext *s, TCGOpcode op, TCGReg r0, int32_t i1)
 301 {
 302     tcg_insn_unit insn = 0;
 303
 304     tcg_debug_assert(i1 == sextract32(i1, 0, 20));
 305     insn = deposit32(insn, 0, 8, op);
 306     insn = deposit32(insn, 8, 4, r0);
 307     insn = deposit32(insn, 12, 20, i1);
 308     tcg_out32(s, insn);
 309 }
 310
 311 static void tcg_out_op_rl(TCGContext *s, TCGOpcode op, TCGReg r0, TCGLabel *l1)
 312 {
 313     tcg_insn_unit insn = 0;
 314
 315     tcg_out_reloc(s, s->code_ptr, 20, l1, 0);
 316     insn = deposit32(insn, 0, 8, op);
 317     insn = deposit32(insn, 8, 4, r0);
 318     tcg_out32(s, insn);
 319 }
 320
 321 static void tcg_out_op_rr(TCGContext *s, TCGOpcode op, TCGReg r0, TCGReg r1)
 322 {
 323     tcg_insn_unit insn = 0;
 324
 325     insn = deposit32(insn, 0, 8, op);
 326     insn = deposit32(insn, 8, 4, r0);
 327     insn = deposit32(insn, 12, 4, r1);
 328     tcg_out32(s, insn);
 329 }
 330
 331 static void tcg_out_op_rrm(TCGContext *s, TCGOpcode op,
 332                            TCGReg r0, TCGReg r1, TCGArg m2)
 333 {
 334     tcg_insn_unit insn = 0;
 335
 336     tcg_debug_assert(m2 == extract32(m2, 0, 12));
 337     insn = deposit32(insn, 0, 8, op);
 338     insn = deposit32(insn, 8, 4, r0);
 339     insn = deposit32(insn, 12, 4, r1);
 340     insn = deposit32(insn, 20, 12, m2);
 341     tcg_out32(s, insn);
 342 }
 343
 344 static void tcg_out_op_rrr(TCGContext *s, TCGOpcode op,
 345                            TCGReg r0, TCGReg r1, TCGReg r2)
 346 {
 347     tcg_insn_unit insn = 0;
 348
 349     insn = deposit32(insn, 0, 8, op);
 350     insn = deposit32(insn, 8, 4, r0);
 351     insn = deposit32(insn, 12, 4, r1);
 352     insn = deposit32(insn, 16, 4, r2);
 353     tcg_out32(s, insn);
 354 }
 355
 356 static void tcg_out_op_rrs(TCGContext *s, TCGOpcode op,
 357                            TCGReg r0, TCGReg r1, intptr_t i2)
 358 {
 359     tcg_insn_unit insn = 0;
 360
 361     tcg_debug_assert(i2 == sextract32(i2, 0, 16));
 362     insn = deposit32(insn, 0, 8, op);
 363     insn = deposit32(insn, 8, 4, r0);
 364     insn = deposit32(insn, 12, 4, r1);
 365     insn = deposit32(insn, 16, 16, i2);
 366     tcg_out32(s, insn);
 367 }
 368
 369 static void tcg_out_op_rrbb(TCGContext *s, TCGOpcode op, TCGReg r0,
 370                             TCGReg r1, uint8_t b2, uint8_t b3)
 371 {
 372     tcg_insn_unit insn = 0;
 373
 374     tcg_debug_assert(b2 == extract32(b2, 0, 6));
 375     tcg_debug_assert(b3 == extract32(b3, 0, 6));
 376     insn = deposit32(insn, 0, 8, op);
 377     insn = deposit32(insn, 8, 4, r0);
 378     insn = deposit32(insn, 12, 4, r1);
 379     insn = deposit32(insn, 16, 6, b2);
 380     insn = deposit32(insn, 22, 6, b3);
 381     tcg_out32(s, insn);
 382 }
 383
 384 static void tcg_out_op_rrrc(TCGContext *s, TCGOpcode op,
 385                             TCGReg r0, TCGReg r1, TCGReg r2, TCGCond c3)
 386 {
 387     tcg_insn_unit insn = 0;
 388
 389     insn = deposit32(insn, 0, 8, op);
 390     insn = deposit32(insn, 8, 4, r0);
 391     insn = deposit32(insn, 12, 4, r1);
 392     insn = deposit32(insn, 16, 4, r2);
 393     insn = deposit32(insn, 20, 4, c3);
 394     tcg_out32(s, insn);
 395 }
 396
 397 static void tcg_out_op_rrrm(TCGContext *s, TCGOpcode op,
 398                             TCGReg r0, TCGReg r1, TCGReg r2, TCGArg m3)
 399 {
 400     tcg_insn_unit insn = 0;
 401
 402     tcg_debug_assert(m3 == extract32(m3, 0, 12));
 403     insn = deposit32(insn, 0, 8, op);
 404     insn = deposit32(insn, 8, 4, r0);
 405     insn = deposit32(insn, 12, 4, r1);
 406     insn = deposit32(insn, 16, 4, r2);
 407     insn = deposit32(insn, 20, 12, m3);
 408     tcg_out32(s, insn);
 409 }
 410
 411 static void tcg_out_op_rrrbb(TCGContext *s, TCGOpcode op, TCGReg r0,
 412                              TCGReg r1, TCGReg r2, uint8_t b3, uint8_t b4)
 413 {
 414     tcg_insn_unit insn = 0;
 415
 416     tcg_debug_assert(b3 == extract32(b3, 0, 6));
 417     tcg_debug_assert(b4 == extract32(b4, 0, 6));
 418     insn = deposit32(insn, 0, 8, op);
 419     insn = deposit32(insn, 8, 4, r0);
 420     insn = deposit32(insn, 12, 4, r1);
 421     insn = deposit32(insn, 16, 4, r2);
 422     insn = deposit32(insn, 20, 6, b3);
 423     insn = deposit32(insn, 26, 6, b4);
 424     tcg_out32(s, insn);
 425 }
 426
 427 static void tcg_out_op_rrrrr(TCGContext *s, TCGOpcode op, TCGReg r0,
 428                              TCGReg r1, TCGReg r2, TCGReg r3, TCGReg r4)
 429 {
 430     tcg_insn_unit insn = 0;
 431
 432     insn = deposit32(insn, 0, 8, op);
 433     insn = deposit32(insn, 8, 4, r0);
 434     insn = deposit32(insn, 12, 4, r1);
 435     insn = deposit32(insn, 16, 4, r2);
 436     insn = deposit32(insn, 20, 4, r3);
 437     insn = deposit32(insn, 24, 4, r4);
 438     tcg_out32(s, insn);
 439 }
 440
 441 static void tcg_out_op_rrrr(TCGContext *s, TCGOpcode op,
 442                             TCGReg r0, TCGReg r1, TCGReg r2, TCGReg r3)
 443 {
 444     tcg_insn_unit insn = 0;
 445
 446     insn = deposit32(insn, 0, 8, op);
 447     insn = deposit32(insn, 8, 4, r0);
 448     insn = deposit32(insn, 12, 4, r1);
 449     insn = deposit32(insn, 16, 4, r2);
 450     insn = deposit32(insn, 20, 4, r3);
 451     tcg_out32(s, insn);
 452 }
 453
 454 static void tcg_out_op_rrrrrc(TCGContext *s, TCGOpcode op,
 455                               TCGReg r0, TCGReg r1, TCGReg r2,
 456                               TCGReg r3, TCGReg r4, TCGCond c5)
 457 {
 458     tcg_insn_unit insn = 0;
 459
 460     insn = deposit32(insn, 0, 8, op);
 461     insn = deposit32(insn, 8, 4, r0);
 462     insn = deposit32(insn, 12, 4, r1);
 463     insn = deposit32(insn, 16, 4, r2);
 464     insn = deposit32(insn, 20, 4, r3);
 465     insn = deposit32(insn, 24, 4, r4);
 466     insn = deposit32(insn, 28, 4, c5);
 467     tcg_out32(s, insn);
 468 }
 469
 470 #if TCG_TARGET_REG_BITS == 32
 471 static void tcg_out_op_rrrrrr(TCGContext *s, TCGOpcode op,
 472                               TCGReg r0, TCGReg r1, TCGReg r2,
 473                               TCGReg r3, TCGReg r4, TCGReg r5)
 474 {
 475     tcg_insn_unit insn = 0;
 476
 477     insn = deposit32(insn, 0, 8, op);
 478     insn = deposit32(insn, 8, 4, r0);
 479     insn = deposit32(insn, 12, 4, r1);
 480     insn = deposit32(insn, 16, 4, r2);
 481     insn = deposit32(insn, 20, 4, r3);
 482     insn = deposit32(insn, 24, 4, r4);
 483     insn = deposit32(insn, 28, 4, r5);
 484     tcg_out32(s, insn);
 485 }
 486 #endif
 487
 488 static void tcg_out_ldst(TCGContext *s, TCGOpcode op, TCGReg val,
 489                          TCGReg base, intptr_t offset)
 490 {
 491     stack_bounds_check(base, offset);
 492     if (offset != sextract32(offset, 0, 16)) {
 493         tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_TMP, offset);
 494         tcg_out_op_rrr(s, (TCG_TARGET_REG_BITS == 32
 495                            ? INDEX_op_add_i32 : INDEX_op_add_i64),
 496                        TCG_REG_TMP, TCG_REG_TMP, base);
 497         base = TCG_REG_TMP;
 498         offset = 0;
 499     }
 500     tcg_out_op_rrs(s, op, val, base, offset);
 501 }
 502
 503 static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg val, TCGReg base,
 504                        intptr_t offset)
 505 {
 506     switch (type) {
 507     case TCG_TYPE_I32:
 508         tcg_out_ldst(s, INDEX_op_ld_i32, val, base, offset);
 509         break;
 510 #if TCG_TARGET_REG_BITS == 64
 511     case TCG_TYPE_I64:
 512         tcg_out_ldst(s, INDEX_op_ld_i64, val, base, offset);
 513         break;
 514 #endif
 515     default:
 516         g_assert_not_reached();
 517     }
 518 }
 519
 520 static bool tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg)
 521 {
 522     switch (type) {
 523     case TCG_TYPE_I32:
 524         tcg_out_op_rr(s, INDEX_op_mov_i32, ret, arg);
 525         break;
 526 #if TCG_TARGET_REG_BITS == 64
 527     case TCG_TYPE_I64:
 528         tcg_out_op_rr(s, INDEX_op_mov_i64, ret, arg);
 529         break;
 530 #endif
 531     default:
 532         g_assert_not_reached();
 533     }
 534     return true;
 535 }
 536
 537 static void tcg_out_movi(TCGContext *s, TCGType type,
 538                          TCGReg ret, tcg_target_long arg)
 539 {
 540     switch (type) {
 541     case TCG_TYPE_I32:
 542 #if TCG_TARGET_REG_BITS == 64
 543         arg = (int32_t)arg;
 544         /* fall through */
 545     case TCG_TYPE_I64:
 546 #endif
 547         break;
 548     default:
 549         g_assert_not_reached();
 550     }
 551
 552     if (arg == sextract32(arg, 0, 20)) {
 553         tcg_out_op_ri(s, INDEX_op_tci_movi, ret, arg);
 554     } else {
 555         tcg_insn_unit insn = 0;
 556
 557         new_pool_label(s, arg, 20, s->code_ptr, 0);
 558         insn = deposit32(insn, 0, 8, INDEX_op_tci_movl);
 559         insn = deposit32(insn, 8, 4, ret);
 560         tcg_out32(s, insn);
 561     }
 562 }
 563
 564 static void tcg_out_call(TCGContext *s, const tcg_insn_unit *func,
 565                          ffi_cif *cif)
 566 {
 567     tcg_insn_unit insn = 0;
 568     uint8_t which;
 569
 570     if (cif->rtype == &ffi_type_void) {
 571         which = 0;
 572     } else if (cif->rtype->size == 4) {
 573         which = 1;
 574     } else {
 575         tcg_debug_assert(cif->rtype->size == 8);
 576         which = 2;
 577     }
 578     new_pool_l2(s, 20, s->code_ptr, 0, (uintptr_t)func, (uintptr_t)cif);
 579     insn = deposit32(insn, 0, 8, INDEX_op_call);
 580     insn = deposit32(insn, 8, 4, which);
 581     tcg_out32(s, insn);
 582 }
 583
 584 #if TCG_TARGET_REG_BITS == 64
 585 # define CASE_32_64(x) \
 586         case glue(glue(INDEX_op_, x), _i64): \
 587         case glue(glue(INDEX_op_, x), _i32):
 588 # define CASE_64(x) \
 589         case glue(glue(INDEX_op_, x), _i64):
 590 #else
 591 # define CASE_32_64(x) \
 592         case glue(glue(INDEX_op_, x), _i32):
 593 # define CASE_64(x)
 594 #endif
 595
 596 static void tcg_out_op(TCGContext *s, TCGOpcode opc,
 597                        const TCGArg args[TCG_MAX_OP_ARGS],
 598                        const int const_args[TCG_MAX_OP_ARGS])
 599 {
 600     switch (opc) {
 601     case INDEX_op_exit_tb:
 602         tcg_out_op_p(s, opc, (void *)args[0]);
 603         break;
 604
 605     case INDEX_op_goto_tb:
 606         tcg_debug_assert(s->tb_jmp_insn_offset == 0);
 607         /* indirect jump method. */
 608         tcg_out_op_p(s, opc, s->tb_jmp_target_addr + args[0]);
 609         set_jmp_reset_offset(s, args[0]);
 610         break;
 611
 612     case INDEX_op_goto_ptr:
 613         tcg_out_op_r(s, opc, args[0]);
 614         break;
 615
 616     case INDEX_op_br:
 617         tcg_out_op_l(s, opc, arg_label(args[0]));
 618         break;
 619
 620     CASE_32_64(setcond)
 621         tcg_out_op_rrrc(s, opc, args[0], args[1], args[2], args[3]);
 622         break;
 623
 624     CASE_32_64(movcond)
 625     case INDEX_op_setcond2_i32:
 626         tcg_out_op_rrrrrc(s, opc, args[0], args[1], args[2],
 627                           args[3], args[4], args[5]);
 628         break;
 629
 630     CASE_32_64(ld8u)
 631     CASE_32_64(ld8s)
 632     CASE_32_64(ld16u)
 633     CASE_32_64(ld16s)
 634     case INDEX_op_ld_i32:
 635     CASE_64(ld32u)
 636     CASE_64(ld32s)
 637     CASE_64(ld)
 638     CASE_32_64(st8)
 639     CASE_32_64(st16)
 640     case INDEX_op_st_i32:
 641     CASE_64(st32)
 642     CASE_64(st)
 643         tcg_out_ldst(s, opc, args[0], args[1], args[2]);
 644         break;
 645
 646     CASE_32_64(add)
 647     CASE_32_64(sub)
 648     CASE_32_64(mul)
 649     CASE_32_64(and)
 650     CASE_32_64(or)
 651     CASE_32_64(xor)
 652     CASE_32_64(andc)     /* Optional (TCG_TARGET_HAS_andc_*). */
 653     CASE_32_64(orc)      /* Optional (TCG_TARGET_HAS_orc_*). */
 654     CASE_32_64(eqv)      /* Optional (TCG_TARGET_HAS_eqv_*). */
 655     CASE_32_64(nand)     /* Optional (TCG_TARGET_HAS_nand_*). */
 656     CASE_32_64(nor)      /* Optional (TCG_TARGET_HAS_nor_*). */
 657     CASE_32_64(shl)
 658     CASE_32_64(shr)
 659     CASE_32_64(sar)
 660     CASE_32_64(rotl)     /* Optional (TCG_TARGET_HAS_rot_*). */
 661     CASE_32_64(rotr)     /* Optional (TCG_TARGET_HAS_rot_*). */
 662     CASE_32_64(div)      /* Optional (TCG_TARGET_HAS_div_*). */
 663     CASE_32_64(divu)     /* Optional (TCG_TARGET_HAS_div_*). */
 664     CASE_32_64(rem)      /* Optional (TCG_TARGET_HAS_div_*). */
 665     CASE_32_64(remu)     /* Optional (TCG_TARGET_HAS_div_*). */
 666     CASE_32_64(clz)      /* Optional (TCG_TARGET_HAS_clz_*). */
 667     CASE_32_64(ctz)      /* Optional (TCG_TARGET_HAS_ctz_*). */
 668         tcg_out_op_rrr(s, opc, args[0], args[1], args[2]);
 669         break;
 670
 671     CASE_32_64(deposit)  /* Optional (TCG_TARGET_HAS_deposit_*). */
 672         {
 673             TCGArg pos = args[3], len = args[4];
 674             TCGArg max = opc == INDEX_op_deposit_i32 ? 32 : 64;
 675
 676             tcg_debug_assert(pos < max);
 677             tcg_debug_assert(pos + len <= max);
 678
 679             tcg_out_op_rrrbb(s, opc, args[0], args[1], args[2], pos, len);
 680         }
 681         break;
 682
 683     CASE_32_64(extract)  /* Optional (TCG_TARGET_HAS_extract_*). */
 684     CASE_32_64(sextract) /* Optional (TCG_TARGET_HAS_sextract_*). */
 685         {
 686             TCGArg pos = args[2], len = args[3];
 687             TCGArg max = tcg_op_defs[opc].flags & TCG_OPF_64BIT ? 64 : 32;
 688
 689             tcg_debug_assert(pos < max);
 690             tcg_debug_assert(pos + len <= max);
 691
 692             tcg_out_op_rrbb(s, opc, args[0], args[1], pos, len);
 693         }
 694         break;
 695
 696     CASE_32_64(brcond)
 697         tcg_out_op_rrrc(s, (opc == INDEX_op_brcond_i32
 698                             ? INDEX_op_setcond_i32 : INDEX_op_setcond_i64),
 699                         TCG_REG_TMP, args[0], args[1], args[2]);
 700         tcg_out_op_rl(s, opc, TCG_REG_TMP, arg_label(args[3]));
 701         break;
 702
 703     CASE_32_64(neg)      /* Optional (TCG_TARGET_HAS_neg_*). */
 704     CASE_32_64(not)      /* Optional (TCG_TARGET_HAS_not_*). */
 705     CASE_32_64(ext8s)    /* Optional (TCG_TARGET_HAS_ext8s_*). */
 706     CASE_32_64(ext8u)    /* Optional (TCG_TARGET_HAS_ext8u_*). */
 707     CASE_32_64(ext16s)   /* Optional (TCG_TARGET_HAS_ext16s_*). */
 708     CASE_32_64(ext16u)   /* Optional (TCG_TARGET_HAS_ext16u_*). */
 709     CASE_64(ext32s)      /* Optional (TCG_TARGET_HAS_ext32s_i64). */
 710     CASE_64(ext32u)      /* Optional (TCG_TARGET_HAS_ext32u_i64). */
 711     CASE_64(ext_i32)
 712     CASE_64(extu_i32)
 713     CASE_32_64(bswap16)  /* Optional (TCG_TARGET_HAS_bswap16_*). */
 714     CASE_32_64(bswap32)  /* Optional (TCG_TARGET_HAS_bswap32_*). */
 715     CASE_64(bswap64)     /* Optional (TCG_TARGET_HAS_bswap64_i64). */
 716     CASE_32_64(ctpop)    /* Optional (TCG_TARGET_HAS_ctpop_*). */
 717         tcg_out_op_rr(s, opc, args[0], args[1]);
 718         break;
 719
 720 #if TCG_TARGET_REG_BITS == 32
 721     case INDEX_op_add2_i32:
 722     case INDEX_op_sub2_i32:
 723         tcg_out_op_rrrrrr(s, opc, args[0], args[1], args[2],
 724                           args[3], args[4], args[5]);
 725         break;
 726     case INDEX_op_brcond2_i32:
 727         tcg_out_op_rrrrrc(s, INDEX_op_setcond2_i32, TCG_REG_TMP,
 728                           args[0], args[1], args[2], args[3], args[4]);
 729         tcg_out_op_rl(s, INDEX_op_brcond_i32, TCG_REG_TMP, arg_label(args[5]));
 730         break;
 731 #endif
 732
 733     CASE_32_64(mulu2)
 734     CASE_32_64(muls2)
 735         tcg_out_op_rrrr(s, opc, args[0], args[1], args[2], args[3]);
 736         break;
 737
 738     case INDEX_op_qemu_ld_i32:
 739     case INDEX_op_qemu_st_i32:
 740         if (TARGET_LONG_BITS <= TCG_TARGET_REG_BITS) {
 741             tcg_out_op_rrm(s, opc, args[0], args[1], args[2]);
 742         } else {
 743             tcg_out_op_rrrm(s, opc, args[0], args[1], args[2], args[3]);
 744         }
 745         break;
 746
 747     case INDEX_op_qemu_ld_i64:
 748     case INDEX_op_qemu_st_i64:
 749         if (TCG_TARGET_REG_BITS == 64) {
 750             tcg_out_op_rrm(s, opc, args[0], args[1], args[2]);
 751         } else if (TARGET_LONG_BITS <= TCG_TARGET_REG_BITS) {
 752             tcg_out_op_rrrm(s, opc, args[0], args[1], args[2], args[3]);
 753         } else {
 754             tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_TMP, args[4]);
 755             tcg_out_op_rrrrr(s, opc, args[0], args[1],
 756                              args[2], args[3], TCG_REG_TMP);
 757         }
 758         break;
 759
 760     case INDEX_op_mb:
 761         tcg_out_op_v(s, opc);
 762         break;
 763
 764     case INDEX_op_mov_i32:  /* Always emitted via tcg_out_mov.  */
 765     case INDEX_op_mov_i64:
 766     case INDEX_op_call:     /* Always emitted via tcg_out_call.  */
 767     default:
 768         tcg_abort();
 769     }
 770 }
 771
 772 static void tcg_out_st(TCGContext *s, TCGType type, TCGReg val, TCGReg base,
 773                        intptr_t offset)
 774 {
 775     stack_bounds_check(base, offset);
 776     switch (type) {
 777     case TCG_TYPE_I32:
 778         tcg_out_op_rrs(s, INDEX_op_st_i32, val, base, offset);
 779         break;
 780 #if TCG_TARGET_REG_BITS == 64
 781     case TCG_TYPE_I64:
 782         tcg_out_op_rrs(s, INDEX_op_st_i64, val, base, offset);
 783         break;
 784 #endif
 785     default:
 786         g_assert_not_reached();
 787     }
 788 }
 789
 790 static inline bool tcg_out_sti(TCGContext *s, TCGType type, TCGArg val,
 791                                TCGReg base, intptr_t ofs)
 792 {
 793     return false;
 794 }
 795
 796 /* Test if a constant matches the constraint. */
 797 static bool tcg_target_const_match(int64_t val, TCGType type, int ct)
 798 {
 799     return ct & TCG_CT_CONST;
 800 }
 801
 802 static void tcg_out_nop_fill(tcg_insn_unit *p, int count)
 803 {
 804     memset(p, 0, sizeof(*p) * count);
 805 }
 806
 807 static void tcg_target_init(TCGContext *s)
 808 {
 809 #if defined(CONFIG_DEBUG_TCG_INTERPRETER)
 810     const char *envval = getenv("DEBUG_TCG");
 811     if (envval) {
 812         qemu_set_log(strtol(envval, NULL, 0));
 813     }
 814 #endif
 815
 816     /* The current code uses uint8_t for tcg operations. */
 817     tcg_debug_assert(tcg_op_defs_max <= UINT8_MAX);
 818
 819     /* Registers available for 32 bit operations. */
 820     tcg_target_available_regs[TCG_TYPE_I32] = BIT(TCG_TARGET_NB_REGS) - 1;
 821     /* Registers available for 64 bit operations. */
 822     tcg_target_available_regs[TCG_TYPE_I64] = BIT(TCG_TARGET_NB_REGS) - 1;
 823     /*
 824      * The interpreter "registers" are in the local stack frame and
 825      * cannot be clobbered by the called helper functions.  However,
 826      * the interpreter assumes a 64-bit return value and assigns to
 827      * the return value registers.
 828      */
 829     tcg_target_call_clobber_regs =
 830         MAKE_64BIT_MASK(TCG_REG_R0, 64 / TCG_TARGET_REG_BITS);
 831
 832     s->reserved_regs = 0;
 833     tcg_regset_set_reg(s->reserved_regs, TCG_REG_TMP);
 834     tcg_regset_set_reg(s->reserved_regs, TCG_REG_CALL_STACK);
 835
 836     /* The call arguments come first, followed by the temp storage. */
 837     tcg_set_frame(s, TCG_REG_CALL_STACK, TCG_STATIC_CALL_ARGS_SIZE,
 838                   TCG_STATIC_FRAME_SIZE);
 839 }
 840
 841 /* Generate global QEMU prologue and epilogue code. */
 842 static inline void tcg_target_qemu_prologue(TCGContext *s)
 843 {
 844 }