tcg/ppc/tcg-target.c

   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 static uint8_t *tb_ret_addr;
  26
  27 #ifdef _CALL_DARWIN
  28 #define LINKAGE_AREA_SIZE 24
  29 #define LR_OFFSET 8
  30 #elif defined _CALL_AIX
  31 #define LINKAGE_AREA_SIZE 52
  32 #define LR_OFFSET 8
  33 #else
  34 #define LINKAGE_AREA_SIZE 8
  35 #define LR_OFFSET 4
  36 #endif
  37
  38 #define FAST_PATH
  39
  40 #ifndef GUEST_BASE
  41 #define GUEST_BASE 0
  42 #endif
  43
  44 #ifdef CONFIG_USE_GUEST_BASE
  45 #define TCG_GUEST_BASE_REG 30
  46 #else
  47 #define TCG_GUEST_BASE_REG 0
  48 #endif
  49
  50 #ifndef NDEBUG
  51 static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
  52     "r0",
  53     "r1",
  54     "r2",
  55     "r3",
  56     "r4",
  57     "r5",
  58     "r6",
  59     "r7",
  60     "r8",
  61     "r9",
  62     "r10",
  63     "r11",
  64     "r12",
  65     "r13",
  66     "r14",
  67     "r15",
  68     "r16",
  69     "r17",
  70     "r18",
  71     "r19",
  72     "r20",
  73     "r21",
  74     "r22",
  75     "r23",
  76     "r24",
  77     "r25",
  78     "r26",
  79     "r27",
  80     "r28",
  81     "r29",
  82     "r30",
  83     "r31"
  84 };
  85 #endif
  86
  87 static const int tcg_target_reg_alloc_order[] = {
  88     TCG_REG_R14,
  89     TCG_REG_R15,
  90     TCG_REG_R16,
  91     TCG_REG_R17,
  92     TCG_REG_R18,
  93     TCG_REG_R19,
  94     TCG_REG_R20,
  95     TCG_REG_R21,
  96     TCG_REG_R22,
  97     TCG_REG_R23,
  98     TCG_REG_R28,
  99     TCG_REG_R29,
 100     TCG_REG_R30,
 101     TCG_REG_R31,
 102 #ifdef _CALL_DARWIN
 103     TCG_REG_R2,
 104 #endif
 105     TCG_REG_R3,
 106     TCG_REG_R4,
 107     TCG_REG_R5,
 108     TCG_REG_R6,
 109     TCG_REG_R7,
 110     TCG_REG_R8,
 111     TCG_REG_R9,
 112     TCG_REG_R10,
 113 #ifndef _CALL_DARWIN
 114     TCG_REG_R11,
 115 #endif
 116     TCG_REG_R12,
 117 #ifndef _CALL_SYSV
 118     TCG_REG_R13,
 119 #endif
 120     TCG_REG_R24,
 121     TCG_REG_R25,
 122     TCG_REG_R26,
 123     TCG_REG_R27
 124 };
 125
 126 static const int tcg_target_call_iarg_regs[] = {
 127     TCG_REG_R3,
 128     TCG_REG_R4,
 129     TCG_REG_R5,
 130     TCG_REG_R6,
 131     TCG_REG_R7,
 132     TCG_REG_R8,
 133     TCG_REG_R9,
 134     TCG_REG_R10
 135 };
 136
 137 static const int tcg_target_call_oarg_regs[2] = {
 138     TCG_REG_R3,
 139     TCG_REG_R4
 140 };
 141
 142 static const int tcg_target_callee_save_regs[] = {
 143 #ifdef _CALL_DARWIN
 144     TCG_REG_R11,
 145     TCG_REG_R13,
 146 #endif
 147 #ifdef _CALL_AIX
 148     TCG_REG_R13,
 149 #endif
 150     TCG_REG_R14,
 151     TCG_REG_R15,
 152     TCG_REG_R16,
 153     TCG_REG_R17,
 154     TCG_REG_R18,
 155     TCG_REG_R19,
 156     TCG_REG_R20,
 157     TCG_REG_R21,
 158     TCG_REG_R22,
 159     TCG_REG_R23,
 160     TCG_REG_R24,
 161     TCG_REG_R25,
 162     TCG_REG_R26,
 163     /* TCG_REG_R27, */ /* currently used for the global env, so no
 164                           need to save */
 165     TCG_REG_R28,
 166     TCG_REG_R29,
 167     TCG_REG_R30,
 168     TCG_REG_R31
 169 };
 170
 171 static uint32_t reloc_pc24_val (void *pc, tcg_target_long target)
 172 {
 173     tcg_target_long disp;
 174
 175     disp = target - (tcg_target_long) pc;
 176     if ((disp << 6) >> 6 != disp)
 177         tcg_abort ();
 178
 179     return disp & 0x3fffffc;
 180 }
 181
 182 static void reloc_pc24 (void *pc, tcg_target_long target)
 183 {
 184     *(uint32_t *) pc = (*(uint32_t *) pc & ~0x3fffffc)
 185         | reloc_pc24_val (pc, target);
 186 }
 187
 188 static uint16_t reloc_pc14_val (void *pc, tcg_target_long target)
 189 {
 190     tcg_target_long disp;
 191
 192     disp = target - (tcg_target_long) pc;
 193     if (disp != (int16_t) disp)
 194         tcg_abort ();
 195
 196     return disp & 0xfffc;
 197 }
 198
 199 static void reloc_pc14 (void *pc, tcg_target_long target)
 200 {
 201     *(uint32_t *) pc = (*(uint32_t *) pc & ~0xfffc)
 202         | reloc_pc14_val (pc, target);
 203 }
 204
 205 static void patch_reloc(uint8_t *code_ptr, int type,
 206                         tcg_target_long value, tcg_target_long addend)
 207 {
 208     value += addend;
 209     switch (type) {
 210     case R_PPC_REL14:
 211         reloc_pc14 (code_ptr, value);
 212         break;
 213     case R_PPC_REL24:
 214         reloc_pc24 (code_ptr, value);
 215         break;
 216     default:
 217         tcg_abort();
 218     }
 219 }
 220
 221 /* maximum number of register used for input function arguments */
 222 static int tcg_target_get_call_iarg_regs_count(int flags)
 223 {
 224     return ARRAY_SIZE (tcg_target_call_iarg_regs);
 225 }
 226
 227 /* parse target specific constraints */
 228 static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
 229 {
 230     const char *ct_str;
 231
 232     ct_str = *pct_str;
 233     switch (ct_str[0]) {
 234     case 'A': case 'B': case 'C': case 'D':
 235         ct->ct |= TCG_CT_REG;
 236         tcg_regset_set_reg(ct->u.regs, 3 + ct_str[0] - 'A');
 237         break;
 238     case 'r':
 239         ct->ct |= TCG_CT_REG;
 240         tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
 241         break;
 242 #ifdef CONFIG_SOFTMMU
 243     case 'L':                   /* qemu_ld constraint */
 244         ct->ct |= TCG_CT_REG;
 245         tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
 246         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3);
 247         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R4);
 248         break;
 249     case 'K':                   /* qemu_st[8..32] constraint */
 250         ct->ct |= TCG_CT_REG;
 251         tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
 252         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3);
 253         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R4);
 254         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R5);
 255 #if TARGET_LONG_BITS == 64
 256         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R6);
 257 #endif
 258         break;
 259     case 'M':                   /* qemu_st64 constraint */
 260         ct->ct |= TCG_CT_REG;
 261         tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
 262         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3);
 263         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R4);
 264         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R5);
 265         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R6);
 266         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R7);
 267         break;
 268 #else
 269     case 'L':
 270     case 'K':
 271         ct->ct |= TCG_CT_REG;
 272         tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
 273         break;
 274     case 'M':
 275         ct->ct |= TCG_CT_REG;
 276         tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
 277         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3);
 278         break;
 279 #endif
 280     default:
 281         return -1;
 282     }
 283     ct_str++;
 284     *pct_str = ct_str;
 285     return 0;
 286 }
 287
 288 /* test if a constant matches the constraint */
 289 static int tcg_target_const_match(tcg_target_long val,
 290                                   const TCGArgConstraint *arg_ct)
 291 {
 292     int ct;
 293
 294     ct = arg_ct->ct;
 295     if (ct & TCG_CT_CONST)
 296         return 1;
 297     return 0;
 298 }
 299
 300 #define OPCD(opc) ((opc)<<26)
 301 #define XO31(opc) (OPCD(31)|((opc)<<1))
 302 #define XO19(opc) (OPCD(19)|((opc)<<1))
 303
 304 #define B      OPCD(18)
 305 #define BC     OPCD(16)
 306 #define LBZ    OPCD(34)
 307 #define LHZ    OPCD(40)
 308 #define LHA    OPCD(42)
 309 #define LWZ    OPCD(32)
 310 #define STB    OPCD(38)
 311 #define STH    OPCD(44)
 312 #define STW    OPCD(36)
 313
 314 #define ADDIC  OPCD(12)
 315 #define ADDI   OPCD(14)
 316 #define ADDIS  OPCD(15)
 317 #define ORI    OPCD(24)
 318 #define ORIS   OPCD(25)
 319 #define XORI   OPCD(26)
 320 #define XORIS  OPCD(27)
 321 #define ANDI   OPCD(28)
 322 #define ANDIS  OPCD(29)
 323 #define MULLI  OPCD( 7)
 324 #define CMPLI  OPCD(10)
 325 #define CMPI   OPCD(11)
 326 #define SUBFIC OPCD( 8)
 327
 328 #define LWZU   OPCD(33)
 329 #define STWU   OPCD(37)
 330
 331 #define RLWIMI OPCD(20)
 332 #define RLWINM OPCD(21)
 333 #define RLWNM  OPCD(23)
 334
 335 #define BCLR   XO19( 16)
 336 #define BCCTR  XO19(528)
 337 #define CRAND  XO19(257)
 338 #define CRANDC XO19(129)
 339 #define CRNAND XO19(225)
 340 #define CROR   XO19(449)
 341 #define CRNOR  XO19( 33)
 342
 343 #define EXTSB  XO31(954)
 344 #define EXTSH  XO31(922)
 345 #define ADD    XO31(266)
 346 #define ADDE   XO31(138)
 347 #define ADDC   XO31( 10)
 348 #define AND    XO31( 28)
 349 #define SUBF   XO31( 40)
 350 #define SUBFC  XO31(  8)
 351 #define SUBFE  XO31(136)
 352 #define OR     XO31(444)
 353 #define XOR    XO31(316)
 354 #define MULLW  XO31(235)
 355 #define MULHWU XO31( 11)
 356 #define DIVW   XO31(491)
 357 #define DIVWU  XO31(459)
 358 #define CMP    XO31(  0)
 359 #define CMPL   XO31( 32)
 360 #define LHBRX  XO31(790)
 361 #define LWBRX  XO31(534)
 362 #define STHBRX XO31(918)
 363 #define STWBRX XO31(662)
 364 #define MFSPR  XO31(339)
 365 #define MTSPR  XO31(467)
 366 #define SRAWI  XO31(824)
 367 #define NEG    XO31(104)
 368 #define MFCR   XO31( 19)
 369 #define CNTLZW XO31( 26)
 370 #define NOR    XO31(124)
 371 #define ANDC   XO31( 60)
 372 #define ORC    XO31(412)
 373 #define EQV    XO31(284)
 374 #define NAND   XO31(476)
 375
 376 #define LBZX   XO31( 87)
 377 #define LHZX   XO31(279)
 378 #define LHAX   XO31(343)
 379 #define LWZX   XO31( 23)
 380 #define STBX   XO31(215)
 381 #define STHX   XO31(407)
 382 #define STWX   XO31(151)
 383
 384 #define SPR(a,b) ((((a)<<5)|(b))<<11)
 385 #define LR     SPR(8, 0)
 386 #define CTR    SPR(9, 0)
 387
 388 #define SLW    XO31( 24)
 389 #define SRW    XO31(536)
 390 #define SRAW   XO31(792)
 391
 392 #define TW     XO31(4)
 393 #define TRAP   (TW | TO (31))
 394
 395 #define RT(r) ((r)<<21)
 396 #define RS(r) ((r)<<21)
 397 #define RA(r) ((r)<<16)
 398 #define RB(r) ((r)<<11)
 399 #define TO(t) ((t)<<21)
 400 #define SH(s) ((s)<<11)
 401 #define MB(b) ((b)<<6)
 402 #define ME(e) ((e)<<1)
 403 #define BO(o) ((o)<<21)
 404
 405 #define LK    1
 406
 407 #define TAB(t,a,b) (RT(t) | RA(a) | RB(b))
 408 #define SAB(s,a,b) (RS(s) | RA(a) | RB(b))
 409
 410 #define BF(n)    ((n)<<23)
 411 #define BI(n, c) (((c)+((n)*4))<<16)
 412 #define BT(n, c) (((c)+((n)*4))<<21)
 413 #define BA(n, c) (((c)+((n)*4))<<16)
 414 #define BB(n, c) (((c)+((n)*4))<<11)
 415
 416 #define BO_COND_TRUE  BO (12)
 417 #define BO_COND_FALSE BO (4)
 418 #define BO_ALWAYS     BO (20)
 419
 420 enum {
 421     CR_LT,
 422     CR_GT,
 423     CR_EQ,
 424     CR_SO
 425 };
 426
 427 static const uint32_t tcg_to_bc[10] = {
 428     [TCG_COND_EQ]  = BC | BI (7, CR_EQ) | BO_COND_TRUE,
 429     [TCG_COND_NE]  = BC | BI (7, CR_EQ) | BO_COND_FALSE,
 430     [TCG_COND_LT]  = BC | BI (7, CR_LT) | BO_COND_TRUE,
 431     [TCG_COND_GE]  = BC | BI (7, CR_LT) | BO_COND_FALSE,
 432     [TCG_COND_LE]  = BC | BI (7, CR_GT) | BO_COND_FALSE,
 433     [TCG_COND_GT]  = BC | BI (7, CR_GT) | BO_COND_TRUE,
 434     [TCG_COND_LTU] = BC | BI (7, CR_LT) | BO_COND_TRUE,
 435     [TCG_COND_GEU] = BC | BI (7, CR_LT) | BO_COND_FALSE,
 436     [TCG_COND_LEU] = BC | BI (7, CR_GT) | BO_COND_FALSE,
 437     [TCG_COND_GTU] = BC | BI (7, CR_GT) | BO_COND_TRUE,
 438 };
 439
 440 static void tcg_out_mov(TCGContext *s, int ret, int arg)
 441 {
 442     tcg_out32 (s, OR | SAB (arg, ret, arg));
 443 }
 444
 445 static void tcg_out_movi(TCGContext *s, TCGType type,
 446                          int ret, tcg_target_long arg)
 447 {
 448     if (arg == (int16_t) arg)
 449         tcg_out32 (s, ADDI | RT (ret) | RA (0) | (arg & 0xffff));
 450     else {
 451         tcg_out32 (s, ADDIS | RT (ret) | RA (0) | ((arg >> 16) & 0xffff));
 452         if (arg & 0xffff)
 453             tcg_out32 (s, ORI | RS (ret) | RA (ret) | (arg & 0xffff));
 454     }
 455 }
 456
 457 static void tcg_out_ldst (TCGContext *s, int ret, int addr,
 458                           int offset, int op1, int op2)
 459 {
 460     if (offset == (int16_t) offset)
 461         tcg_out32 (s, op1 | RT (ret) | RA (addr) | (offset & 0xffff));
 462     else {
 463         tcg_out_movi (s, TCG_TYPE_I32, 0, offset);
 464         tcg_out32 (s, op2 | RT (ret) | RA (addr) | RB (0));
 465     }
 466 }
 467
 468 static void tcg_out_b (TCGContext *s, int mask, tcg_target_long target)
 469 {
 470     tcg_target_long disp;
 471
 472     disp = target - (tcg_target_long) s->code_ptr;
 473     if ((disp << 6) >> 6 == disp)
 474         tcg_out32 (s, B | (disp & 0x3fffffc) | mask);
 475     else {
 476         tcg_out_movi (s, TCG_TYPE_I32, 0, (tcg_target_long) target);
 477         tcg_out32 (s, MTSPR | RS (0) | CTR);
 478         tcg_out32 (s, BCCTR | BO_ALWAYS | mask);
 479     }
 480 }
 481
 482 static void tcg_out_call (TCGContext *s, tcg_target_long arg, int const_arg)
 483 {
 484 #ifdef _CALL_AIX
 485     int reg;
 486
 487     if (const_arg) {
 488         reg = 2;
 489         tcg_out_movi (s, TCG_TYPE_I32, reg, arg);
 490     }
 491     else reg = arg;
 492
 493     tcg_out32 (s, LWZ | RT (0) | RA (reg));
 494     tcg_out32 (s, MTSPR | RA (0) | CTR);
 495     tcg_out32 (s, LWZ | RT (2) | RA (reg) | 4);
 496     tcg_out32 (s, BCCTR | BO_ALWAYS | LK);
 497 #else
 498     if (const_arg) {
 499         tcg_out_b (s, LK, arg);
 500     }
 501     else {
 502         tcg_out32 (s, MTSPR | RS (arg) | LR);
 503         tcg_out32 (s, BCLR | BO_ALWAYS | LK);
 504     }
 505 #endif
 506 }
 507
 508 #if defined(CONFIG_SOFTMMU)
 509
 510 #include "../../softmmu_defs.h"
 511
 512 static void *qemu_ld_helpers[4] = {
 513     __ldb_mmu,
 514     __ldw_mmu,
 515     __ldl_mmu,
 516     __ldq_mmu,
 517 };
 518
 519 static void *qemu_st_helpers[4] = {
 520     __stb_mmu,
 521     __stw_mmu,
 522     __stl_mmu,
 523     __stq_mmu,
 524 };
 525 #endif
 526
 527 static void tcg_out_qemu_ld (TCGContext *s, const TCGArg *args, int opc)
 528 {
 529     int addr_reg, data_reg, data_reg2, r0, r1, rbase, mem_index, s_bits, bswap;
 530 #ifdef CONFIG_SOFTMMU
 531     int r2;
 532     void *label1_ptr, *label2_ptr;
 533 #endif
 534 #if TARGET_LONG_BITS == 64
 535     int addr_reg2;
 536 #endif
 537
 538     data_reg = *args++;
 539     if (opc == 3)
 540         data_reg2 = *args++;
 541     else
 542         data_reg2 = 0;
 543     addr_reg = *args++;
 544 #if TARGET_LONG_BITS == 64
 545     addr_reg2 = *args++;
 546 #endif
 547     mem_index = *args;
 548     s_bits = opc & 3;
 549
 550 #ifdef CONFIG_SOFTMMU
 551     r0 = 3;
 552     r1 = 4;
 553     r2 = 0;
 554     rbase = 0;
 555
 556     tcg_out32 (s, (RLWINM
 557                    | RA (r0)
 558                    | RS (addr_reg)
 559                    | SH (32 - (TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS))
 560                    | MB (32 - (CPU_TLB_BITS + CPU_TLB_ENTRY_BITS))
 561                    | ME (31 - CPU_TLB_ENTRY_BITS)
 562                    )
 563         );
 564     tcg_out32 (s, ADD | RT (r0) | RA (r0) | RB (TCG_AREG0));
 565     tcg_out32 (s, (LWZU
 566                    | RT (r1)
 567                    | RA (r0)
 568                    | offsetof (CPUState, tlb_table[mem_index][0].addr_read)
 569                    )
 570         );
 571     tcg_out32 (s, (RLWINM
 572                    | RA (r2)
 573                    | RS (addr_reg)
 574                    | SH (0)
 575                    | MB ((32 - s_bits) & 31)
 576                    | ME (31 - TARGET_PAGE_BITS)
 577                    )
 578         );
 579
 580     tcg_out32 (s, CMP | BF (7) | RA (r2) | RB (r1));
 581 #if TARGET_LONG_BITS == 64
 582     tcg_out32 (s, LWZ | RT (r1) | RA (r0) | 4);
 583     tcg_out32 (s, CMP | BF (6) | RA (addr_reg2) | RB (r1));
 584     tcg_out32 (s, CRAND | BT (7, CR_EQ) | BA (6, CR_EQ) | BB (7, CR_EQ));
 585 #endif
 586
 587     label1_ptr = s->code_ptr;
 588 #ifdef FAST_PATH
 589     tcg_out32 (s, BC | BI (7, CR_EQ) | BO_COND_TRUE);
 590 #endif
 591
 592     /* slow path */
 593 #if TARGET_LONG_BITS == 32
 594     tcg_out_mov (s, 3, addr_reg);
 595     tcg_out_movi (s, TCG_TYPE_I32, 4, mem_index);
 596 #else
 597     tcg_out_mov (s, 3, addr_reg2);
 598     tcg_out_mov (s, 4, addr_reg);
 599     tcg_out_movi (s, TCG_TYPE_I32, 5, mem_index);
 600 #endif
 601
 602     tcg_out_call (s, (tcg_target_long) qemu_ld_helpers[s_bits], 1);
 603     switch (opc) {
 604     case 0|4:
 605         tcg_out32 (s, EXTSB | RA (data_reg) | RS (3));
 606         break;
 607     case 1|4:
 608         tcg_out32 (s, EXTSH | RA (data_reg) | RS (3));
 609         break;
 610     case 0:
 611     case 1:
 612     case 2:
 613         if (data_reg != 3)
 614             tcg_out_mov (s, data_reg, 3);
 615         break;
 616     case 3:
 617         if (data_reg == 3) {
 618             if (data_reg2 == 4) {
 619                 tcg_out_mov (s, 0, 4);
 620                 tcg_out_mov (s, 4, 3);
 621                 tcg_out_mov (s, 3, 0);
 622             }
 623             else {
 624                 tcg_out_mov (s, data_reg2, 3);
 625                 tcg_out_mov (s, 3, 4);
 626             }
 627         }
 628         else {
 629             if (data_reg != 4) tcg_out_mov (s, data_reg, 4);
 630             if (data_reg2 != 3) tcg_out_mov (s, data_reg2, 3);
 631         }
 632         break;
 633     }
 634     label2_ptr = s->code_ptr;
 635     tcg_out32 (s, B);
 636
 637     /* label1: fast path */
 638 #ifdef FAST_PATH
 639     reloc_pc14 (label1_ptr, (tcg_target_long) s->code_ptr);
 640 #endif
 641
 642     /* r0 now contains &env->tlb_table[mem_index][index].addr_read */
 643     tcg_out32 (s, (LWZ
 644                    | RT (r0)
 645                    | RA (r0)
 646                    | (offsetof (CPUTLBEntry, addend)
 647                       - offsetof (CPUTLBEntry, addr_read))
 648                    ));
 649     /* r0 = env->tlb_table[mem_index][index].addend */
 650     tcg_out32 (s, ADD | RT (r0) | RA (r0) | RB (addr_reg));
 651     /* r0 = env->tlb_table[mem_index][index].addend + addr */
 652
 653 #else  /* !CONFIG_SOFTMMU */
 654     r0 = addr_reg;
 655     r1 = 3;
 656     rbase = GUEST_BASE ? TCG_GUEST_BASE_REG : 0;
 657 #endif
 658
 659 #ifdef TARGET_WORDS_BIGENDIAN
 660     bswap = 0;
 661 #else
 662     bswap = 1;
 663 #endif
 664
 665     switch (opc) {
 666     default:
 667     case 0:
 668         tcg_out32 (s, LBZX | TAB (data_reg, rbase, r0));
 669         break;
 670     case 0|4:
 671         tcg_out32 (s, LBZX | TAB (data_reg, rbase, r0));
 672         tcg_out32 (s, EXTSB | RA (data_reg) | RS (data_reg));
 673         break;
 674     case 1:
 675         if (bswap)
 676             tcg_out32 (s, LHBRX | TAB (data_reg, rbase, r0));
 677         else
 678             tcg_out32 (s, LHZX | TAB (data_reg, rbase, r0));
 679         break;
 680     case 1|4:
 681         if (bswap) {
 682             tcg_out32 (s, LHBRX | TAB (data_reg, rbase, r0));
 683             tcg_out32 (s, EXTSH | RA (data_reg) | RS (data_reg));
 684         }
 685         else tcg_out32 (s, LHAX | TAB (data_reg, rbase, r0));
 686         break;
 687     case 2:
 688         if (bswap)
 689             tcg_out32 (s, LWBRX | TAB (data_reg, rbase, r0));
 690         else
 691             tcg_out32 (s, LWZX | TAB (data_reg, rbase, r0));
 692         break;
 693     case 3:
 694         if (bswap) {
 695             tcg_out32 (s, ADDI | RT (r1) | RA (r0) | 4);
 696             tcg_out32 (s, LWBRX | TAB (data_reg, rbase, r0));
 697             tcg_out32 (s, LWBRX | TAB (data_reg2, rbase, r1));
 698         }
 699         else {
 700 #ifdef CONFIG_USE_GUEST_BASE
 701             tcg_out32 (s, ADDI | RT (r1) | RA (r0) | 4);
 702             tcg_out32 (s, LWZX | TAB (data_reg2, rbase, r0));
 703             tcg_out32 (s, LWZX | TAB (data_reg, rbase, r1));
 704 #else
 705             if (r0 == data_reg2) {
 706                 tcg_out32 (s, LWZ | RT (0) | RA (r0));
 707                 tcg_out32 (s, LWZ | RT (data_reg) | RA (r0) | 4);
 708                 tcg_out_mov (s, data_reg2, 0);
 709             }
 710             else {
 711                 tcg_out32 (s, LWZ | RT (data_reg2) | RA (r0));
 712                 tcg_out32 (s, LWZ | RT (data_reg) | RA (r0) | 4);
 713             }
 714 #endif
 715         }
 716         break;
 717     }
 718
 719 #ifdef CONFIG_SOFTMMU
 720     reloc_pc24 (label2_ptr, (tcg_target_long) s->code_ptr);
 721 #endif
 722 }
 723
 724 static void tcg_out_qemu_st (TCGContext *s, const TCGArg *args, int opc)
 725 {
 726     int addr_reg, r0, r1, data_reg, data_reg2, mem_index, bswap, rbase;
 727 #ifdef CONFIG_SOFTMMU
 728     int r2, ir;
 729     void *label1_ptr, *label2_ptr;
 730 #endif
 731 #if TARGET_LONG_BITS == 64
 732     int addr_reg2;
 733 #endif
 734
 735     data_reg = *args++;
 736     if (opc == 3)
 737         data_reg2 = *args++;
 738     else
 739         data_reg2 = 0;
 740     addr_reg = *args++;
 741 #if TARGET_LONG_BITS == 64
 742     addr_reg2 = *args++;
 743 #endif
 744     mem_index = *args;
 745
 746 #ifdef CONFIG_SOFTMMU
 747     r0 = 3;
 748     r1 = 4;
 749     r2 = 0;
 750     rbase = 0;
 751
 752     tcg_out32 (s, (RLWINM
 753                    | RA (r0)
 754                    | RS (addr_reg)
 755                    | SH (32 - (TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS))
 756                    | MB (32 - (CPU_TLB_ENTRY_BITS + CPU_TLB_BITS))
 757                    | ME (31 - CPU_TLB_ENTRY_BITS)
 758                    )
 759         );
 760     tcg_out32 (s, ADD | RT (r0) | RA (r0) | RB (TCG_AREG0));
 761     tcg_out32 (s, (LWZU
 762                    | RT (r1)
 763                    | RA (r0)
 764                    | offsetof (CPUState, tlb_table[mem_index][0].addr_write)
 765                    )
 766         );
 767     tcg_out32 (s, (RLWINM
 768                    | RA (r2)
 769                    | RS (addr_reg)
 770                    | SH (0)
 771                    | MB ((32 - opc) & 31)
 772                    | ME (31 - TARGET_PAGE_BITS)
 773                    )
 774         );
 775
 776     tcg_out32 (s, CMP | (7 << 23) | RA (r2) | RB (r1));
 777 #if TARGET_LONG_BITS == 64
 778     tcg_out32 (s, LWZ | RT (r1) | RA (r0) | 4);
 779     tcg_out32 (s, CMP | BF (6) | RA (addr_reg2) | RB (r1));
 780     tcg_out32 (s, CRAND | BT (7, CR_EQ) | BA (6, CR_EQ) | BB (7, CR_EQ));
 781 #endif
 782
 783     label1_ptr = s->code_ptr;
 784 #ifdef FAST_PATH
 785     tcg_out32 (s, BC | BI (7, CR_EQ) | BO_COND_TRUE);
 786 #endif
 787
 788     /* slow path */
 789 #if TARGET_LONG_BITS == 32
 790     tcg_out_mov (s, 3, addr_reg);
 791     ir = 4;
 792 #else
 793     tcg_out_mov (s, 3, addr_reg2);
 794     tcg_out_mov (s, 4, addr_reg);
 795 #ifdef TCG_TARGET_CALL_ALIGN_ARGS
 796     ir = 5;
 797 #else
 798     ir = 4;
 799 #endif
 800 #endif
 801
 802     switch (opc) {
 803     case 0:
 804         tcg_out32 (s, (RLWINM
 805                        | RA (ir)
 806                        | RS (data_reg)
 807                        | SH (0)
 808                        | MB (24)
 809                        | ME (31)));
 810         break;
 811     case 1:
 812         tcg_out32 (s, (RLWINM
 813                        | RA (ir)
 814                        | RS (data_reg)
 815                        | SH (0)
 816                        | MB (16)
 817                        | ME (31)));
 818         break;
 819     case 2:
 820         tcg_out_mov (s, ir, data_reg);
 821         break;
 822     case 3:
 823 #ifdef TCG_TARGET_CALL_ALIGN_ARGS
 824         ir = 5;
 825 #endif
 826         tcg_out_mov (s, ir++, data_reg2);
 827         tcg_out_mov (s, ir, data_reg);
 828         break;
 829     }
 830     ir++;
 831
 832     tcg_out_movi (s, TCG_TYPE_I32, ir, mem_index);
 833     tcg_out_call (s, (tcg_target_long) qemu_st_helpers[opc], 1);
 834     label2_ptr = s->code_ptr;
 835     tcg_out32 (s, B);
 836
 837     /* label1: fast path */
 838 #ifdef FAST_PATH
 839     reloc_pc14 (label1_ptr, (tcg_target_long) s->code_ptr);
 840 #endif
 841
 842     tcg_out32 (s, (LWZ
 843                    | RT (r0)
 844                    | RA (r0)
 845                    | (offsetof (CPUTLBEntry, addend)
 846                       - offsetof (CPUTLBEntry, addr_write))
 847                    ));
 848     /* r0 = env->tlb_table[mem_index][index].addend */
 849     tcg_out32 (s, ADD | RT (r0) | RA (r0) | RB (addr_reg));
 850     /* r0 = env->tlb_table[mem_index][index].addend + addr */
 851
 852 #else  /* !CONFIG_SOFTMMU */
 853     r0 = addr_reg;
 854     r1 = 3;
 855     rbase = GUEST_BASE ? TCG_GUEST_BASE_REG : 0;
 856 #endif
 857
 858 #ifdef TARGET_WORDS_BIGENDIAN
 859     bswap = 0;
 860 #else
 861     bswap = 1;
 862 #endif
 863     switch (opc) {
 864     case 0:
 865         tcg_out32 (s, STBX | SAB (data_reg, rbase, r0));
 866         break;
 867     case 1:
 868         if (bswap)
 869             tcg_out32 (s, STHBRX | SAB (data_reg, rbase, r0));
 870         else
 871             tcg_out32 (s, STHX | SAB (data_reg, rbase, r0));
 872         break;
 873     case 2:
 874         if (bswap)
 875             tcg_out32 (s, STWBRX | SAB (data_reg, rbase, r0));
 876         else
 877             tcg_out32 (s, STWX | SAB (data_reg, rbase, r0));
 878         break;
 879     case 3:
 880         if (bswap) {
 881             tcg_out32 (s, ADDI | RT (r1) | RA (r0) | 4);
 882             tcg_out32 (s, STWBRX | SAB (data_reg,  rbase, r0));
 883             tcg_out32 (s, STWBRX | SAB (data_reg2, rbase, r1));
 884         }
 885         else {
 886 #ifdef CONFIG_USE_GUEST_BASE
 887             tcg_out32 (s, STWX | SAB (data_reg2, rbase, r0));
 888             tcg_out32 (s, ADDI | RT (r1) | RA (r0) | 4);
 889             tcg_out32 (s, STWX | SAB (data_reg,  rbase, r1));
 890 #else
 891             tcg_out32 (s, STW | RS (data_reg2) | RA (r0));
 892             tcg_out32 (s, STW | RS (data_reg) | RA (r0) | 4);
 893 #endif
 894         }
 895         break;
 896     }
 897
 898 #ifdef CONFIG_SOFTMMU
 899     reloc_pc24 (label2_ptr, (tcg_target_long) s->code_ptr);
 900 #endif
 901 }
 902
 903 void tcg_target_qemu_prologue (TCGContext *s)
 904 {
 905     int i, frame_size;
 906
 907     frame_size = 0
 908         + LINKAGE_AREA_SIZE
 909         + TCG_STATIC_CALL_ARGS_SIZE
 910         + ARRAY_SIZE (tcg_target_callee_save_regs) * 4
 911         ;
 912     frame_size = (frame_size + 15) & ~15;
 913
 914 #ifdef _CALL_AIX
 915     {
 916         uint32_t addr;
 917
 918         /* First emit adhoc function descriptor */
 919         addr = (uint32_t) s->code_ptr + 12;
 920         tcg_out32 (s, addr);        /* entry point */
 921         s->code_ptr += 8;           /* skip TOC and environment pointer */
 922     }
 923 #endif
 924     tcg_out32 (s, MFSPR | RT (0) | LR);
 925     tcg_out32 (s, STWU | RS (1) | RA (1) | (-frame_size & 0xffff));
 926     for (i = 0; i < ARRAY_SIZE (tcg_target_callee_save_regs); ++i)
 927         tcg_out32 (s, (STW
 928                        | RS (tcg_target_callee_save_regs[i])
 929                        | RA (1)
 930                        | (i * 4 + LINKAGE_AREA_SIZE + TCG_STATIC_CALL_ARGS_SIZE)
 931                        )
 932             );
 933     tcg_out32 (s, STW | RS (0) | RA (1) | (frame_size + LR_OFFSET));
 934
 935 #ifdef CONFIG_USE_GUEST_BASE
 936     tcg_out_movi (s, TCG_TYPE_I32, TCG_GUEST_BASE_REG, GUEST_BASE);
 937 #endif
 938
 939     tcg_out32 (s, MTSPR | RS (3) | CTR);
 940     tcg_out32 (s, BCCTR | BO_ALWAYS);
 941     tb_ret_addr = s->code_ptr;
 942
 943     for (i = 0; i < ARRAY_SIZE (tcg_target_callee_save_regs); ++i)
 944         tcg_out32 (s, (LWZ
 945                        | RT (tcg_target_callee_save_regs[i])
 946                        | RA (1)
 947                        | (i * 4 + LINKAGE_AREA_SIZE + TCG_STATIC_CALL_ARGS_SIZE)
 948                        )
 949             );
 950     tcg_out32 (s, LWZ | RT (0) | RA (1) | (frame_size + LR_OFFSET));
 951     tcg_out32 (s, MTSPR | RS (0) | LR);
 952     tcg_out32 (s, ADDI | RT (1) | RA (1) | frame_size);
 953     tcg_out32 (s, BCLR | BO_ALWAYS);
 954 }
 955
 956 static void tcg_out_ld (TCGContext *s, TCGType type, int ret, int arg1,
 957                         tcg_target_long arg2)
 958 {
 959     tcg_out_ldst (s, ret, arg1, arg2, LWZ, LWZX);
 960 }
 961
 962 static void tcg_out_st (TCGContext *s, TCGType type, int arg, int arg1,
 963                         tcg_target_long arg2)
 964 {
 965     tcg_out_ldst (s, arg, arg1, arg2, STW, STWX);
 966 }
 967
 968 static void ppc_addi (TCGContext *s, int rt, int ra, tcg_target_long si)
 969 {
 970     if (!si && rt == ra)
 971         return;
 972
 973     if (si == (int16_t) si)
 974         tcg_out32 (s, ADDI | RT (rt) | RA (ra) | (si & 0xffff));
 975     else {
 976         uint16_t h = ((si >> 16) & 0xffff) + ((uint16_t) si >> 15);
 977         tcg_out32 (s, ADDIS | RT (rt) | RA (ra) | h);
 978         tcg_out32 (s, ADDI | RT (rt) | RA (rt) | (si & 0xffff));
 979     }
 980 }
 981
 982 static void tcg_out_addi(TCGContext *s, int reg, tcg_target_long val)
 983 {
 984     ppc_addi (s, reg, reg, val);
 985 }
 986
 987 static void tcg_out_cmp (TCGContext *s, int cond, TCGArg arg1, TCGArg arg2,
 988                          int const_arg2, int cr)
 989 {
 990     int imm;
 991     uint32_t op;
 992
 993     switch (cond) {
 994     case TCG_COND_EQ:
 995     case TCG_COND_NE:
 996         if (const_arg2) {
 997             if ((int16_t) arg2 == arg2) {
 998                 op = CMPI;
 999                 imm = 1;
1000                 break;
1001             }
1002             else if ((uint16_t) arg2 == arg2) {
1003                 op = CMPLI;
1004                 imm = 1;
1005                 break;
1006             }
1007         }
1008         op = CMPL;
1009         imm = 0;
1010         break;
1011
1012     case TCG_COND_LT:
1013     case TCG_COND_GE:
1014     case TCG_COND_LE:
1015     case TCG_COND_GT:
1016         if (const_arg2) {
1017             if ((int16_t) arg2 == arg2) {
1018                 op = CMPI;
1019                 imm = 1;
1020                 break;
1021             }
1022         }
1023         op = CMP;
1024         imm = 0;
1025         break;
1026
1027     case TCG_COND_LTU:
1028     case TCG_COND_GEU:
1029     case TCG_COND_LEU:
1030     case TCG_COND_GTU:
1031         if (const_arg2) {
1032             if ((uint16_t) arg2 == arg2) {
1033                 op = CMPLI;
1034                 imm = 1;
1035                 break;
1036             }
1037         }
1038         op = CMPL;
1039         imm = 0;
1040         break;
1041
1042     default:
1043         tcg_abort ();
1044     }
1045     op |= BF (cr);
1046
1047     if (imm)
1048         tcg_out32 (s, op | RA (arg1) | (arg2 & 0xffff));
1049     else {
1050         if (const_arg2) {
1051             tcg_out_movi (s, TCG_TYPE_I32, 0, arg2);
1052             tcg_out32 (s, op | RA (arg1) | RB (0));
1053         }
1054         else
1055             tcg_out32 (s, op | RA (arg1) | RB (arg2));
1056     }
1057
1058 }
1059
1060 static void tcg_out_bc (TCGContext *s, int bc, int label_index)
1061 {
1062     TCGLabel *l = &s->labels[label_index];
1063
1064     if (l->has_value)
1065         tcg_out32 (s, bc | reloc_pc14_val (s->code_ptr, l->u.value));
1066     else {
1067         uint16_t val = *(uint16_t *) &s->code_ptr[2];
1068
1069         /* Thanks to Andrzej Zaborowski */
1070         tcg_out32 (s, bc | (val & 0xfffc));
1071         tcg_out_reloc (s, s->code_ptr - 4, R_PPC_REL14, label_index, 0);
1072     }
1073 }
1074
1075 static void tcg_out_cr7eq_from_cond (TCGContext *s, const TCGArg *args,
1076                                      const int *const_args)
1077 {
1078     TCGCond cond = args[4];
1079     int op;
1080     struct { int bit1; int bit2; int cond2; } bits[] = {
1081         [TCG_COND_LT ] = { CR_LT, CR_LT, TCG_COND_LT  },
1082         [TCG_COND_LE ] = { CR_LT, CR_GT, TCG_COND_LT  },
1083         [TCG_COND_GT ] = { CR_GT, CR_GT, TCG_COND_GT  },
1084         [TCG_COND_GE ] = { CR_GT, CR_LT, TCG_COND_GT  },
1085         [TCG_COND_LTU] = { CR_LT, CR_LT, TCG_COND_LTU },
1086         [TCG_COND_LEU] = { CR_LT, CR_GT, TCG_COND_LTU },
1087         [TCG_COND_GTU] = { CR_GT, CR_GT, TCG_COND_GTU },
1088         [TCG_COND_GEU] = { CR_GT, CR_LT, TCG_COND_GTU },
1089     }, *b = &bits[cond];
1090
1091     switch (cond) {
1092     case TCG_COND_EQ:
1093     case TCG_COND_NE:
1094         op = (cond == TCG_COND_EQ) ? CRAND : CRNAND;
1095         tcg_out_cmp (s, cond, args[0], args[2], const_args[2], 6);
1096         tcg_out_cmp (s, cond, args[1], args[3], const_args[3], 7);
1097         tcg_out32 (s, op | BT (7, CR_EQ) | BA (6, CR_EQ) | BB (7, CR_EQ));
1098         break;
1099     case TCG_COND_LT:
1100     case TCG_COND_LE:
1101     case TCG_COND_GT:
1102     case TCG_COND_GE:
1103     case TCG_COND_LTU:
1104     case TCG_COND_LEU:
1105     case TCG_COND_GTU:
1106     case TCG_COND_GEU:
1107         op = (b->bit1 != b->bit2) ? CRANDC : CRAND;
1108         tcg_out_cmp (s, b->cond2, args[1], args[3], const_args[3], 5);
1109         tcg_out_cmp (s, TCG_COND_EQ, args[1], args[3], const_args[3], 6);
1110         tcg_out_cmp (s, cond, args[0], args[2], const_args[2], 7);
1111         tcg_out32 (s, op | BT (7, CR_EQ) | BA (6, CR_EQ) | BB (7, b->bit2));
1112         tcg_out32 (s, CROR | BT (7, CR_EQ) | BA (5, b->bit1) | BB (7, CR_EQ));
1113         break;
1114     default:
1115         tcg_abort();
1116     }
1117 }
1118
1119 static void tcg_out_setcond (TCGContext *s, TCGCond cond, TCGArg arg0,
1120                              TCGArg arg1, TCGArg arg2, int const_arg2)
1121 {
1122     int crop, sh, arg;
1123
1124     switch (cond) {
1125     case TCG_COND_EQ:
1126         if (const_arg2) {
1127             if (!arg2) {
1128                 arg = arg1;
1129             }
1130             else {
1131                 arg = 0;
1132                 if ((uint16_t) arg2 == arg2) {
1133                     tcg_out32 (s, XORI | RS (arg1) | RA (0) | arg2);
1134                 }
1135                 else {
1136                     tcg_out_movi (s, TCG_TYPE_I32, 0, arg2);
1137                     tcg_out32 (s, XOR | SAB (arg1, 0, 0));
1138                 }
1139             }
1140         }
1141         else {
1142             arg = 0;
1143             tcg_out32 (s, XOR | SAB (arg1, 0, arg2));
1144         }
1145         tcg_out32 (s, CNTLZW | RS (arg) | RA (0));
1146         tcg_out32 (s, (RLWINM
1147                        | RA (arg0)
1148                        | RS (0)
1149                        | SH (27)
1150                        | MB (5)
1151                        | ME (31)
1152                        )
1153             );
1154         break;
1155
1156     case TCG_COND_NE:
1157         if (const_arg2) {
1158             if (!arg2) {
1159                 arg = arg1;
1160             }
1161             else {
1162                 arg = 0;
1163                 if ((uint16_t) arg2 == arg2) {
1164                     tcg_out32 (s, XORI | RS (arg1) | RA (0) | arg2);
1165                 }
1166                 else {
1167                     tcg_out_movi (s, TCG_TYPE_I32, 0, arg2);
1168                     tcg_out32 (s, XOR | SAB (arg1, 0, 0));
1169                 }
1170             }
1171         }
1172         else {
1173             arg = 0;
1174             tcg_out32 (s, XOR | SAB (arg1, 0, arg2));
1175         }
1176
1177         if (arg == arg1 && arg1 == arg0) {
1178             tcg_out32 (s, ADDIC | RT (0) | RA (arg) | 0xffff);
1179             tcg_out32 (s, SUBFE | TAB (arg0, 0, arg));
1180         }
1181         else {
1182             tcg_out32 (s, ADDIC | RT (arg0) | RA (arg) | 0xffff);
1183             tcg_out32 (s, SUBFE | TAB (arg0, arg0, arg));
1184         }
1185         break;
1186
1187     case TCG_COND_GT:
1188     case TCG_COND_GTU:
1189         sh = 30;
1190         crop = 0;
1191         goto crtest;
1192
1193     case TCG_COND_LT:
1194     case TCG_COND_LTU:
1195         sh = 29;
1196         crop = 0;
1197         goto crtest;
1198
1199     case TCG_COND_GE:
1200     case TCG_COND_GEU:
1201         sh = 31;
1202         crop = CRNOR | BT (7, CR_EQ) | BA (7, CR_LT) | BB (7, CR_LT);
1203         goto crtest;
1204
1205     case TCG_COND_LE:
1206     case TCG_COND_LEU:
1207         sh = 31;
1208         crop = CRNOR | BT (7, CR_EQ) | BA (7, CR_GT) | BB (7, CR_GT);
1209     crtest:
1210         tcg_out_cmp (s, cond, arg1, arg2, const_arg2, 7);
1211         if (crop) tcg_out32 (s, crop);
1212         tcg_out32 (s, MFCR | RT (0));
1213         tcg_out32 (s, (RLWINM
1214                        | RA (arg0)
1215                        | RS (0)
1216                        | SH (sh)
1217                        | MB (31)
1218                        | ME (31)
1219                        )
1220             );
1221         break;
1222
1223     default:
1224         tcg_abort ();
1225     }
1226 }
1227
1228 static void tcg_out_setcond2 (TCGContext *s, const TCGArg *args,
1229                               const int *const_args)
1230 {
1231     tcg_out_cr7eq_from_cond (s, args + 1, const_args + 1);
1232     tcg_out32 (s, MFCR | RT (0));
1233     tcg_out32 (s, (RLWINM
1234                    | RA (args[0])
1235                    | RS (0)
1236                    | SH (31)
1237                    | MB (31)
1238                    | ME (31)
1239                    )
1240         );
1241 }
1242
1243 static void tcg_out_brcond (TCGContext *s, TCGCond cond,
1244                             TCGArg arg1, TCGArg arg2, int const_arg2,
1245                             int label_index)
1246 {
1247     tcg_out_cmp (s, cond, arg1, arg2, const_arg2, 7);
1248     tcg_out_bc (s, tcg_to_bc[cond], label_index);
1249 }
1250
1251 /* XXX: we implement it at the target level to avoid having to
1252    handle cross basic blocks temporaries */
1253 static void tcg_out_brcond2 (TCGContext *s, const TCGArg *args,
1254                              const int *const_args)
1255 {
1256     tcg_out_cr7eq_from_cond (s, args, const_args);
1257     tcg_out_bc (s, (BC | BI (7, CR_EQ) | BO_COND_TRUE), args[5]);
1258 }
1259
1260 void ppc_tb_set_jmp_target (unsigned long jmp_addr, unsigned long addr)
1261 {
1262     uint32_t *ptr;
1263     long disp = addr - jmp_addr;
1264     unsigned long patch_size;
1265
1266     ptr = (uint32_t *)jmp_addr;
1267
1268     if ((disp << 6) >> 6 != disp) {
1269         ptr[0] = 0x3c000000 | (addr >> 16);    /* lis 0,addr@ha */
1270         ptr[1] = 0x60000000 | (addr & 0xffff); /* la  0,addr@l(0) */
1271         ptr[2] = 0x7c0903a6;                   /* mtctr 0 */
1272         ptr[3] = 0x4e800420;                   /* brctr */
1273         patch_size = 16;
1274     } else {
1275         /* patch the branch destination */
1276         if (disp != 16) {
1277             *ptr = 0x48000000 | (disp & 0x03fffffc); /* b disp */
1278             patch_size = 4;
1279         } else {
1280             ptr[0] = 0x60000000; /* nop */
1281             ptr[1] = 0x60000000;
1282             ptr[2] = 0x60000000;
1283             ptr[3] = 0x60000000;
1284             patch_size = 16;
1285         }
1286     }
1287     /* flush icache */
1288     flush_icache_range(jmp_addr, jmp_addr + patch_size);
1289 }
1290
1291 static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args,
1292                        const int *const_args)
1293 {
1294     switch (opc) {
1295     case INDEX_op_exit_tb:
1296         tcg_out_movi (s, TCG_TYPE_I32, TCG_REG_R3, args[0]);
1297         tcg_out_b (s, 0, (tcg_target_long) tb_ret_addr);
1298         break;
1299     case INDEX_op_goto_tb:
1300         if (s->tb_jmp_offset) {
1301             /* direct jump method */
1302
1303             s->tb_jmp_offset[args[0]] = s->code_ptr - s->code_buf;
1304             s->code_ptr += 16;
1305         }
1306         else {
1307             tcg_abort ();
1308         }
1309         s->tb_next_offset[args[0]] = s->code_ptr - s->code_buf;
1310         break;
1311     case INDEX_op_br:
1312         {
1313             TCGLabel *l = &s->labels[args[0]];
1314
1315             if (l->has_value) {
1316                 tcg_out_b (s, 0, l->u.value);
1317             }
1318             else {
1319                 uint32_t val = *(uint32_t *) s->code_ptr;
1320
1321                 /* Thanks to Andrzej Zaborowski */
1322                 tcg_out32 (s, B | (val & 0x3fffffc));
1323                 tcg_out_reloc (s, s->code_ptr - 4, R_PPC_REL24, args[0], 0);
1324             }
1325         }
1326         break;
1327     case INDEX_op_call:
1328         tcg_out_call (s, args[0], const_args[0]);
1329         break;
1330     case INDEX_op_jmp:
1331         if (const_args[0]) {
1332             tcg_out_b (s, 0, args[0]);
1333         }
1334         else {
1335             tcg_out32 (s, MTSPR | RS (args[0]) | CTR);
1336             tcg_out32 (s, BCCTR | BO_ALWAYS);
1337         }
1338         break;
1339     case INDEX_op_movi_i32:
1340         tcg_out_movi(s, TCG_TYPE_I32, args[0], args[1]);
1341         break;
1342     case INDEX_op_ld8u_i32:
1343         tcg_out_ldst (s, args[0], args[1], args[2], LBZ, LBZX);
1344         break;
1345     case INDEX_op_ld8s_i32:
1346         tcg_out_ldst (s, args[0], args[1], args[2], LBZ, LBZX);
1347         tcg_out32 (s, EXTSB | RS (args[0]) | RA (args[0]));
1348         break;
1349     case INDEX_op_ld16u_i32:
1350         tcg_out_ldst (s, args[0], args[1], args[2], LHZ, LHZX);
1351         break;
1352     case INDEX_op_ld16s_i32:
1353         tcg_out_ldst (s, args[0], args[1], args[2], LHA, LHAX);
1354         break;
1355     case INDEX_op_ld_i32:
1356         tcg_out_ldst (s, args[0], args[1], args[2], LWZ, LWZX);
1357         break;
1358     case INDEX_op_st8_i32:
1359         tcg_out_ldst (s, args[0], args[1], args[2], STB, STBX);
1360         break;
1361     case INDEX_op_st16_i32:
1362         tcg_out_ldst (s, args[0], args[1], args[2], STH, STHX);
1363         break;
1364     case INDEX_op_st_i32:
1365         tcg_out_ldst (s, args[0], args[1], args[2], STW, STWX);
1366         break;
1367
1368     case INDEX_op_add_i32:
1369         if (const_args[2])
1370             ppc_addi (s, args[0], args[1], args[2]);
1371         else
1372             tcg_out32 (s, ADD | TAB (args[0], args[1], args[2]));
1373         break;
1374     case INDEX_op_sub_i32:
1375         if (const_args[2])
1376             ppc_addi (s, args[0], args[1], -args[2]);
1377         else
1378             tcg_out32 (s, SUBF | TAB (args[0], args[2], args[1]));
1379         break;
1380
1381     case INDEX_op_and_i32:
1382         if (const_args[2]) {
1383             uint32_t c;
1384
1385             c = args[2];
1386
1387             if (!c) {
1388                 tcg_out_movi (s, TCG_TYPE_I32, args[0], 0);
1389                 break;
1390             }
1391 #ifdef __PPU__
1392             uint32_t t, n;
1393             int mb, me;
1394
1395             n = c ^ -(c & 1);
1396             t = n + (n & -n);
1397
1398             if ((t & (t - 1)) == 0) {
1399                 int lzc, tzc;
1400
1401                 if ((c & 0x80000001) == 0x80000001) {
1402                     lzc = clz32 (n);
1403                     tzc = ctz32 (n);
1404
1405                     mb = 32 - tzc;
1406                     me = lzc - 1;
1407                 }
1408                 else {
1409                     lzc = clz32 (c);
1410                     tzc = ctz32 (c);
1411
1412                     mb = lzc;
1413                     me = 31 - tzc;
1414                 }
1415
1416                 tcg_out32 (s, (RLWINM
1417                                | RA (args[0])
1418                                | RS (args[1])
1419                                | SH (0)
1420                                | MB (mb)
1421                                | ME (me)
1422                                )
1423                     );
1424             }
1425             else
1426 #endif /* !__PPU__ */
1427             {
1428                 if ((c & 0xffff) == c)
1429                     tcg_out32 (s, ANDI | RS (args[1]) | RA (args[0]) | c);
1430                 else if ((c & 0xffff0000) == c)
1431                     tcg_out32 (s, ANDIS | RS (args[1]) | RA (args[0])
1432                                | ((c >> 16) & 0xffff));
1433                 else {
1434                     tcg_out_movi (s, TCG_TYPE_I32, 0, c);
1435                     tcg_out32 (s, AND | SAB (args[1], args[0], 0));
1436                 }
1437             }
1438         }
1439         else
1440             tcg_out32 (s, AND | SAB (args[1], args[0], args[2]));
1441         break;
1442     case INDEX_op_or_i32:
1443         if (const_args[2]) {
1444             if (args[2] & 0xffff) {
1445                 tcg_out32 (s, ORI | RS (args[1])  | RA (args[0])
1446                            | (args[2] & 0xffff));
1447                 if (args[2] >> 16)
1448                     tcg_out32 (s, ORIS | RS (args[0])  | RA (args[0])
1449                                | ((args[2] >> 16) & 0xffff));
1450             }
1451             else {
1452                 tcg_out32 (s, ORIS | RS (args[1])  | RA (args[0])
1453                            | ((args[2] >> 16) & 0xffff));
1454             }
1455         }
1456         else
1457             tcg_out32 (s, OR | SAB (args[1], args[0], args[2]));
1458         break;
1459     case INDEX_op_xor_i32:
1460         if (const_args[2]) {
1461             if ((args[2] & 0xffff) == args[2])
1462                 tcg_out32 (s, XORI | RS (args[1])  | RA (args[0])
1463                            | (args[2] & 0xffff));
1464             else if ((args[2] & 0xffff0000) == args[2])
1465                 tcg_out32 (s, XORIS | RS (args[1])  | RA (args[0])
1466                            | ((args[2] >> 16) & 0xffff));
1467             else {
1468                 tcg_out_movi (s, TCG_TYPE_I32, 0, args[2]);
1469                 tcg_out32 (s, XOR | SAB (args[1], args[0], 0));
1470             }
1471         }
1472         else
1473             tcg_out32 (s, XOR | SAB (args[1], args[0], args[2]));
1474         break;
1475     case INDEX_op_andc_i32:
1476         tcg_out32 (s, ANDC | SAB (args[1], args[0], args[2]));
1477         break;
1478     case INDEX_op_orc_i32:
1479         tcg_out32 (s, ORC | SAB (args[1], args[0], args[2]));
1480         break;
1481     case INDEX_op_eqv_i32:
1482         tcg_out32 (s, EQV | SAB (args[1], args[0], args[2]));
1483         break;
1484     case INDEX_op_nand_i32:
1485         tcg_out32 (s, NAND | SAB (args[1], args[0], args[2]));
1486         break;
1487     case INDEX_op_nor_i32:
1488         tcg_out32 (s, NOR | SAB (args[1], args[0], args[2]));
1489         break;
1490
1491     case INDEX_op_mul_i32:
1492         if (const_args[2]) {
1493             if (args[2] == (int16_t) args[2])
1494                 tcg_out32 (s, MULLI | RT (args[0]) | RA (args[1])
1495                            | (args[2] & 0xffff));
1496             else {
1497                 tcg_out_movi (s, TCG_TYPE_I32, 0, args[2]);
1498                 tcg_out32 (s, MULLW | TAB (args[0], args[1], 0));
1499             }
1500         }
1501         else
1502             tcg_out32 (s, MULLW | TAB (args[0], args[1], args[2]));
1503         break;
1504
1505     case INDEX_op_div_i32:
1506         tcg_out32 (s, DIVW | TAB (args[0], args[1], args[2]));
1507         break;
1508
1509     case INDEX_op_divu_i32:
1510         tcg_out32 (s, DIVWU | TAB (args[0], args[1], args[2]));
1511         break;
1512
1513     case INDEX_op_rem_i32:
1514         tcg_out32 (s, DIVW | TAB (0, args[1], args[2]));
1515         tcg_out32 (s, MULLW | TAB (0, 0, args[2]));
1516         tcg_out32 (s, SUBF | TAB (args[0], 0, args[1]));
1517         break;
1518
1519     case INDEX_op_remu_i32:
1520         tcg_out32 (s, DIVWU | TAB (0, args[1], args[2]));
1521         tcg_out32 (s, MULLW | TAB (0, 0, args[2]));
1522         tcg_out32 (s, SUBF | TAB (args[0], 0, args[1]));
1523         break;
1524
1525     case INDEX_op_mulu2_i32:
1526         if (args[0] == args[2] || args[0] == args[3]) {
1527             tcg_out32 (s, MULLW | TAB (0, args[2], args[3]));
1528             tcg_out32 (s, MULHWU | TAB (args[1], args[2], args[3]));
1529             tcg_out_mov (s, args[0], 0);
1530         }
1531         else {
1532             tcg_out32 (s, MULLW | TAB (args[0], args[2], args[3]));
1533             tcg_out32 (s, MULHWU | TAB (args[1], args[2], args[3]));
1534         }
1535         break;
1536
1537     case INDEX_op_shl_i32:
1538         if (const_args[2]) {
1539             tcg_out32 (s, (RLWINM
1540                            | RA (args[0])
1541                            | RS (args[1])
1542                            | SH (args[2])
1543                            | MB (0)
1544                            | ME (31 - args[2])
1545                            )
1546                 );
1547         }
1548         else
1549             tcg_out32 (s, SLW | SAB (args[1], args[0], args[2]));
1550         break;
1551     case INDEX_op_shr_i32:
1552         if (const_args[2]) {
1553             tcg_out32 (s, (RLWINM
1554                            | RA (args[0])
1555                            | RS (args[1])
1556                            | SH (32 - args[2])
1557                            | MB (args[2])
1558                            | ME (31)
1559                            )
1560                 );
1561         }
1562         else
1563             tcg_out32 (s, SRW | SAB (args[1], args[0], args[2]));
1564         break;
1565     case INDEX_op_sar_i32:
1566         if (const_args[2])
1567             tcg_out32 (s, SRAWI | RS (args[1]) | RA (args[0]) | SH (args[2]));
1568         else
1569             tcg_out32 (s, SRAW | SAB (args[1], args[0], args[2]));
1570         break;
1571     case INDEX_op_rotl_i32:
1572         {
1573             int op = 0
1574                 | RA (args[0])
1575                 | RS (args[1])
1576                 | MB (0)
1577                 | ME (31)
1578                 | (const_args[2] ? RLWINM | SH (args[2])
1579                                  : RLWNM | RB (args[2]))
1580                 ;
1581             tcg_out32 (s, op);
1582         }
1583         break;
1584     case INDEX_op_rotr_i32:
1585         if (const_args[2]) {
1586             if (!args[2]) {
1587                 tcg_out_mov (s, args[0], args[1]);
1588             }
1589             else {
1590                 tcg_out32 (s, RLWINM
1591                            | RA (args[0])
1592                            | RS (args[1])
1593                            | SH (32 - args[2])
1594                            | MB (0)
1595                            | ME (31)
1596                     );
1597             }
1598         }
1599         else {
1600             tcg_out32 (s, SUBFIC | RT (0) | RA (args[2]) | 32);
1601             tcg_out32 (s, RLWNM
1602                        | RA (args[0])
1603                        | RS (args[1])
1604                        | RB (0)
1605                        | MB (0)
1606                        | ME (31)
1607                 );
1608         }
1609         break;
1610
1611     case INDEX_op_add2_i32:
1612         if (args[0] == args[3] || args[0] == args[5]) {
1613             tcg_out32 (s, ADDC | TAB (0, args[2], args[4]));
1614             tcg_out32 (s, ADDE | TAB (args[1], args[3], args[5]));
1615             tcg_out_mov (s, args[0], 0);
1616         }
1617         else {
1618             tcg_out32 (s, ADDC | TAB (args[0], args[2], args[4]));
1619             tcg_out32 (s, ADDE | TAB (args[1], args[3], args[5]));
1620         }
1621         break;
1622     case INDEX_op_sub2_i32:
1623         if (args[0] == args[3] || args[0] == args[5]) {
1624             tcg_out32 (s, SUBFC | TAB (0, args[4], args[2]));
1625             tcg_out32 (s, SUBFE | TAB (args[1], args[5], args[3]));
1626             tcg_out_mov (s, args[0], 0);
1627         }
1628         else {
1629             tcg_out32 (s, SUBFC | TAB (args[0], args[4], args[2]));
1630             tcg_out32 (s, SUBFE | TAB (args[1], args[5], args[3]));
1631         }
1632         break;
1633
1634     case INDEX_op_brcond_i32:
1635         /*
1636           args[0] = r0
1637           args[1] = r1
1638           args[2] = cond
1639           args[3] = r1 is const
1640           args[4] = label_index
1641         */
1642         tcg_out_brcond (s, args[2], args[0], args[1], const_args[1], args[3]);
1643         break;
1644     case INDEX_op_brcond2_i32:
1645         tcg_out_brcond2(s, args, const_args);
1646         break;
1647
1648     case INDEX_op_neg_i32:
1649         tcg_out32 (s, NEG | RT (args[0]) | RA (args[1]));
1650         break;
1651
1652     case INDEX_op_not_i32:
1653         tcg_out32 (s, NOR | SAB (args[1], args[0], args[1]));
1654         break;
1655
1656     case INDEX_op_qemu_ld8u:
1657         tcg_out_qemu_ld(s, args, 0);
1658         break;
1659     case INDEX_op_qemu_ld8s:
1660         tcg_out_qemu_ld(s, args, 0 | 4);
1661         break;
1662     case INDEX_op_qemu_ld16u:
1663         tcg_out_qemu_ld(s, args, 1);
1664         break;
1665     case INDEX_op_qemu_ld16s:
1666         tcg_out_qemu_ld(s, args, 1 | 4);
1667         break;
1668     case INDEX_op_qemu_ld32:
1669         tcg_out_qemu_ld(s, args, 2);
1670         break;
1671     case INDEX_op_qemu_ld64:
1672         tcg_out_qemu_ld(s, args, 3);
1673         break;
1674     case INDEX_op_qemu_st8:
1675         tcg_out_qemu_st(s, args, 0);
1676         break;
1677     case INDEX_op_qemu_st16:
1678         tcg_out_qemu_st(s, args, 1);
1679         break;
1680     case INDEX_op_qemu_st32:
1681         tcg_out_qemu_st(s, args, 2);
1682         break;
1683     case INDEX_op_qemu_st64:
1684         tcg_out_qemu_st(s, args, 3);
1685         break;
1686
1687     case INDEX_op_ext8s_i32:
1688         tcg_out32 (s, EXTSB | RS (args[1]) | RA (args[0]));
1689         break;
1690     case INDEX_op_ext8u_i32:
1691         tcg_out32 (s, RLWINM
1692                    | RA (args[0])
1693                    | RS (args[1])
1694                    | SH (0)
1695                    | MB (24)
1696                    | ME (31)
1697             );
1698         break;
1699     case INDEX_op_ext16s_i32:
1700         tcg_out32 (s, EXTSH | RS (args[1]) | RA (args[0]));
1701         break;
1702     case INDEX_op_ext16u_i32:
1703         tcg_out32 (s, RLWINM
1704                    | RA (args[0])
1705                    | RS (args[1])
1706                    | SH (0)
1707                    | MB (16)
1708                    | ME (31)
1709             );
1710         break;
1711
1712     case INDEX_op_setcond_i32:
1713         tcg_out_setcond (s, args[3], args[0], args[1], args[2], const_args[2]);
1714         break;
1715     case INDEX_op_setcond2_i32:
1716         tcg_out_setcond2 (s, args, const_args);
1717         break;
1718
1719     case INDEX_op_bswap16_i32:
1720         /* Stolen from gcc's builtin_bswap16 */
1721
1722         /* a1 = abcd */
1723
1724         /* r0 = (a1 << 8) & 0xff00 # 00d0 */
1725         tcg_out32 (s, RLWINM
1726                    | RA (0)
1727                    | RS (args[1])
1728                    | SH (8)
1729                    | MB (16)
1730                    | ME (23)
1731             );
1732
1733         /* a0 = rotate_left (a1, 24) & 0xff # 000c */
1734         tcg_out32 (s, RLWINM
1735                    | RA (args[0])
1736                    | RS (args[1])
1737                    | SH (24)
1738                    | MB (24)
1739                    | ME (31)
1740             );
1741
1742         /* a0 = a0 | r0 # 00dc */
1743         tcg_out32 (s, OR | SAB (0, args[0], args[0]));
1744         break;
1745
1746     case INDEX_op_bswap32_i32:
1747         /* Stolen from gcc's builtin_bswap32 */
1748         {
1749             int a0 = args[0];
1750
1751             /* a1 = args[1] # abcd */
1752
1753             if (a0 == args[1]) {
1754                 a0 = 0;
1755             }
1756
1757             /* a0 = rotate_left (a1, 8) # bcda */
1758             tcg_out32 (s, RLWINM
1759                        | RA (a0)
1760                        | RS (args[1])
1761                        | SH (8)
1762                        | MB (0)
1763                        | ME (31)
1764                 );
1765
1766             /* a0 = (a0 & ~0xff000000) | ((a1 << 24) & 0xff000000) # dcda */
1767             tcg_out32 (s, RLWIMI
1768                        | RA (a0)
1769                        | RS (args[1])
1770                        | SH (24)
1771                        | MB (0)
1772                        | ME (7)
1773                 );
1774
1775             /* a0 = (a0 & ~0x0000ff00) | ((a1 << 24) & 0x0000ff00) # dcba */
1776             tcg_out32 (s, RLWIMI
1777                        | RA (a0)
1778                        | RS (args[1])
1779                        | SH (24)
1780                        | MB (16)
1781                        | ME (23)
1782                 );
1783
1784             if (!a0) {
1785                 tcg_out_mov (s, args[0], a0);
1786             }
1787         }
1788         break;
1789
1790     default:
1791         tcg_dump_ops (s, stderr);
1792         tcg_abort ();
1793     }
1794 }
1795
1796 static const TCGTargetOpDef ppc_op_defs[] = {
1797     { INDEX_op_exit_tb, { } },
1798     { INDEX_op_goto_tb, { } },
1799     { INDEX_op_call, { "ri" } },
1800     { INDEX_op_jmp, { "ri" } },
1801     { INDEX_op_br, { } },
1802
1803     { INDEX_op_mov_i32, { "r", "r" } },
1804     { INDEX_op_movi_i32, { "r" } },
1805     { INDEX_op_ld8u_i32, { "r", "r" } },
1806     { INDEX_op_ld8s_i32, { "r", "r" } },
1807     { INDEX_op_ld16u_i32, { "r", "r" } },
1808     { INDEX_op_ld16s_i32, { "r", "r" } },
1809     { INDEX_op_ld_i32, { "r", "r" } },
1810     { INDEX_op_st8_i32, { "r", "r" } },
1811     { INDEX_op_st16_i32, { "r", "r" } },
1812     { INDEX_op_st_i32, { "r", "r" } },
1813
1814     { INDEX_op_add_i32, { "r", "r", "ri" } },
1815     { INDEX_op_mul_i32, { "r", "r", "ri" } },
1816     { INDEX_op_div_i32, { "r", "r", "r" } },
1817     { INDEX_op_divu_i32, { "r", "r", "r" } },
1818     { INDEX_op_rem_i32, { "r", "r", "r" } },
1819     { INDEX_op_remu_i32, { "r", "r", "r" } },
1820     { INDEX_op_mulu2_i32, { "r", "r", "r", "r" } },
1821     { INDEX_op_sub_i32, { "r", "r", "ri" } },
1822     { INDEX_op_and_i32, { "r", "r", "ri" } },
1823     { INDEX_op_or_i32, { "r", "r", "ri" } },
1824     { INDEX_op_xor_i32, { "r", "r", "ri" } },
1825
1826     { INDEX_op_shl_i32, { "r", "r", "ri" } },
1827     { INDEX_op_shr_i32, { "r", "r", "ri" } },
1828     { INDEX_op_sar_i32, { "r", "r", "ri" } },
1829
1830     { INDEX_op_rotl_i32, { "r", "r", "ri" } },
1831     { INDEX_op_rotr_i32, { "r", "r", "ri" } },
1832
1833     { INDEX_op_brcond_i32, { "r", "ri" } },
1834
1835     { INDEX_op_add2_i32, { "r", "r", "r", "r", "r", "r" } },
1836     { INDEX_op_sub2_i32, { "r", "r", "r", "r", "r", "r" } },
1837     { INDEX_op_brcond2_i32, { "r", "r", "r", "r" } },
1838
1839     { INDEX_op_neg_i32, { "r", "r" } },
1840     { INDEX_op_not_i32, { "r", "r" } },
1841
1842     { INDEX_op_andc_i32, { "r", "r", "r" } },
1843     { INDEX_op_orc_i32, { "r", "r", "r" } },
1844     { INDEX_op_eqv_i32, { "r", "r", "r" } },
1845     { INDEX_op_nand_i32, { "r", "r", "r" } },
1846     { INDEX_op_nor_i32, { "r", "r", "r" } },
1847
1848     { INDEX_op_setcond_i32, { "r", "r", "ri" } },
1849     { INDEX_op_setcond2_i32, { "r", "r", "r", "ri", "ri" } },
1850
1851     { INDEX_op_bswap16_i32, { "r", "r" } },
1852     { INDEX_op_bswap32_i32, { "r", "r" } },
1853
1854 #if TARGET_LONG_BITS == 32
1855     { INDEX_op_qemu_ld8u, { "r", "L" } },
1856     { INDEX_op_qemu_ld8s, { "r", "L" } },
1857     { INDEX_op_qemu_ld16u, { "r", "L" } },
1858     { INDEX_op_qemu_ld16s, { "r", "L" } },
1859     { INDEX_op_qemu_ld32, { "r", "L" } },
1860     { INDEX_op_qemu_ld64, { "r", "r", "L" } },
1861
1862     { INDEX_op_qemu_st8, { "K", "K" } },
1863     { INDEX_op_qemu_st16, { "K", "K" } },
1864     { INDEX_op_qemu_st32, { "K", "K" } },
1865     { INDEX_op_qemu_st64, { "M", "M", "M" } },
1866 #else
1867     { INDEX_op_qemu_ld8u, { "r", "L", "L" } },
1868     { INDEX_op_qemu_ld8s, { "r", "L", "L" } },
1869     { INDEX_op_qemu_ld16u, { "r", "L", "L" } },
1870     { INDEX_op_qemu_ld16s, { "r", "L", "L" } },
1871     { INDEX_op_qemu_ld32, { "r", "L", "L" } },
1872     { INDEX_op_qemu_ld64, { "r", "L", "L", "L" } },
1873
1874     { INDEX_op_qemu_st8, { "K", "K", "K" } },
1875     { INDEX_op_qemu_st16, { "K", "K", "K" } },
1876     { INDEX_op_qemu_st32, { "K", "K", "K" } },
1877     { INDEX_op_qemu_st64, { "M", "M", "M", "M" } },
1878 #endif
1879
1880     { INDEX_op_ext8s_i32, { "r", "r" } },
1881     { INDEX_op_ext8u_i32, { "r", "r" } },
1882     { INDEX_op_ext16s_i32, { "r", "r" } },
1883     { INDEX_op_ext16u_i32, { "r", "r" } },
1884
1885     { -1 },
1886 };
1887
1888 void tcg_target_init(TCGContext *s)
1889 {
1890     tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I32], 0, 0xffffffff);
1891     tcg_regset_set32(tcg_target_call_clobber_regs, 0,
1892                      (1 << TCG_REG_R0) |
1893 #ifdef _CALL_DARWIN
1894                      (1 << TCG_REG_R2) |
1895 #endif
1896                      (1 << TCG_REG_R3) |
1897                      (1 << TCG_REG_R4) |
1898                      (1 << TCG_REG_R5) |
1899                      (1 << TCG_REG_R6) |
1900                      (1 << TCG_REG_R7) |
1901                      (1 << TCG_REG_R8) |
1902                      (1 << TCG_REG_R9) |
1903                      (1 << TCG_REG_R10) |
1904                      (1 << TCG_REG_R11) |
1905                      (1 << TCG_REG_R12)
1906         );
1907
1908     tcg_regset_clear(s->reserved_regs);
1909     tcg_regset_set_reg(s->reserved_regs, TCG_REG_R0);
1910     tcg_regset_set_reg(s->reserved_regs, TCG_REG_R1);
1911 #ifndef _CALL_DARWIN
1912     tcg_regset_set_reg(s->reserved_regs, TCG_REG_R2);
1913 #endif
1914 #ifdef _CALL_SYSV
1915     tcg_regset_set_reg(s->reserved_regs, TCG_REG_R13);
1916 #endif
1917 #ifdef CONFIG_USE_GUEST_BASE
1918     tcg_regset_set_reg(s->reserved_regs, TCG_GUEST_BASE_REG);
1919 #endif
1920
1921     tcg_add_target_add_op_defs(ppc_op_defs);
1922 }