tcg/s390/tcg-target.c

   1 /*
   2  * Tiny Code Generator for QEMU
   3  *
   4  * Copyright (c) 2009 Ulrich Hecht <[email protected]>
   5  * Copyright (c) 2009 Alexander Graf <[email protected]>
   6  * Copyright (c) 2010 Richard Henderson <[email protected]>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24  * THE SOFTWARE.
  25  */
  26
  27 /* ??? The translation blocks produced by TCG are generally small enough to
  28    be entirely reachable with a 16-bit displacement.  Leaving the option for
  29    a 32-bit displacement here Just In Case.  */
  30 #define USE_LONG_BRANCHES 0
  31
  32 #define TCG_CT_CONST_32    0x0100
  33 #define TCG_CT_CONST_NEG   0x0200
  34 #define TCG_CT_CONST_ADDI  0x0400
  35 #define TCG_CT_CONST_MULI  0x0800
  36 #define TCG_CT_CONST_ANDI  0x1000
  37 #define TCG_CT_CONST_ORI   0x2000
  38 #define TCG_CT_CONST_XORI  0x4000
  39 #define TCG_CT_CONST_CMPI  0x8000
  40
  41 /* Several places within the instruction set 0 means "no register"
  42    rather than TCG_REG_R0.  */
  43 #define TCG_REG_NONE    0
  44
  45 /* A scratch register that may be be used throughout the backend.  */
  46 #define TCG_TMP0        TCG_REG_R14
  47
  48 #ifdef CONFIG_USE_GUEST_BASE
  49 #define TCG_GUEST_BASE_REG TCG_REG_R13
  50 #else
  51 #define TCG_GUEST_BASE_REG TCG_REG_R0
  52 #endif
  53
  54 #ifndef GUEST_BASE
  55 #define GUEST_BASE 0
  56 #endif
  57
  58
  59 /* All of the following instructions are prefixed with their instruction
  60    format, and are defined as 8- or 16-bit quantities, even when the two
  61    halves of the 16-bit quantity may appear 32 bits apart in the insn.
  62    This makes it easy to copy the values from the tables in Appendix B.  */
  63 typedef enum S390Opcode {
  64     RIL_AFI     = 0xc209,
  65     RIL_AGFI    = 0xc208,
  66     RIL_ALGFI   = 0xc20a,
  67     RIL_BRASL   = 0xc005,
  68     RIL_BRCL    = 0xc004,
  69     RIL_CFI     = 0xc20d,
  70     RIL_CGFI    = 0xc20c,
  71     RIL_CLFI    = 0xc20f,
  72     RIL_CLGFI   = 0xc20e,
  73     RIL_IIHF    = 0xc008,
  74     RIL_IILF    = 0xc009,
  75     RIL_LARL    = 0xc000,
  76     RIL_LGFI    = 0xc001,
  77     RIL_LGRL    = 0xc408,
  78     RIL_LLIHF   = 0xc00e,
  79     RIL_LLILF   = 0xc00f,
  80     RIL_LRL     = 0xc40d,
  81     RIL_MSFI    = 0xc201,
  82     RIL_MSGFI   = 0xc200,
  83     RIL_NIHF    = 0xc00a,
  84     RIL_NILF    = 0xc00b,
  85     RIL_OIHF    = 0xc00c,
  86     RIL_OILF    = 0xc00d,
  87     RIL_XIHF    = 0xc006,
  88     RIL_XILF    = 0xc007,
  89
  90     RI_AGHI     = 0xa70b,
  91     RI_AHI      = 0xa70a,
  92     RI_BRC      = 0xa704,
  93     RI_IIHH     = 0xa500,
  94     RI_IIHL     = 0xa501,
  95     RI_IILH     = 0xa502,
  96     RI_IILL     = 0xa503,
  97     RI_LGHI     = 0xa709,
  98     RI_LLIHH    = 0xa50c,
  99     RI_LLIHL    = 0xa50d,
 100     RI_LLILH    = 0xa50e,
 101     RI_LLILL    = 0xa50f,
 102     RI_MGHI     = 0xa70d,
 103     RI_MHI      = 0xa70c,
 104     RI_NIHH     = 0xa504,
 105     RI_NIHL     = 0xa505,
 106     RI_NILH     = 0xa506,
 107     RI_NILL     = 0xa507,
 108     RI_OIHH     = 0xa508,
 109     RI_OIHL     = 0xa509,
 110     RI_OILH     = 0xa50a,
 111     RI_OILL     = 0xa50b,
 112
 113     RIE_CGIJ    = 0xec7c,
 114     RIE_CGRJ    = 0xec64,
 115     RIE_CIJ     = 0xec7e,
 116     RIE_CLGRJ   = 0xec65,
 117     RIE_CLIJ    = 0xec7f,
 118     RIE_CLGIJ   = 0xec7d,
 119     RIE_CLRJ    = 0xec77,
 120     RIE_CRJ     = 0xec76,
 121
 122     RRE_AGR     = 0xb908,
 123     RRE_CGR     = 0xb920,
 124     RRE_CLGR    = 0xb921,
 125     RRE_DLGR    = 0xb987,
 126     RRE_DLR     = 0xb997,
 127     RRE_DSGFR   = 0xb91d,
 128     RRE_DSGR    = 0xb90d,
 129     RRE_LGBR    = 0xb906,
 130     RRE_LCGR    = 0xb903,
 131     RRE_LGFR    = 0xb914,
 132     RRE_LGHR    = 0xb907,
 133     RRE_LGR     = 0xb904,
 134     RRE_LLGCR   = 0xb984,
 135     RRE_LLGFR   = 0xb916,
 136     RRE_LLGHR   = 0xb985,
 137     RRE_LRVR    = 0xb91f,
 138     RRE_LRVGR   = 0xb90f,
 139     RRE_LTGR    = 0xb902,
 140     RRE_MSGR    = 0xb90c,
 141     RRE_MSR     = 0xb252,
 142     RRE_NGR     = 0xb980,
 143     RRE_OGR     = 0xb981,
 144     RRE_SGR     = 0xb909,
 145     RRE_XGR     = 0xb982,
 146
 147     RR_AR       = 0x1a,
 148     RR_BASR     = 0x0d,
 149     RR_BCR      = 0x07,
 150     RR_CLR      = 0x15,
 151     RR_CR       = 0x19,
 152     RR_DR       = 0x1d,
 153     RR_LCR      = 0x13,
 154     RR_LR       = 0x18,
 155     RR_LTR      = 0x12,
 156     RR_NR       = 0x14,
 157     RR_OR       = 0x16,
 158     RR_SR       = 0x1b,
 159     RR_XR       = 0x17,
 160
 161     RSY_RLL     = 0xeb1d,
 162     RSY_RLLG    = 0xeb1c,
 163     RSY_SLLG    = 0xeb0d,
 164     RSY_SRAG    = 0xeb0a,
 165     RSY_SRLG    = 0xeb0c,
 166
 167     RS_SLL      = 0x89,
 168     RS_SRA      = 0x8a,
 169     RS_SRL      = 0x88,
 170
 171     RXY_AG      = 0xe308,
 172     RXY_AY      = 0xe35a,
 173     RXY_CG      = 0xe320,
 174     RXY_CY      = 0xe359,
 175     RXY_LB      = 0xe376,
 176     RXY_LG      = 0xe304,
 177     RXY_LGB     = 0xe377,
 178     RXY_LGF     = 0xe314,
 179     RXY_LGH     = 0xe315,
 180     RXY_LHY     = 0xe378,
 181     RXY_LLGC    = 0xe390,
 182     RXY_LLGF    = 0xe316,
 183     RXY_LLGH    = 0xe391,
 184     RXY_LMG     = 0xeb04,
 185     RXY_LRV     = 0xe31e,
 186     RXY_LRVG    = 0xe30f,
 187     RXY_LRVH    = 0xe31f,
 188     RXY_LY      = 0xe358,
 189     RXY_STCY    = 0xe372,
 190     RXY_STG     = 0xe324,
 191     RXY_STHY    = 0xe370,
 192     RXY_STMG    = 0xeb24,
 193     RXY_STRV    = 0xe33e,
 194     RXY_STRVG   = 0xe32f,
 195     RXY_STRVH   = 0xe33f,
 196     RXY_STY     = 0xe350,
 197
 198     RX_A        = 0x5a,
 199     RX_C        = 0x59,
 200     RX_L        = 0x58,
 201     RX_LH       = 0x48,
 202     RX_ST       = 0x50,
 203     RX_STC      = 0x42,
 204     RX_STH      = 0x40,
 205 } S390Opcode;
 206
 207 #define LD_SIGNED      0x04
 208 #define LD_UINT8       0x00
 209 #define LD_INT8        (LD_UINT8 | LD_SIGNED)
 210 #define LD_UINT16      0x01
 211 #define LD_INT16       (LD_UINT16 | LD_SIGNED)
 212 #define LD_UINT32      0x02
 213 #define LD_INT32       (LD_UINT32 | LD_SIGNED)
 214 #define LD_UINT64      0x03
 215 #define LD_INT64       (LD_UINT64 | LD_SIGNED)
 216
 217 #ifndef NDEBUG
 218 static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
 219     "%r0", "%r1", "%r2", "%r3", "%r4", "%r5", "%r6", "%r7",
 220     "%r8", "%r9", "%r10" "%r11" "%r12" "%r13" "%r14" "%r15"
 221 };
 222 #endif
 223
 224 /* Since R6 is a potential argument register, choose it last of the
 225    call-saved registers.  Likewise prefer the call-clobbered registers
 226    in reverse order to maximize the chance of avoiding the arguments.  */
 227 static const int tcg_target_reg_alloc_order[] = {
 228     TCG_REG_R13,
 229     TCG_REG_R12,
 230     TCG_REG_R11,
 231     TCG_REG_R10,
 232     TCG_REG_R9,
 233     TCG_REG_R8,
 234     TCG_REG_R7,
 235     TCG_REG_R6,
 236     TCG_REG_R14,
 237     TCG_REG_R0,
 238     TCG_REG_R1,
 239     TCG_REG_R5,
 240     TCG_REG_R4,
 241     TCG_REG_R3,
 242     TCG_REG_R2,
 243 };
 244
 245 static const int tcg_target_call_iarg_regs[] = {
 246     TCG_REG_R2,
 247     TCG_REG_R3,
 248     TCG_REG_R4,
 249     TCG_REG_R5,
 250     TCG_REG_R6,
 251 };
 252
 253 static const int tcg_target_call_oarg_regs[] = {
 254     TCG_REG_R2,
 255 #if TCG_TARGET_REG_BITS == 32
 256     TCG_REG_R3
 257 #endif
 258 };
 259
 260 #define S390_CC_EQ      8
 261 #define S390_CC_LT      4
 262 #define S390_CC_GT      2
 263 #define S390_CC_OV      1
 264 #define S390_CC_NE      (S390_CC_LT | S390_CC_GT)
 265 #define S390_CC_LE      (S390_CC_LT | S390_CC_EQ)
 266 #define S390_CC_GE      (S390_CC_GT | S390_CC_EQ)
 267 #define S390_CC_NEVER   0
 268 #define S390_CC_ALWAYS  15
 269
 270 /* Condition codes that result from a COMPARE and COMPARE LOGICAL.  */
 271 static const uint8_t tcg_cond_to_s390_cond[10] = {
 272     [TCG_COND_EQ]  = S390_CC_EQ,
 273     [TCG_COND_NE]  = S390_CC_NE,
 274     [TCG_COND_LT]  = S390_CC_LT,
 275     [TCG_COND_LE]  = S390_CC_LE,
 276     [TCG_COND_GT]  = S390_CC_GT,
 277     [TCG_COND_GE]  = S390_CC_GE,
 278     [TCG_COND_LTU] = S390_CC_LT,
 279     [TCG_COND_LEU] = S390_CC_LE,
 280     [TCG_COND_GTU] = S390_CC_GT,
 281     [TCG_COND_GEU] = S390_CC_GE,
 282 };
 283
 284 /* Condition codes that result from a LOAD AND TEST.  Here, we have no
 285    unsigned instruction variation, however since the test is vs zero we
 286    can re-map the outcomes appropriately.  */
 287 static const uint8_t tcg_cond_to_ltr_cond[10] = {
 288     [TCG_COND_EQ]  = S390_CC_EQ,
 289     [TCG_COND_NE]  = S390_CC_NE,
 290     [TCG_COND_LT]  = S390_CC_LT,
 291     [TCG_COND_LE]  = S390_CC_LE,
 292     [TCG_COND_GT]  = S390_CC_GT,
 293     [TCG_COND_GE]  = S390_CC_GE,
 294     [TCG_COND_LTU] = S390_CC_NEVER,
 295     [TCG_COND_LEU] = S390_CC_EQ,
 296     [TCG_COND_GTU] = S390_CC_NE,
 297     [TCG_COND_GEU] = S390_CC_ALWAYS,
 298 };
 299
 300 #ifdef CONFIG_SOFTMMU
 301
 302 #include "../../softmmu_defs.h"
 303
 304 static void *qemu_ld_helpers[4] = {
 305     __ldb_mmu,
 306     __ldw_mmu,
 307     __ldl_mmu,
 308     __ldq_mmu,
 309 };
 310
 311 static void *qemu_st_helpers[4] = {
 312     __stb_mmu,
 313     __stw_mmu,
 314     __stl_mmu,
 315     __stq_mmu,
 316 };
 317 #endif
 318
 319 static uint8_t *tb_ret_addr;
 320
 321 /* A list of relevant facilities used by this translator.  Some of these
 322    are required for proper operation, and these are checked at startup.  */
 323
 324 #define FACILITY_ZARCH_ACTIVE   (1ULL << (63 - 2))
 325 #define FACILITY_LONG_DISP      (1ULL << (63 - 18))
 326 #define FACILITY_EXT_IMM        (1ULL << (63 - 21))
 327 #define FACILITY_GEN_INST_EXT   (1ULL << (63 - 34))
 328
 329 static uint64_t facilities;
 330
 331 static void patch_reloc(uint8_t *code_ptr, int type,
 332                         tcg_target_long value, tcg_target_long addend)
 333 {
 334     tcg_target_long code_ptr_tl = (tcg_target_long)code_ptr;
 335     tcg_target_long pcrel2;
 336
 337     /* ??? Not the usual definition of "addend".  */
 338     pcrel2 = (value - (code_ptr_tl + addend)) >> 1;
 339
 340     switch (type) {
 341     case R_390_PC16DBL:
 342         assert(pcrel2 == (int16_t)pcrel2);
 343         *(int16_t *)code_ptr = pcrel2;
 344         break;
 345     case R_390_PC32DBL:
 346         assert(pcrel2 == (int32_t)pcrel2);
 347         *(int32_t *)code_ptr = pcrel2;
 348         break;
 349     default:
 350         tcg_abort();
 351         break;
 352     }
 353 }
 354
 355 static int tcg_target_get_call_iarg_regs_count(int flags)
 356 {
 357     return sizeof(tcg_target_call_iarg_regs) / sizeof(int);
 358 }
 359
 360 /* parse target specific constraints */
 361 static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
 362 {
 363     const char *ct_str = *pct_str;
 364
 365     switch (ct_str[0]) {
 366     case 'r':                  /* all registers */
 367         ct->ct |= TCG_CT_REG;
 368         tcg_regset_set32(ct->u.regs, 0, 0xffff);
 369         break;
 370     case 'R':                  /* not R0 */
 371         ct->ct |= TCG_CT_REG;
 372         tcg_regset_set32(ct->u.regs, 0, 0xffff);
 373         tcg_regset_reset_reg(ct->u.regs, TCG_REG_R0);
 374         break;
 375     case 'L':                  /* qemu_ld/st constraint */
 376         ct->ct |= TCG_CT_REG;
 377         tcg_regset_set32(ct->u.regs, 0, 0xffff);
 378         tcg_regset_reset_reg (ct->u.regs, TCG_REG_R2);
 379         tcg_regset_reset_reg (ct->u.regs, TCG_REG_R3);
 380         break;
 381     case 'a':                  /* force R2 for division */
 382         ct->ct |= TCG_CT_REG;
 383         tcg_regset_clear(ct->u.regs);
 384         tcg_regset_set_reg(ct->u.regs, TCG_REG_R2);
 385         break;
 386     case 'b':                  /* force R3 for division */
 387         ct->ct |= TCG_CT_REG;
 388         tcg_regset_clear(ct->u.regs);
 389         tcg_regset_set_reg(ct->u.regs, TCG_REG_R3);
 390         break;
 391     case 'N':                  /* force immediate negate */
 392         ct->ct |= TCG_CT_CONST_NEG;
 393         break;
 394     case 'W':                  /* force 32-bit ("word") immediate */
 395         ct->ct |= TCG_CT_CONST_32;
 396         break;
 397     case 'I':
 398         ct->ct |= TCG_CT_CONST_ADDI;
 399         break;
 400     case 'K':
 401         ct->ct |= TCG_CT_CONST_MULI;
 402         break;
 403     case 'A':
 404         ct->ct |= TCG_CT_CONST_ANDI;
 405         break;
 406     case 'O':
 407         ct->ct |= TCG_CT_CONST_ORI;
 408         break;
 409     case 'X':
 410         ct->ct |= TCG_CT_CONST_XORI;
 411         break;
 412     case 'C':
 413         ct->ct |= TCG_CT_CONST_CMPI;
 414         break;
 415     default:
 416         return -1;
 417     }
 418     ct_str++;
 419     *pct_str = ct_str;
 420
 421     return 0;
 422 }
 423
 424 /* Immediates to be used with logical AND.  This is an optimization only,
 425    since a full 64-bit immediate AND can always be performed with 4 sequential
 426    NI[LH][LH] instructions.  What we're looking for is immediates that we
 427    can load efficiently, and the immediate load plus the reg-reg AND is
 428    smaller than the sequential NI's.  */
 429
 430 static int tcg_match_andi(int ct, tcg_target_ulong val)
 431 {
 432     int i;
 433
 434     if (facilities & FACILITY_EXT_IMM) {
 435         if (ct & TCG_CT_CONST_32) {
 436             /* All 32-bit ANDs can be performed with 1 48-bit insn.  */
 437             return 1;
 438         }
 439
 440         /* Zero-extensions.  */
 441         if (val == 0xff || val == 0xffff || val == 0xffffffff) {
 442             return 1;
 443         }
 444     } else {
 445         if (ct & TCG_CT_CONST_32) {
 446             val = (uint32_t)val;
 447         } else if (val == 0xffffffff) {
 448             return 1;
 449         }
 450     }
 451
 452     /* Try all 32-bit insns that can perform it in one go.  */
 453     for (i = 0; i < 4; i++) {
 454         tcg_target_ulong mask = ~(0xffffull << i*16);
 455         if ((val & mask) == mask) {
 456             return 1;
 457         }
 458     }
 459
 460     /* Look for 16-bit values performing the mask.  These are better
 461        to load with LLI[LH][LH].  */
 462     for (i = 0; i < 4; i++) {
 463         tcg_target_ulong mask = 0xffffull << i*16;
 464         if ((val & mask) == val) {
 465             return 0;
 466         }
 467     }
 468
 469     /* Look for 32-bit values performing the 64-bit mask.  These
 470        are better to load with LLI[LH]F, or if extended immediates
 471        not available, with a pair of LLI insns.  */
 472     if ((ct & TCG_CT_CONST_32) == 0) {
 473         if (val <= 0xffffffff || (val & 0xffffffff) == 0) {
 474             return 0;
 475         }
 476     }
 477
 478     return 1;
 479 }
 480
 481 /* Immediates to be used with logical OR.  This is an optimization only,
 482    since a full 64-bit immediate OR can always be performed with 4 sequential
 483    OI[LH][LH] instructions.  What we're looking for is immediates that we
 484    can load efficiently, and the immediate load plus the reg-reg OR is
 485    smaller than the sequential OI's.  */
 486
 487 static int tcg_match_ori(int ct, tcg_target_long val)
 488 {
 489     if (facilities & FACILITY_EXT_IMM) {
 490         if (ct & TCG_CT_CONST_32) {
 491             /* All 32-bit ORs can be performed with 1 48-bit insn.  */
 492             return 1;
 493         }
 494     }
 495
 496     /* Look for negative values.  These are best to load with LGHI.  */
 497     if (val < 0) {
 498         if (val == (int16_t)val) {
 499             return 0;
 500         }
 501         if (facilities & FACILITY_EXT_IMM) {
 502             if (val == (int32_t)val) {
 503                 return 0;
 504             }
 505         }
 506     }
 507
 508     return 1;
 509 }
 510
 511 /* Immediates to be used with logical XOR.  This is almost, but not quite,
 512    only an optimization.  XOR with immediate is only supported with the
 513    extended-immediate facility.  That said, there are a few patterns for
 514    which it is better to load the value into a register first.  */
 515
 516 static int tcg_match_xori(int ct, tcg_target_long val)
 517 {
 518     if ((facilities & FACILITY_EXT_IMM) == 0) {
 519         return 0;
 520     }
 521
 522     if (ct & TCG_CT_CONST_32) {
 523         /* All 32-bit XORs can be performed with 1 48-bit insn.  */
 524         return 1;
 525     }
 526
 527     /* Look for negative values.  These are best to load with LGHI.  */
 528     if (val < 0 && val == (int32_t)val) {
 529         return 0;
 530     }
 531
 532     return 1;
 533 }
 534
 535 /* Imediates to be used with comparisons.  */
 536
 537 static int tcg_match_cmpi(int ct, tcg_target_long val)
 538 {
 539     if (facilities & FACILITY_EXT_IMM) {
 540         /* The COMPARE IMMEDIATE instruction is available.  */
 541         if (ct & TCG_CT_CONST_32) {
 542             /* We have a 32-bit immediate and can compare against anything.  */
 543             return 1;
 544         } else {
 545             /* ??? We have no insight here into whether the comparison is
 546                signed or unsigned.  The COMPARE IMMEDIATE insn uses a 32-bit
 547                signed immediate, and the COMPARE LOGICAL IMMEDIATE insn uses
 548                a 32-bit unsigned immediate.  If we were to use the (semi)
 549                obvious "val == (int32_t)val" we would be enabling unsigned
 550                comparisons vs very large numbers.  The only solution is to
 551                take the intersection of the ranges.  */
 552             /* ??? Another possible solution is to simply lie and allow all
 553                constants here and force the out-of-range values into a temp
 554                register in tgen_cmp when we have knowledge of the actual
 555                comparison code in use.  */
 556             return val >= 0 && val <= 0x7fffffff;
 557         }
 558     } else {
 559         /* Only the LOAD AND TEST instruction is available.  */
 560         return val == 0;
 561     }
 562 }
 563
 564 /* Test if a constant matches the constraint. */
 565 static int tcg_target_const_match(tcg_target_long val,
 566                                   const TCGArgConstraint *arg_ct)
 567 {
 568     int ct = arg_ct->ct;
 569
 570     if (ct & TCG_CT_CONST) {
 571         return 1;
 572     }
 573
 574     /* Handle the modifiers.  */
 575     if (ct & TCG_CT_CONST_NEG) {
 576         val = -val;
 577     }
 578     if (ct & TCG_CT_CONST_32) {
 579         val = (int32_t)val;
 580     }
 581
 582     /* The following are mutually exclusive.  */
 583     if (ct & TCG_CT_CONST_ADDI) {
 584         /* Immediates that may be used with add.  If we have the
 585            extended-immediates facility then we have ADD IMMEDIATE
 586            with signed and unsigned 32-bit, otherwise we have only
 587            ADD HALFWORD IMMEDIATE with a signed 16-bit.  */
 588         if (facilities & FACILITY_EXT_IMM) {
 589             return val == (int32_t)val || val == (uint32_t)val;
 590         } else {
 591             return val == (int16_t)val;
 592         }
 593     } else if (ct & TCG_CT_CONST_MULI) {
 594         /* Immediates that may be used with multiply.  If we have the
 595            general-instruction-extensions, then we have MULTIPLY SINGLE
 596            IMMEDIATE with a signed 32-bit, otherwise we have only
 597            MULTIPLY HALFWORD IMMEDIATE, with a signed 16-bit.  */
 598         if (facilities & FACILITY_GEN_INST_EXT) {
 599             return val == (int32_t)val;
 600         } else {
 601             return val == (int16_t)val;
 602         }
 603     } else if (ct & TCG_CT_CONST_ANDI) {
 604         return tcg_match_andi(ct, val);
 605     } else if (ct & TCG_CT_CONST_ORI) {
 606         return tcg_match_ori(ct, val);
 607     } else if (ct & TCG_CT_CONST_XORI) {
 608         return tcg_match_xori(ct, val);
 609     } else if (ct & TCG_CT_CONST_CMPI) {
 610         return tcg_match_cmpi(ct, val);
 611     }
 612
 613     return 0;
 614 }
 615
 616 /* Emit instructions according to the given instruction format.  */
 617
 618 static void tcg_out_insn_RR(TCGContext *s, S390Opcode op, TCGReg r1, TCGReg r2)
 619 {
 620     tcg_out16(s, (op << 8) | (r1 << 4) | r2);
 621 }
 622
 623 static void tcg_out_insn_RRE(TCGContext *s, S390Opcode op,
 624                              TCGReg r1, TCGReg r2)
 625 {
 626     tcg_out32(s, (op << 16) | (r1 << 4) | r2);
 627 }
 628
 629 static void tcg_out_insn_RI(TCGContext *s, S390Opcode op, TCGReg r1, int i2)
 630 {
 631     tcg_out32(s, (op << 16) | (r1 << 20) | (i2 & 0xffff));
 632 }
 633
 634 static void tcg_out_insn_RIL(TCGContext *s, S390Opcode op, TCGReg r1, int i2)
 635 {
 636     tcg_out16(s, op | (r1 << 4));
 637     tcg_out32(s, i2);
 638 }
 639
 640 static void tcg_out_insn_RS(TCGContext *s, S390Opcode op, TCGReg r1,
 641                             TCGReg b2, TCGReg r3, int disp)
 642 {
 643     tcg_out32(s, (op << 24) | (r1 << 20) | (r3 << 16) | (b2 << 12)
 644               | (disp & 0xfff));
 645 }
 646
 647 static void tcg_out_insn_RSY(TCGContext *s, S390Opcode op, TCGReg r1,
 648                              TCGReg b2, TCGReg r3, int disp)
 649 {
 650     tcg_out16(s, (op & 0xff00) | (r1 << 4) | r3);
 651     tcg_out32(s, (op & 0xff) | (b2 << 28)
 652               | ((disp & 0xfff) << 16) | ((disp & 0xff000) >> 4));
 653 }
 654
 655 #define tcg_out_insn_RX   tcg_out_insn_RS
 656 #define tcg_out_insn_RXY  tcg_out_insn_RSY
 657
 658 /* Emit an opcode with "type-checking" of the format.  */
 659 #define tcg_out_insn(S, FMT, OP, ...) \
 660     glue(tcg_out_insn_,FMT)(S, glue(glue(FMT,_),OP), ## __VA_ARGS__)
 661
 662
 663 /* emit 64-bit shifts */
 664 static void tcg_out_sh64(TCGContext* s, S390Opcode op, TCGReg dest,
 665                          TCGReg src, TCGReg sh_reg, int sh_imm)
 666 {
 667     tcg_out_insn_RSY(s, op, dest, sh_reg, src, sh_imm);
 668 }
 669
 670 /* emit 32-bit shifts */
 671 static void tcg_out_sh32(TCGContext* s, S390Opcode op, TCGReg dest,
 672                          TCGReg sh_reg, int sh_imm)
 673 {
 674     tcg_out_insn_RS(s, op, dest, sh_reg, 0, sh_imm);
 675 }
 676
 677 static void tcg_out_mov(TCGContext *s, TCGType type, TCGReg dst, TCGReg src)
 678 {
 679     if (src != dst) {
 680         if (type == TCG_TYPE_I32) {
 681             tcg_out_insn(s, RR, LR, dst, src);
 682         } else {
 683             tcg_out_insn(s, RRE, LGR, dst, src);
 684         }
 685     }
 686 }
 687
 688 /* load a register with an immediate value */
 689 static void tcg_out_movi(TCGContext *s, TCGType type,
 690                          TCGReg ret, tcg_target_long sval)
 691 {
 692     static const S390Opcode lli_insns[4] = {
 693         RI_LLILL, RI_LLILH, RI_LLIHL, RI_LLIHH
 694     };
 695
 696     tcg_target_ulong uval = sval;
 697     int i;
 698
 699     if (type == TCG_TYPE_I32) {
 700         uval = (uint32_t)sval;
 701         sval = (int32_t)sval;
 702     }
 703
 704     /* Try all 32-bit insns that can load it in one go.  */
 705     if (sval >= -0x8000 && sval < 0x8000) {
 706         tcg_out_insn(s, RI, LGHI, ret, sval);
 707         return;
 708     }
 709
 710     for (i = 0; i < 4; i++) {
 711         tcg_target_long mask = 0xffffull << i*16;
 712         if ((uval & mask) == uval) {
 713             tcg_out_insn_RI(s, lli_insns[i], ret, uval >> i*16);
 714             return;
 715         }
 716     }
 717
 718     /* Try all 48-bit insns that can load it in one go.  */
 719     if (facilities & FACILITY_EXT_IMM) {
 720         if (sval == (int32_t)sval) {
 721             tcg_out_insn(s, RIL, LGFI, ret, sval);
 722             return;
 723         }
 724         if (uval <= 0xffffffff) {
 725             tcg_out_insn(s, RIL, LLILF, ret, uval);
 726             return;
 727         }
 728         if ((uval & 0xffffffff) == 0) {
 729             tcg_out_insn(s, RIL, LLIHF, ret, uval >> 31 >> 1);
 730             return;
 731         }
 732     }
 733
 734     /* Try for PC-relative address load.  */
 735     if ((sval & 1) == 0) {
 736         intptr_t off = (sval - (intptr_t)s->code_ptr) >> 1;
 737         if (off == (int32_t)off) {
 738             tcg_out_insn(s, RIL, LARL, ret, off);
 739             return;
 740         }
 741     }
 742
 743     /* If extended immediates are not present, then we may have to issue
 744        several instructions to load the low 32 bits.  */
 745     if (!(facilities & FACILITY_EXT_IMM)) {
 746         /* A 32-bit unsigned value can be loaded in 2 insns.  And given
 747            that the lli_insns loop above did not succeed, we know that
 748            both insns are required.  */
 749         if (uval <= 0xffffffff) {
 750             tcg_out_insn(s, RI, LLILL, ret, uval);
 751             tcg_out_insn(s, RI, IILH, ret, uval >> 16);
 752             return;
 753         }
 754
 755         /* If all high bits are set, the value can be loaded in 2 or 3 insns.
 756            We first want to make sure that all the high bits get set.  With
 757            luck the low 16-bits can be considered negative to perform that for
 758            free, otherwise we load an explicit -1.  */
 759         if (sval >> 31 >> 1 == -1) {
 760             if (uval & 0x8000) {
 761                 tcg_out_insn(s, RI, LGHI, ret, uval);
 762             } else {
 763                 tcg_out_insn(s, RI, LGHI, ret, -1);
 764                 tcg_out_insn(s, RI, IILL, ret, uval);
 765             }
 766             tcg_out_insn(s, RI, IILH, ret, uval >> 16);
 767             return;
 768         }
 769     }
 770
 771     /* If we get here, both the high and low parts have non-zero bits.  */
 772
 773     /* Recurse to load the lower 32-bits.  */
 774     tcg_out_movi(s, TCG_TYPE_I32, ret, sval);
 775
 776     /* Insert data into the high 32-bits.  */
 777     uval = uval >> 31 >> 1;
 778     if (facilities & FACILITY_EXT_IMM) {
 779         if (uval < 0x10000) {
 780             tcg_out_insn(s, RI, IIHL, ret, uval);
 781         } else if ((uval & 0xffff) == 0) {
 782             tcg_out_insn(s, RI, IIHH, ret, uval >> 16);
 783         } else {
 784             tcg_out_insn(s, RIL, IIHF, ret, uval);
 785         }
 786     } else {
 787         if (uval & 0xffff) {
 788             tcg_out_insn(s, RI, IIHL, ret, uval);
 789         }
 790         if (uval & 0xffff0000) {
 791             tcg_out_insn(s, RI, IIHH, ret, uval >> 16);
 792         }
 793     }
 794 }
 795
 796
 797 /* Emit a load/store type instruction.  Inputs are:
 798    DATA:     The register to be loaded or stored.
 799    BASE+OFS: The effective address.
 800    OPC_RX:   If the operation has an RX format opcode (e.g. STC), otherwise 0.
 801    OPC_RXY:  The RXY format opcode for the operation (e.g. STCY).  */
 802
 803 static void tcg_out_mem(TCGContext *s, S390Opcode opc_rx, S390Opcode opc_rxy,
 804                         TCGReg data, TCGReg base, TCGReg index,
 805                         tcg_target_long ofs)
 806 {
 807     if (ofs < -0x80000 || ofs >= 0x80000) {
 808         /* Combine the low 16 bits of the offset with the actual load insn;
 809            the high 48 bits must come from an immediate load.  */
 810         tcg_out_movi(s, TCG_TYPE_PTR, TCG_TMP0, ofs & ~0xffff);
 811         ofs &= 0xffff;
 812
 813         /* If we were already given an index register, add it in.  */
 814         if (index != TCG_REG_NONE) {
 815             tcg_out_insn(s, RRE, AGR, TCG_TMP0, index);
 816         }
 817         index = TCG_TMP0;
 818     }
 819
 820     if (opc_rx && ofs >= 0 && ofs < 0x1000) {
 821         tcg_out_insn_RX(s, opc_rx, data, base, index, ofs);
 822     } else {
 823         tcg_out_insn_RXY(s, opc_rxy, data, base, index, ofs);
 824     }
 825 }
 826
 827
 828 /* load data without address translation or endianness conversion */
 829 static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg data,
 830                               TCGReg base, tcg_target_long ofs)
 831 {
 832     if (type == TCG_TYPE_I32) {
 833         tcg_out_mem(s, RX_L, RXY_LY, data, base, TCG_REG_NONE, ofs);
 834     } else {
 835         tcg_out_mem(s, 0, RXY_LG, data, base, TCG_REG_NONE, ofs);
 836     }
 837 }
 838
 839 static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg data,
 840                               TCGReg base, tcg_target_long ofs)
 841 {
 842     if (type == TCG_TYPE_I32) {
 843         tcg_out_mem(s, RX_ST, RXY_STY, data, base, TCG_REG_NONE, ofs);
 844     } else {
 845         tcg_out_mem(s, 0, RXY_STG, data, base, TCG_REG_NONE, ofs);
 846     }
 847 }
 848
 849 /* load data from an absolute host address */
 850 static void tcg_out_ld_abs(TCGContext *s, TCGType type, TCGReg dest, void *abs)
 851 {
 852     tcg_target_long addr = (tcg_target_long)abs;
 853
 854     if (facilities & FACILITY_GEN_INST_EXT) {
 855         tcg_target_long disp = (addr - (tcg_target_long)s->code_ptr) >> 1;
 856         if (disp == (int32_t)disp) {
 857             if (type == TCG_TYPE_I32) {
 858                 tcg_out_insn(s, RIL, LRL, dest, disp);
 859             } else {
 860                 tcg_out_insn(s, RIL, LGRL, dest, disp);
 861             }
 862             return;
 863         }
 864     }
 865
 866     tcg_out_movi(s, TCG_TYPE_PTR, dest, addr & ~0xffff);
 867     tcg_out_ld(s, type, dest, dest, addr & 0xffff);
 868 }
 869
 870 static void tgen_ext8s(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
 871 {
 872     if (facilities & FACILITY_EXT_IMM) {
 873         tcg_out_insn(s, RRE, LGBR, dest, src);
 874         return;
 875     }
 876
 877     if (type == TCG_TYPE_I32) {
 878         if (dest == src) {
 879             tcg_out_sh32(s, RS_SLL, dest, TCG_REG_NONE, 24);
 880         } else {
 881             tcg_out_sh64(s, RSY_SLLG, dest, src, TCG_REG_NONE, 24);
 882         }
 883         tcg_out_sh32(s, RS_SRA, dest, TCG_REG_NONE, 24);
 884     } else {
 885         tcg_out_sh64(s, RSY_SLLG, dest, src, TCG_REG_NONE, 56);
 886         tcg_out_sh64(s, RSY_SRAG, dest, dest, TCG_REG_NONE, 56);
 887     }
 888 }
 889
 890 static void tgen_ext8u(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
 891 {
 892     if (facilities & FACILITY_EXT_IMM) {
 893         tcg_out_insn(s, RRE, LLGCR, dest, src);
 894         return;
 895     }
 896
 897     if (dest == src) {
 898         tcg_out_movi(s, type, TCG_TMP0, 0xff);
 899         src = TCG_TMP0;
 900     } else {
 901         tcg_out_movi(s, type, dest, 0xff);
 902     }
 903     if (type == TCG_TYPE_I32) {
 904         tcg_out_insn(s, RR, NR, dest, src);
 905     } else {
 906         tcg_out_insn(s, RRE, NGR, dest, src);
 907     }
 908 }
 909
 910 static void tgen_ext16s(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
 911 {
 912     if (facilities & FACILITY_EXT_IMM) {
 913         tcg_out_insn(s, RRE, LGHR, dest, src);
 914         return;
 915     }
 916
 917     if (type == TCG_TYPE_I32) {
 918         if (dest == src) {
 919             tcg_out_sh32(s, RS_SLL, dest, TCG_REG_NONE, 16);
 920         } else {
 921             tcg_out_sh64(s, RSY_SLLG, dest, src, TCG_REG_NONE, 16);
 922         }
 923         tcg_out_sh32(s, RS_SRA, dest, TCG_REG_NONE, 16);
 924     } else {
 925         tcg_out_sh64(s, RSY_SLLG, dest, src, TCG_REG_NONE, 48);
 926         tcg_out_sh64(s, RSY_SRAG, dest, dest, TCG_REG_NONE, 48);
 927     }
 928 }
 929
 930 static void tgen_ext16u(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
 931 {
 932     if (facilities & FACILITY_EXT_IMM) {
 933         tcg_out_insn(s, RRE, LLGHR, dest, src);
 934         return;
 935     }
 936
 937     if (dest == src) {
 938         tcg_out_movi(s, type, TCG_TMP0, 0xffff);
 939         src = TCG_TMP0;
 940     } else {
 941         tcg_out_movi(s, type, dest, 0xffff);
 942     }
 943     if (type == TCG_TYPE_I32) {
 944         tcg_out_insn(s, RR, NR, dest, src);
 945     } else {
 946         tcg_out_insn(s, RRE, NGR, dest, src);
 947     }
 948 }
 949
 950 static inline void tgen_ext32s(TCGContext *s, TCGReg dest, TCGReg src)
 951 {
 952     tcg_out_insn(s, RRE, LGFR, dest, src);
 953 }
 954
 955 static inline void tgen_ext32u(TCGContext *s, TCGReg dest, TCGReg src)
 956 {
 957     tcg_out_insn(s, RRE, LLGFR, dest, src);
 958 }
 959
 960 static inline void tgen32_addi(TCGContext *s, TCGReg dest, int32_t val)
 961 {
 962     if (val == (int16_t)val) {
 963         tcg_out_insn(s, RI, AHI, dest, val);
 964     } else {
 965         tcg_out_insn(s, RIL, AFI, dest, val);
 966     }
 967 }
 968
 969 static inline void tgen64_addi(TCGContext *s, TCGReg dest, int64_t val)
 970 {
 971     if (val == (int16_t)val) {
 972         tcg_out_insn(s, RI, AGHI, dest, val);
 973     } else if (val == (int32_t)val) {
 974         tcg_out_insn(s, RIL, AGFI, dest, val);
 975     } else if (val == (uint32_t)val) {
 976         tcg_out_insn(s, RIL, ALGFI, dest, val);
 977     } else {
 978         tcg_abort();
 979     }
 980
 981 }
 982
 983 static void tgen64_andi(TCGContext *s, TCGReg dest, tcg_target_ulong val)
 984 {
 985     static const S390Opcode ni_insns[4] = {
 986         RI_NILL, RI_NILH, RI_NIHL, RI_NIHH
 987     };
 988     static const S390Opcode nif_insns[2] = {
 989         RIL_NILF, RIL_NIHF
 990     };
 991
 992     int i;
 993
 994     /* Look for no-op.  */
 995     if (val == -1) {
 996         return;
 997     }
 998
 999     /* Look for the zero-extensions.  */
1000     if (val == 0xffffffff) {
1001         tgen_ext32u(s, dest, dest);
1002         return;
1003     }
1004
1005     if (facilities & FACILITY_EXT_IMM) {
1006         if (val == 0xff) {
1007             tgen_ext8u(s, TCG_TYPE_I64, dest, dest);
1008             return;
1009         }
1010         if (val == 0xffff) {
1011             tgen_ext16u(s, TCG_TYPE_I64, dest, dest);
1012             return;
1013         }
1014
1015         /* Try all 32-bit insns that can perform it in one go.  */
1016         for (i = 0; i < 4; i++) {
1017             tcg_target_ulong mask = ~(0xffffull << i*16);
1018             if ((val & mask) == mask) {
1019                 tcg_out_insn_RI(s, ni_insns[i], dest, val >> i*16);
1020                 return;
1021             }
1022         }
1023
1024         /* Try all 48-bit insns that can perform it in one go.  */
1025         if (facilities & FACILITY_EXT_IMM) {
1026             for (i = 0; i < 2; i++) {
1027                 tcg_target_ulong mask = ~(0xffffffffull << i*32);
1028                 if ((val & mask) == mask) {
1029                     tcg_out_insn_RIL(s, nif_insns[i], dest, val >> i*32);
1030                     return;
1031                 }
1032             }
1033         }
1034
1035         /* Perform the AND via sequential modifications to the high and low
1036            parts.  Do this via recursion to handle 16-bit vs 32-bit masks in
1037            each half.  */
1038         tgen64_andi(s, dest, val | 0xffffffff00000000ull);
1039         tgen64_andi(s, dest, val | 0x00000000ffffffffull);
1040     } else {
1041         /* With no extended-immediate facility, just emit the sequence.  */
1042         for (i = 0; i < 4; i++) {
1043             tcg_target_ulong mask = 0xffffull << i*16;
1044             if ((val & mask) != mask) {
1045                 tcg_out_insn_RI(s, ni_insns[i], dest, val >> i*16);
1046             }
1047         }
1048     }
1049 }
1050
1051 static void tgen64_ori(TCGContext *s, TCGReg dest, tcg_target_ulong val)
1052 {
1053     static const S390Opcode oi_insns[4] = {
1054         RI_OILL, RI_OILH, RI_OIHL, RI_OIHH
1055     };
1056     static const S390Opcode nif_insns[2] = {
1057         RIL_OILF, RIL_OIHF
1058     };
1059
1060     int i;
1061
1062     /* Look for no-op.  */
1063     if (val == 0) {
1064         return;
1065     }
1066
1067     if (facilities & FACILITY_EXT_IMM) {
1068         /* Try all 32-bit insns that can perform it in one go.  */
1069         for (i = 0; i < 4; i++) {
1070             tcg_target_ulong mask = (0xffffull << i*16);
1071             if ((val & mask) != 0 && (val & ~mask) == 0) {
1072                 tcg_out_insn_RI(s, oi_insns[i], dest, val >> i*16);
1073                 return;
1074             }
1075         }
1076
1077         /* Try all 48-bit insns that can perform it in one go.  */
1078         for (i = 0; i < 2; i++) {
1079             tcg_target_ulong mask = (0xffffffffull << i*32);
1080             if ((val & mask) != 0 && (val & ~mask) == 0) {
1081                 tcg_out_insn_RIL(s, nif_insns[i], dest, val >> i*32);
1082                 return;
1083             }
1084         }
1085
1086         /* Perform the OR via sequential modifications to the high and
1087            low parts.  Do this via recursion to handle 16-bit vs 32-bit
1088            masks in each half.  */
1089         tgen64_ori(s, dest, val & 0x00000000ffffffffull);
1090         tgen64_ori(s, dest, val & 0xffffffff00000000ull);
1091     } else {
1092         /* With no extended-immediate facility, we don't need to be so
1093            clever.  Just iterate over the insns and mask in the constant.  */
1094         for (i = 0; i < 4; i++) {
1095             tcg_target_ulong mask = (0xffffull << i*16);
1096             if ((val & mask) != 0) {
1097                 tcg_out_insn_RI(s, oi_insns[i], dest, val >> i*16);
1098             }
1099         }
1100     }
1101 }
1102
1103 static void tgen64_xori(TCGContext *s, TCGReg dest, tcg_target_ulong val)
1104 {
1105     /* Perform the xor by parts.  */
1106     if (val & 0xffffffff) {
1107         tcg_out_insn(s, RIL, XILF, dest, val);
1108     }
1109     if (val > 0xffffffff) {
1110         tcg_out_insn(s, RIL, XIHF, dest, val >> 31 >> 1);
1111     }
1112 }
1113
1114 static int tgen_cmp(TCGContext *s, TCGType type, TCGCond c, TCGReg r1,
1115                     TCGArg c2, int c2const)
1116 {
1117     bool is_unsigned = (c > TCG_COND_GT);
1118     if (c2const) {
1119         if (c2 == 0) {
1120             if (type == TCG_TYPE_I32) {
1121                 tcg_out_insn(s, RR, LTR, r1, r1);
1122             } else {
1123                 tcg_out_insn(s, RRE, LTGR, r1, r1);
1124             }
1125             return tcg_cond_to_ltr_cond[c];
1126         } else {
1127             if (is_unsigned) {
1128                 if (type == TCG_TYPE_I32) {
1129                     tcg_out_insn(s, RIL, CLFI, r1, c2);
1130                 } else {
1131                     tcg_out_insn(s, RIL, CLGFI, r1, c2);
1132                 }
1133             } else {
1134                 if (type == TCG_TYPE_I32) {
1135                     tcg_out_insn(s, RIL, CFI, r1, c2);
1136                 } else {
1137                     tcg_out_insn(s, RIL, CGFI, r1, c2);
1138                 }
1139             }
1140         }
1141     } else {
1142         if (is_unsigned) {
1143             if (type == TCG_TYPE_I32) {
1144                 tcg_out_insn(s, RR, CLR, r1, c2);
1145             } else {
1146                 tcg_out_insn(s, RRE, CLGR, r1, c2);
1147             }
1148         } else {
1149             if (type == TCG_TYPE_I32) {
1150                 tcg_out_insn(s, RR, CR, r1, c2);
1151             } else {
1152                 tcg_out_insn(s, RRE, CGR, r1, c2);
1153             }
1154         }
1155     }
1156     return tcg_cond_to_s390_cond[c];
1157 }
1158
1159 static void tgen_setcond(TCGContext *s, TCGType type, TCGCond c,
1160                          TCGReg dest, TCGReg r1, TCGArg c2, int c2const)
1161 {
1162     int cc = tgen_cmp(s, type, c, r1, c2, c2const);
1163
1164     /* Emit: r1 = 1; if (cc) goto over; r1 = 0; over:  */
1165     tcg_out_movi(s, type, dest, 1);
1166     tcg_out_insn(s, RI, BRC, cc, (4 + 4) >> 1);
1167     tcg_out_movi(s, type, dest, 0);
1168 }
1169
1170 static void tgen_gotoi(TCGContext *s, int cc, tcg_target_long dest)
1171 {
1172     tcg_target_long off = (dest - (tcg_target_long)s->code_ptr) >> 1;
1173     if (off > -0x8000 && off < 0x7fff) {
1174         tcg_out_insn(s, RI, BRC, cc, off);
1175     } else if (off == (int32_t)off) {
1176         tcg_out_insn(s, RIL, BRCL, cc, off);
1177     } else {
1178         tcg_out_movi(s, TCG_TYPE_PTR, TCG_TMP0, dest);
1179         tcg_out_insn(s, RR, BCR, cc, TCG_TMP0);
1180     }
1181 }
1182
1183 static void tgen_branch(TCGContext *s, int cc, int labelno)
1184 {
1185     TCGLabel* l = &s->labels[labelno];
1186     if (l->has_value) {
1187         tgen_gotoi(s, cc, l->u.value);
1188     } else if (USE_LONG_BRANCHES) {
1189         tcg_out16(s, RIL_BRCL | (cc << 4));
1190         tcg_out_reloc(s, s->code_ptr, R_390_PC32DBL, labelno, -2);
1191         s->code_ptr += 4;
1192     } else {
1193         tcg_out16(s, RI_BRC | (cc << 4));
1194         tcg_out_reloc(s, s->code_ptr, R_390_PC16DBL, labelno, -2);
1195         s->code_ptr += 2;
1196     }
1197 }
1198
1199 static void tgen_compare_branch(TCGContext *s, S390Opcode opc, int cc,
1200                                 TCGReg r1, TCGReg r2, int labelno)
1201 {
1202     TCGLabel* l = &s->labels[labelno];
1203     tcg_target_long off;
1204
1205     if (l->has_value) {
1206         off = (l->u.value - (tcg_target_long)s->code_ptr) >> 1;
1207     } else {
1208         /* We need to keep the offset unchanged for retranslation.  */
1209         off = ((int16_t *)s->code_ptr)[1];
1210         tcg_out_reloc(s, s->code_ptr + 2, R_390_PC16DBL, labelno, -2);
1211     }
1212
1213     tcg_out16(s, (opc & 0xff00) | (r1 << 4) | r2);
1214     tcg_out16(s, off);
1215     tcg_out16(s, cc << 12 | (opc & 0xff));
1216 }
1217
1218 static void tgen_compare_imm_branch(TCGContext *s, S390Opcode opc, int cc,
1219                                     TCGReg r1, int i2, int labelno)
1220 {
1221     TCGLabel* l = &s->labels[labelno];
1222     tcg_target_long off;
1223
1224     if (l->has_value) {
1225         off = (l->u.value - (tcg_target_long)s->code_ptr) >> 1;
1226     } else {
1227         /* We need to keep the offset unchanged for retranslation.  */
1228         off = ((int16_t *)s->code_ptr)[1];
1229         tcg_out_reloc(s, s->code_ptr + 2, R_390_PC16DBL, labelno, -2);
1230     }
1231
1232     tcg_out16(s, (opc & 0xff00) | (r1 << 4) | cc);
1233     tcg_out16(s, off);
1234     tcg_out16(s, (i2 << 8) | (opc & 0xff));
1235 }
1236
1237 static void tgen_brcond(TCGContext *s, TCGType type, TCGCond c,
1238                         TCGReg r1, TCGArg c2, int c2const, int labelno)
1239 {
1240     int cc;
1241
1242     if (facilities & FACILITY_GEN_INST_EXT) {
1243         bool is_unsigned = (c > TCG_COND_GT);
1244         bool in_range;
1245         S390Opcode opc;
1246
1247         cc = tcg_cond_to_s390_cond[c];
1248
1249         if (!c2const) {
1250             opc = (type == TCG_TYPE_I32
1251                    ? (is_unsigned ? RIE_CLRJ : RIE_CRJ)
1252                    : (is_unsigned ? RIE_CLGRJ : RIE_CGRJ));
1253             tgen_compare_branch(s, opc, cc, r1, c2, labelno);
1254             return;
1255         }
1256
1257         /* COMPARE IMMEDIATE AND BRANCH RELATIVE has an 8-bit immediate field.
1258            If the immediate we've been given does not fit that range, we'll
1259            fall back to separate compare and branch instructions using the
1260            larger comparison range afforded by COMPARE IMMEDIATE.  */
1261         if (type == TCG_TYPE_I32) {
1262             if (is_unsigned) {
1263                 opc = RIE_CLIJ;
1264                 in_range = (uint32_t)c2 == (uint8_t)c2;
1265             } else {
1266                 opc = RIE_CIJ;
1267                 in_range = (int32_t)c2 == (int8_t)c2;
1268             }
1269         } else {
1270             if (is_unsigned) {
1271                 opc = RIE_CLGIJ;
1272                 in_range = (uint64_t)c2 == (uint8_t)c2;
1273             } else {
1274                 opc = RIE_CGIJ;
1275                 in_range = (int64_t)c2 == (int8_t)c2;
1276             }
1277         }
1278         if (in_range) {
1279             tgen_compare_imm_branch(s, opc, cc, r1, c2, labelno);
1280             return;
1281         }
1282     }
1283
1284     cc = tgen_cmp(s, type, c, r1, c2, c2const);
1285     tgen_branch(s, cc, labelno);
1286 }
1287
1288 static void tgen_calli(TCGContext *s, tcg_target_long dest)
1289 {
1290     tcg_target_long off = (dest - (tcg_target_long)s->code_ptr) >> 1;
1291     if (off == (int32_t)off) {
1292         tcg_out_insn(s, RIL, BRASL, TCG_REG_R14, off);
1293     } else {
1294         tcg_out_movi(s, TCG_TYPE_PTR, TCG_TMP0, dest);
1295         tcg_out_insn(s, RR, BASR, TCG_REG_R14, TCG_TMP0);
1296     }
1297 }
1298
1299 static void tcg_out_qemu_ld_direct(TCGContext *s, int opc, TCGReg data,
1300                                    TCGReg base, TCGReg index, int disp)
1301 {
1302 #ifdef TARGET_WORDS_BIGENDIAN
1303     const int bswap = 0;
1304 #else
1305     const int bswap = 1;
1306 #endif
1307     switch (opc) {
1308     case LD_UINT8:
1309         tcg_out_insn(s, RXY, LLGC, data, base, index, disp);
1310         break;
1311     case LD_INT8:
1312         tcg_out_insn(s, RXY, LGB, data, base, index, disp);
1313         break;
1314     case LD_UINT16:
1315         if (bswap) {
1316             /* swapped unsigned halfword load with upper bits zeroed */
1317             tcg_out_insn(s, RXY, LRVH, data, base, index, disp);
1318             tgen_ext16u(s, TCG_TYPE_I64, data, data);
1319         } else {
1320             tcg_out_insn(s, RXY, LLGH, data, base, index, disp);
1321         }
1322         break;
1323     case LD_INT16:
1324         if (bswap) {
1325             /* swapped sign-extended halfword load */
1326             tcg_out_insn(s, RXY, LRVH, data, base, index, disp);
1327             tgen_ext16s(s, TCG_TYPE_I64, data, data);
1328         } else {
1329             tcg_out_insn(s, RXY, LGH, data, base, index, disp);
1330         }
1331         break;
1332     case LD_UINT32:
1333         if (bswap) {
1334             /* swapped unsigned int load with upper bits zeroed */
1335             tcg_out_insn(s, RXY, LRV, data, base, index, disp);
1336             tgen_ext32u(s, data, data);
1337         } else {
1338             tcg_out_insn(s, RXY, LLGF, data, base, index, disp);
1339         }
1340         break;
1341     case LD_INT32:
1342         if (bswap) {
1343             /* swapped sign-extended int load */
1344             tcg_out_insn(s, RXY, LRV, data, base, index, disp);
1345             tgen_ext32s(s, data, data);
1346         } else {
1347             tcg_out_insn(s, RXY, LGF, data, base, index, disp);
1348         }
1349         break;
1350     case LD_UINT64:
1351         if (bswap) {
1352             tcg_out_insn(s, RXY, LRVG, data, base, index, disp);
1353         } else {
1354             tcg_out_insn(s, RXY, LG, data, base, index, disp);
1355         }
1356         break;
1357     default:
1358         tcg_abort();
1359     }
1360 }
1361
1362 static void tcg_out_qemu_st_direct(TCGContext *s, int opc, TCGReg data,
1363                                    TCGReg base, TCGReg index, int disp)
1364 {
1365 #ifdef TARGET_WORDS_BIGENDIAN
1366     const int bswap = 0;
1367 #else
1368     const int bswap = 1;
1369 #endif
1370     switch (opc) {
1371     case LD_UINT8:
1372         if (disp >= 0 && disp < 0x1000) {
1373             tcg_out_insn(s, RX, STC, data, base, index, disp);
1374         } else {
1375             tcg_out_insn(s, RXY, STCY, data, base, index, disp);
1376         }
1377         break;
1378     case LD_UINT16:
1379         if (bswap) {
1380             tcg_out_insn(s, RXY, STRVH, data, base, index, disp);
1381         } else if (disp >= 0 && disp < 0x1000) {
1382             tcg_out_insn(s, RX, STH, data, base, index, disp);
1383         } else {
1384             tcg_out_insn(s, RXY, STHY, data, base, index, disp);
1385         }
1386         break;
1387     case LD_UINT32:
1388         if (bswap) {
1389             tcg_out_insn(s, RXY, STRV, data, base, index, disp);
1390         } else if (disp >= 0 && disp < 0x1000) {
1391             tcg_out_insn(s, RX, ST, data, base, index, disp);
1392         } else {
1393             tcg_out_insn(s, RXY, STY, data, base, index, disp);
1394         }
1395         break;
1396     case LD_UINT64:
1397         if (bswap) {
1398             tcg_out_insn(s, RXY, STRVG, data, base, index, disp);
1399         } else {
1400             tcg_out_insn(s, RXY, STG, data, base, index, disp);
1401         }
1402         break;
1403     default:
1404         tcg_abort();
1405     }
1406 }
1407
1408 #if defined(CONFIG_SOFTMMU)
1409 static void tgen64_andi_tmp(TCGContext *s, TCGReg dest, tcg_target_ulong val)
1410 {
1411     if (tcg_match_andi(0, val)) {
1412         tcg_out_movi(s, TCG_TYPE_I64, TCG_TMP0, val);
1413         tcg_out_insn(s, RRE, NGR, dest, TCG_TMP0);
1414     } else {
1415         tgen64_andi(s, dest, val);
1416     }
1417 }
1418
1419 static void tcg_prepare_qemu_ldst(TCGContext* s, TCGReg data_reg,
1420                                   TCGReg addr_reg, int mem_index, int opc,
1421                                   uint16_t **label2_ptr_p, int is_store)
1422 {
1423     const TCGReg arg0 = TCG_REG_R2;
1424     const TCGReg arg1 = TCG_REG_R3;
1425     int s_bits = opc & 3;
1426     uint16_t *label1_ptr;
1427     tcg_target_long ofs;
1428
1429     if (TARGET_LONG_BITS == 32) {
1430         tgen_ext32u(s, arg0, addr_reg);
1431     } else {
1432         tcg_out_mov(s, TCG_TYPE_I64, arg0, addr_reg);
1433     }
1434
1435     tcg_out_sh64(s, RSY_SRLG, arg1, addr_reg, TCG_REG_NONE,
1436                  TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS);
1437
1438     tgen64_andi_tmp(s, arg0, TARGET_PAGE_MASK | ((1 << s_bits) - 1));
1439     tgen64_andi_tmp(s, arg1, (CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS);
1440
1441     if (is_store) {
1442         ofs = offsetof(CPUArchState, tlb_table[mem_index][0].addr_write);
1443     } else {
1444         ofs = offsetof(CPUArchState, tlb_table[mem_index][0].addr_read);
1445     }
1446     assert(ofs < 0x80000);
1447
1448     if (TARGET_LONG_BITS == 32) {
1449         tcg_out_mem(s, RX_C, RXY_CY, arg0, arg1, TCG_AREG0, ofs);
1450     } else {
1451         tcg_out_mem(s, 0, RXY_CG, arg0, arg1, TCG_AREG0, ofs);
1452     }
1453
1454     if (TARGET_LONG_BITS == 32) {
1455         tgen_ext32u(s, arg0, addr_reg);
1456     } else {
1457         tcg_out_mov(s, TCG_TYPE_I64, arg0, addr_reg);
1458     }
1459
1460     label1_ptr = (uint16_t*)s->code_ptr;
1461
1462     /* je label1 (offset will be patched in later) */
1463     tcg_out_insn(s, RI, BRC, S390_CC_EQ, 0);
1464
1465     /* call load/store helper */
1466     if (is_store) {
1467         /* Make sure to zero-extend the value to the full register
1468            for the calling convention.  */
1469         switch (opc) {
1470         case LD_UINT8:
1471             tgen_ext8u(s, TCG_TYPE_I64, arg1, data_reg);
1472             break;
1473         case LD_UINT16:
1474             tgen_ext16u(s, TCG_TYPE_I64, arg1, data_reg);
1475             break;
1476         case LD_UINT32:
1477             tgen_ext32u(s, arg1, data_reg);
1478             break;
1479         case LD_UINT64:
1480             tcg_out_mov(s, TCG_TYPE_I64, arg1, data_reg);
1481             break;
1482         default:
1483             tcg_abort();
1484         }
1485         tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_R4, mem_index);
1486         tgen_calli(s, (tcg_target_ulong)qemu_st_helpers[s_bits]);
1487     } else {
1488         tcg_out_movi(s, TCG_TYPE_I32, arg1, mem_index);
1489         tgen_calli(s, (tcg_target_ulong)qemu_ld_helpers[s_bits]);
1490
1491         /* sign extension */
1492         switch (opc) {
1493         case LD_INT8:
1494             tgen_ext8s(s, TCG_TYPE_I64, data_reg, arg0);
1495             break;
1496         case LD_INT16:
1497             tgen_ext16s(s, TCG_TYPE_I64, data_reg, arg0);
1498             break;
1499         case LD_INT32:
1500             tgen_ext32s(s, data_reg, arg0);
1501             break;
1502         default:
1503             /* unsigned -> just copy */
1504             tcg_out_mov(s, TCG_TYPE_I64, data_reg, arg0);
1505             break;
1506         }
1507     }
1508
1509     /* jump to label2 (end) */
1510     *label2_ptr_p = (uint16_t*)s->code_ptr;
1511
1512     tcg_out_insn(s, RI, BRC, S390_CC_ALWAYS, 0);
1513
1514     /* this is label1, patch branch */
1515     *(label1_ptr + 1) = ((unsigned long)s->code_ptr -
1516                          (unsigned long)label1_ptr) >> 1;
1517
1518     ofs = offsetof(CPUArchState, tlb_table[mem_index][0].addend);
1519     assert(ofs < 0x80000);
1520
1521     tcg_out_mem(s, 0, RXY_AG, arg0, arg1, TCG_AREG0, ofs);
1522 }
1523
1524 static void tcg_finish_qemu_ldst(TCGContext* s, uint16_t *label2_ptr)
1525 {
1526     /* patch branch */
1527     *(label2_ptr + 1) = ((unsigned long)s->code_ptr -
1528                          (unsigned long)label2_ptr) >> 1;
1529 }
1530 #else
1531 static void tcg_prepare_user_ldst(TCGContext *s, TCGReg *addr_reg,
1532                                   TCGReg *index_reg, tcg_target_long *disp)
1533 {
1534     if (TARGET_LONG_BITS == 32) {
1535         tgen_ext32u(s, TCG_TMP0, *addr_reg);
1536         *addr_reg = TCG_TMP0;
1537     }
1538     if (GUEST_BASE < 0x80000) {
1539         *index_reg = TCG_REG_NONE;
1540         *disp = GUEST_BASE;
1541     } else {
1542         *index_reg = TCG_GUEST_BASE_REG;
1543         *disp = 0;
1544     }
1545 }
1546 #endif /* CONFIG_SOFTMMU */
1547
1548 /* load data with address translation (if applicable)
1549    and endianness conversion */
1550 static void tcg_out_qemu_ld(TCGContext* s, const TCGArg* args, int opc)
1551 {
1552     TCGReg addr_reg, data_reg;
1553 #if defined(CONFIG_SOFTMMU)
1554     int mem_index;
1555     uint16_t *label2_ptr;
1556 #else
1557     TCGReg index_reg;
1558     tcg_target_long disp;
1559 #endif
1560
1561     data_reg = *args++;
1562     addr_reg = *args++;
1563
1564 #if defined(CONFIG_SOFTMMU)
1565     mem_index = *args;
1566
1567     tcg_prepare_qemu_ldst(s, data_reg, addr_reg, mem_index,
1568                           opc, &label2_ptr, 0);
1569
1570     tcg_out_qemu_ld_direct(s, opc, data_reg, TCG_REG_R2, TCG_REG_NONE, 0);
1571
1572     tcg_finish_qemu_ldst(s, label2_ptr);
1573 #else
1574     tcg_prepare_user_ldst(s, &addr_reg, &index_reg, &disp);
1575     tcg_out_qemu_ld_direct(s, opc, data_reg, addr_reg, index_reg, disp);
1576 #endif
1577 }
1578
1579 static void tcg_out_qemu_st(TCGContext* s, const TCGArg* args, int opc)
1580 {
1581     TCGReg addr_reg, data_reg;
1582 #if defined(CONFIG_SOFTMMU)
1583     int mem_index;
1584     uint16_t *label2_ptr;
1585 #else
1586     TCGReg index_reg;
1587     tcg_target_long disp;
1588 #endif
1589
1590     data_reg = *args++;
1591     addr_reg = *args++;
1592
1593 #if defined(CONFIG_SOFTMMU)
1594     mem_index = *args;
1595
1596     tcg_prepare_qemu_ldst(s, data_reg, addr_reg, mem_index,
1597                           opc, &label2_ptr, 1);
1598
1599     tcg_out_qemu_st_direct(s, opc, data_reg, TCG_REG_R2, TCG_REG_NONE, 0);
1600
1601     tcg_finish_qemu_ldst(s, label2_ptr);
1602 #else
1603     tcg_prepare_user_ldst(s, &addr_reg, &index_reg, &disp);
1604     tcg_out_qemu_st_direct(s, opc, data_reg, addr_reg, index_reg, disp);
1605 #endif
1606 }
1607
1608 #if TCG_TARGET_REG_BITS == 64
1609 # define OP_32_64(x) \
1610         case glue(glue(INDEX_op_,x),_i32): \
1611         case glue(glue(INDEX_op_,x),_i64)
1612 #else
1613 # define OP_32_64(x) \
1614         case glue(glue(INDEX_op_,x),_i32)
1615 #endif
1616
1617 static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
1618                 const TCGArg *args, const int *const_args)
1619 {
1620     S390Opcode op;
1621
1622     switch (opc) {
1623     case INDEX_op_exit_tb:
1624         /* return value */
1625         tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_R2, args[0]);
1626         tgen_gotoi(s, S390_CC_ALWAYS, (unsigned long)tb_ret_addr);
1627         break;
1628
1629     case INDEX_op_goto_tb:
1630         if (s->tb_jmp_offset) {
1631             tcg_abort();
1632         } else {
1633             /* load address stored at s->tb_next + args[0] */
1634             tcg_out_ld_abs(s, TCG_TYPE_PTR, TCG_TMP0, s->tb_next + args[0]);
1635             /* and go there */
1636             tcg_out_insn(s, RR, BCR, S390_CC_ALWAYS, TCG_TMP0);
1637         }
1638         s->tb_next_offset[args[0]] = s->code_ptr - s->code_buf;
1639         break;
1640
1641     case INDEX_op_call:
1642         if (const_args[0]) {
1643             tgen_calli(s, args[0]);
1644         } else {
1645             tcg_out_insn(s, RR, BASR, TCG_REG_R14, args[0]);
1646         }
1647         break;
1648
1649     case INDEX_op_mov_i32:
1650         tcg_out_mov(s, TCG_TYPE_I32, args[0], args[1]);
1651         break;
1652     case INDEX_op_movi_i32:
1653         tcg_out_movi(s, TCG_TYPE_I32, args[0], args[1]);
1654         break;
1655
1656     OP_32_64(ld8u):
1657         /* ??? LLC (RXY format) is only present with the extended-immediate
1658            facility, whereas LLGC is always present.  */
1659         tcg_out_mem(s, 0, RXY_LLGC, args[0], args[1], TCG_REG_NONE, args[2]);
1660         break;
1661
1662     OP_32_64(ld8s):
1663         /* ??? LB is no smaller than LGB, so no point to using it.  */
1664         tcg_out_mem(s, 0, RXY_LGB, args[0], args[1], TCG_REG_NONE, args[2]);
1665         break;
1666
1667     OP_32_64(ld16u):
1668         /* ??? LLH (RXY format) is only present with the extended-immediate
1669            facility, whereas LLGH is always present.  */
1670         tcg_out_mem(s, 0, RXY_LLGH, args[0], args[1], TCG_REG_NONE, args[2]);
1671         break;
1672
1673     case INDEX_op_ld16s_i32:
1674         tcg_out_mem(s, RX_LH, RXY_LHY, args[0], args[1], TCG_REG_NONE, args[2]);
1675         break;
1676
1677     case INDEX_op_ld_i32:
1678         tcg_out_ld(s, TCG_TYPE_I32, args[0], args[1], args[2]);
1679         break;
1680
1681     OP_32_64(st8):
1682         tcg_out_mem(s, RX_STC, RXY_STCY, args[0], args[1],
1683                     TCG_REG_NONE, args[2]);
1684         break;
1685
1686     OP_32_64(st16):
1687         tcg_out_mem(s, RX_STH, RXY_STHY, args[0], args[1],
1688                     TCG_REG_NONE, args[2]);
1689         break;
1690
1691     case INDEX_op_st_i32:
1692         tcg_out_st(s, TCG_TYPE_I32, args[0], args[1], args[2]);
1693         break;
1694
1695     case INDEX_op_add_i32:
1696         if (const_args[2]) {
1697             tgen32_addi(s, args[0], args[2]);
1698         } else {
1699             tcg_out_insn(s, RR, AR, args[0], args[2]);
1700         }
1701         break;
1702     case INDEX_op_sub_i32:
1703         if (const_args[2]) {
1704             tgen32_addi(s, args[0], -args[2]);
1705         } else {
1706             tcg_out_insn(s, RR, SR, args[0], args[2]);
1707         }
1708         break;
1709
1710     case INDEX_op_and_i32:
1711         if (const_args[2]) {
1712             tgen64_andi(s, args[0], args[2] | 0xffffffff00000000ull);
1713         } else {
1714             tcg_out_insn(s, RR, NR, args[0], args[2]);
1715         }
1716         break;
1717     case INDEX_op_or_i32:
1718         if (const_args[2]) {
1719             tgen64_ori(s, args[0], args[2] & 0xffffffff);
1720         } else {
1721             tcg_out_insn(s, RR, OR, args[0], args[2]);
1722         }
1723         break;
1724     case INDEX_op_xor_i32:
1725         if (const_args[2]) {
1726             tgen64_xori(s, args[0], args[2] & 0xffffffff);
1727         } else {
1728             tcg_out_insn(s, RR, XR, args[0], args[2]);
1729         }
1730         break;
1731
1732     case INDEX_op_neg_i32:
1733         tcg_out_insn(s, RR, LCR, args[0], args[1]);
1734         break;
1735
1736     case INDEX_op_mul_i32:
1737         if (const_args[2]) {
1738             if ((int32_t)args[2] == (int16_t)args[2]) {
1739                 tcg_out_insn(s, RI, MHI, args[0], args[2]);
1740             } else {
1741                 tcg_out_insn(s, RIL, MSFI, args[0], args[2]);
1742             }
1743         } else {
1744             tcg_out_insn(s, RRE, MSR, args[0], args[2]);
1745         }
1746         break;
1747
1748     case INDEX_op_div2_i32:
1749         tcg_out_insn(s, RR, DR, TCG_REG_R2, args[4]);
1750         break;
1751     case INDEX_op_divu2_i32:
1752         tcg_out_insn(s, RRE, DLR, TCG_REG_R2, args[4]);
1753         break;
1754
1755     case INDEX_op_shl_i32:
1756         op = RS_SLL;
1757     do_shift32:
1758         if (const_args[2]) {
1759             tcg_out_sh32(s, op, args[0], TCG_REG_NONE, args[2]);
1760         } else {
1761             tcg_out_sh32(s, op, args[0], args[2], 0);
1762         }
1763         break;
1764     case INDEX_op_shr_i32:
1765         op = RS_SRL;
1766         goto do_shift32;
1767     case INDEX_op_sar_i32:
1768         op = RS_SRA;
1769         goto do_shift32;
1770
1771     case INDEX_op_rotl_i32:
1772         /* ??? Using tcg_out_sh64 here for the format; it is a 32-bit rol.  */
1773         if (const_args[2]) {
1774             tcg_out_sh64(s, RSY_RLL, args[0], args[1], TCG_REG_NONE, args[2]);
1775         } else {
1776             tcg_out_sh64(s, RSY_RLL, args[0], args[1], args[2], 0);
1777         }
1778         break;
1779     case INDEX_op_rotr_i32:
1780         if (const_args[2]) {
1781             tcg_out_sh64(s, RSY_RLL, args[0], args[1],
1782                          TCG_REG_NONE, (32 - args[2]) & 31);
1783         } else {
1784             tcg_out_insn(s, RR, LCR, TCG_TMP0, args[2]);
1785             tcg_out_sh64(s, RSY_RLL, args[0], args[1], TCG_TMP0, 0);
1786         }
1787         break;
1788
1789     case INDEX_op_ext8s_i32:
1790         tgen_ext8s(s, TCG_TYPE_I32, args[0], args[1]);
1791         break;
1792     case INDEX_op_ext16s_i32:
1793         tgen_ext16s(s, TCG_TYPE_I32, args[0], args[1]);
1794         break;
1795     case INDEX_op_ext8u_i32:
1796         tgen_ext8u(s, TCG_TYPE_I32, args[0], args[1]);
1797         break;
1798     case INDEX_op_ext16u_i32:
1799         tgen_ext16u(s, TCG_TYPE_I32, args[0], args[1]);
1800         break;
1801
1802     OP_32_64(bswap16):
1803         /* The TCG bswap definition requires bits 0-47 already be zero.
1804            Thus we don't need the G-type insns to implement bswap16_i64.  */
1805         tcg_out_insn(s, RRE, LRVR, args[0], args[1]);
1806         tcg_out_sh32(s, RS_SRL, args[0], TCG_REG_NONE, 16);
1807         break;
1808     OP_32_64(bswap32):
1809         tcg_out_insn(s, RRE, LRVR, args[0], args[1]);
1810         break;
1811
1812     case INDEX_op_br:
1813         tgen_branch(s, S390_CC_ALWAYS, args[0]);
1814         break;
1815
1816     case INDEX_op_brcond_i32:
1817         tgen_brcond(s, TCG_TYPE_I32, args[2], args[0],
1818                     args[1], const_args[1], args[3]);
1819         break;
1820     case INDEX_op_setcond_i32:
1821         tgen_setcond(s, TCG_TYPE_I32, args[3], args[0], args[1],
1822                      args[2], const_args[2]);
1823         break;
1824
1825     case INDEX_op_qemu_ld8u:
1826         tcg_out_qemu_ld(s, args, LD_UINT8);
1827         break;
1828     case INDEX_op_qemu_ld8s:
1829         tcg_out_qemu_ld(s, args, LD_INT8);
1830         break;
1831     case INDEX_op_qemu_ld16u:
1832         tcg_out_qemu_ld(s, args, LD_UINT16);
1833         break;
1834     case INDEX_op_qemu_ld16s:
1835         tcg_out_qemu_ld(s, args, LD_INT16);
1836         break;
1837     case INDEX_op_qemu_ld32:
1838         /* ??? Technically we can use a non-extending instruction.  */
1839         tcg_out_qemu_ld(s, args, LD_UINT32);
1840         break;
1841     case INDEX_op_qemu_ld64:
1842         tcg_out_qemu_ld(s, args, LD_UINT64);
1843         break;
1844
1845     case INDEX_op_qemu_st8:
1846         tcg_out_qemu_st(s, args, LD_UINT8);
1847         break;
1848     case INDEX_op_qemu_st16:
1849         tcg_out_qemu_st(s, args, LD_UINT16);
1850         break;
1851     case INDEX_op_qemu_st32:
1852         tcg_out_qemu_st(s, args, LD_UINT32);
1853         break;
1854     case INDEX_op_qemu_st64:
1855         tcg_out_qemu_st(s, args, LD_UINT64);
1856         break;
1857
1858 #if TCG_TARGET_REG_BITS == 64
1859     case INDEX_op_mov_i64:
1860         tcg_out_mov(s, TCG_TYPE_I64, args[0], args[1]);
1861         break;
1862     case INDEX_op_movi_i64:
1863         tcg_out_movi(s, TCG_TYPE_I64, args[0], args[1]);
1864         break;
1865
1866     case INDEX_op_ld16s_i64:
1867         tcg_out_mem(s, 0, RXY_LGH, args[0], args[1], TCG_REG_NONE, args[2]);
1868         break;
1869     case INDEX_op_ld32u_i64:
1870         tcg_out_mem(s, 0, RXY_LLGF, args[0], args[1], TCG_REG_NONE, args[2]);
1871         break;
1872     case INDEX_op_ld32s_i64:
1873         tcg_out_mem(s, 0, RXY_LGF, args[0], args[1], TCG_REG_NONE, args[2]);
1874         break;
1875     case INDEX_op_ld_i64:
1876         tcg_out_ld(s, TCG_TYPE_I64, args[0], args[1], args[2]);
1877         break;
1878
1879     case INDEX_op_st32_i64:
1880         tcg_out_st(s, TCG_TYPE_I32, args[0], args[1], args[2]);
1881         break;
1882     case INDEX_op_st_i64:
1883         tcg_out_st(s, TCG_TYPE_I64, args[0], args[1], args[2]);
1884         break;
1885
1886     case INDEX_op_add_i64:
1887         if (const_args[2]) {
1888             tgen64_addi(s, args[0], args[2]);
1889         } else {
1890             tcg_out_insn(s, RRE, AGR, args[0], args[2]);
1891         }
1892         break;
1893     case INDEX_op_sub_i64:
1894         if (const_args[2]) {
1895             tgen64_addi(s, args[0], -args[2]);
1896         } else {
1897             tcg_out_insn(s, RRE, SGR, args[0], args[2]);
1898         }
1899         break;
1900
1901     case INDEX_op_and_i64:
1902         if (const_args[2]) {
1903             tgen64_andi(s, args[0], args[2]);
1904         } else {
1905             tcg_out_insn(s, RRE, NGR, args[0], args[2]);
1906         }
1907         break;
1908     case INDEX_op_or_i64:
1909         if (const_args[2]) {
1910             tgen64_ori(s, args[0], args[2]);
1911         } else {
1912             tcg_out_insn(s, RRE, OGR, args[0], args[2]);
1913         }
1914         break;
1915     case INDEX_op_xor_i64:
1916         if (const_args[2]) {
1917             tgen64_xori(s, args[0], args[2]);
1918         } else {
1919             tcg_out_insn(s, RRE, XGR, args[0], args[2]);
1920         }
1921         break;
1922
1923     case INDEX_op_neg_i64:
1924         tcg_out_insn(s, RRE, LCGR, args[0], args[1]);
1925         break;
1926     case INDEX_op_bswap64_i64:
1927         tcg_out_insn(s, RRE, LRVGR, args[0], args[1]);
1928         break;
1929
1930     case INDEX_op_mul_i64:
1931         if (const_args[2]) {
1932             if (args[2] == (int16_t)args[2]) {
1933                 tcg_out_insn(s, RI, MGHI, args[0], args[2]);
1934             } else {
1935                 tcg_out_insn(s, RIL, MSGFI, args[0], args[2]);
1936             }
1937         } else {
1938             tcg_out_insn(s, RRE, MSGR, args[0], args[2]);
1939         }
1940         break;
1941
1942     case INDEX_op_div2_i64:
1943         /* ??? We get an unnecessary sign-extension of the dividend
1944            into R3 with this definition, but as we do in fact always
1945            produce both quotient and remainder using INDEX_op_div_i64
1946            instead requires jumping through even more hoops.  */
1947         tcg_out_insn(s, RRE, DSGR, TCG_REG_R2, args[4]);
1948         break;
1949     case INDEX_op_divu2_i64:
1950         tcg_out_insn(s, RRE, DLGR, TCG_REG_R2, args[4]);
1951         break;
1952
1953     case INDEX_op_shl_i64:
1954         op = RSY_SLLG;
1955     do_shift64:
1956         if (const_args[2]) {
1957             tcg_out_sh64(s, op, args[0], args[1], TCG_REG_NONE, args[2]);
1958         } else {
1959             tcg_out_sh64(s, op, args[0], args[1], args[2], 0);
1960         }
1961         break;
1962     case INDEX_op_shr_i64:
1963         op = RSY_SRLG;
1964         goto do_shift64;
1965     case INDEX_op_sar_i64:
1966         op = RSY_SRAG;
1967         goto do_shift64;
1968
1969     case INDEX_op_rotl_i64:
1970         if (const_args[2]) {
1971             tcg_out_sh64(s, RSY_RLLG, args[0], args[1],
1972                          TCG_REG_NONE, args[2]);
1973         } else {
1974             tcg_out_sh64(s, RSY_RLLG, args[0], args[1], args[2], 0);
1975         }
1976         break;
1977     case INDEX_op_rotr_i64:
1978         if (const_args[2]) {
1979             tcg_out_sh64(s, RSY_RLLG, args[0], args[1],
1980                          TCG_REG_NONE, (64 - args[2]) & 63);
1981         } else {
1982             /* We can use the smaller 32-bit negate because only the
1983                low 6 bits are examined for the rotate.  */
1984             tcg_out_insn(s, RR, LCR, TCG_TMP0, args[2]);
1985             tcg_out_sh64(s, RSY_RLLG, args[0], args[1], TCG_TMP0, 0);
1986         }
1987         break;
1988
1989     case INDEX_op_ext8s_i64:
1990         tgen_ext8s(s, TCG_TYPE_I64, args[0], args[1]);
1991         break;
1992     case INDEX_op_ext16s_i64:
1993         tgen_ext16s(s, TCG_TYPE_I64, args[0], args[1]);
1994         break;
1995     case INDEX_op_ext32s_i64:
1996         tgen_ext32s(s, args[0], args[1]);
1997         break;
1998     case INDEX_op_ext8u_i64:
1999         tgen_ext8u(s, TCG_TYPE_I64, args[0], args[1]);
2000         break;
2001     case INDEX_op_ext16u_i64:
2002         tgen_ext16u(s, TCG_TYPE_I64, args[0], args[1]);
2003         break;
2004     case INDEX_op_ext32u_i64:
2005         tgen_ext32u(s, args[0], args[1]);
2006         break;
2007
2008     case INDEX_op_brcond_i64:
2009         tgen_brcond(s, TCG_TYPE_I64, args[2], args[0],
2010                     args[1], const_args[1], args[3]);
2011         break;
2012     case INDEX_op_setcond_i64:
2013         tgen_setcond(s, TCG_TYPE_I64, args[3], args[0], args[1],
2014                      args[2], const_args[2]);
2015         break;
2016
2017     case INDEX_op_qemu_ld32u:
2018         tcg_out_qemu_ld(s, args, LD_UINT32);
2019         break;
2020     case INDEX_op_qemu_ld32s:
2021         tcg_out_qemu_ld(s, args, LD_INT32);
2022         break;
2023 #endif /* TCG_TARGET_REG_BITS == 64 */
2024
2025     case INDEX_op_jmp:
2026         /* This one is obsolete and never emitted.  */
2027         tcg_abort();
2028         break;
2029
2030     default:
2031         fprintf(stderr,"unimplemented opc 0x%x\n",opc);
2032         tcg_abort();
2033     }
2034 }
2035
2036 static const TCGTargetOpDef s390_op_defs[] = {
2037     { INDEX_op_exit_tb, { } },
2038     { INDEX_op_goto_tb, { } },
2039     { INDEX_op_call, { "ri" } },
2040     { INDEX_op_jmp, { "ri" } },
2041     { INDEX_op_br, { } },
2042
2043     { INDEX_op_mov_i32, { "r", "r" } },
2044     { INDEX_op_movi_i32, { "r" } },
2045
2046     { INDEX_op_ld8u_i32, { "r", "r" } },
2047     { INDEX_op_ld8s_i32, { "r", "r" } },
2048     { INDEX_op_ld16u_i32, { "r", "r" } },
2049     { INDEX_op_ld16s_i32, { "r", "r" } },
2050     { INDEX_op_ld_i32, { "r", "r" } },
2051     { INDEX_op_st8_i32, { "r", "r" } },
2052     { INDEX_op_st16_i32, { "r", "r" } },
2053     { INDEX_op_st_i32, { "r", "r" } },
2054
2055     { INDEX_op_add_i32, { "r", "0", "rWI" } },
2056     { INDEX_op_sub_i32, { "r", "0", "rWNI" } },
2057     { INDEX_op_mul_i32, { "r", "0", "rK" } },
2058
2059     { INDEX_op_div2_i32, { "b", "a", "0", "1", "r" } },
2060     { INDEX_op_divu2_i32, { "b", "a", "0", "1", "r" } },
2061
2062     { INDEX_op_and_i32, { "r", "0", "rWA" } },
2063     { INDEX_op_or_i32, { "r", "0", "rWO" } },
2064     { INDEX_op_xor_i32, { "r", "0", "rWX" } },
2065
2066     { INDEX_op_neg_i32, { "r", "r" } },
2067
2068     { INDEX_op_shl_i32, { "r", "0", "Ri" } },
2069     { INDEX_op_shr_i32, { "r", "0", "Ri" } },
2070     { INDEX_op_sar_i32, { "r", "0", "Ri" } },
2071
2072     { INDEX_op_rotl_i32, { "r", "r", "Ri" } },
2073     { INDEX_op_rotr_i32, { "r", "r", "Ri" } },
2074
2075     { INDEX_op_ext8s_i32, { "r", "r" } },
2076     { INDEX_op_ext8u_i32, { "r", "r" } },
2077     { INDEX_op_ext16s_i32, { "r", "r" } },
2078     { INDEX_op_ext16u_i32, { "r", "r" } },
2079
2080     { INDEX_op_bswap16_i32, { "r", "r" } },
2081     { INDEX_op_bswap32_i32, { "r", "r" } },
2082
2083     { INDEX_op_brcond_i32, { "r", "rWC" } },
2084     { INDEX_op_setcond_i32, { "r", "r", "rWC" } },
2085
2086     { INDEX_op_qemu_ld8u, { "r", "L" } },
2087     { INDEX_op_qemu_ld8s, { "r", "L" } },
2088     { INDEX_op_qemu_ld16u, { "r", "L" } },
2089     { INDEX_op_qemu_ld16s, { "r", "L" } },
2090     { INDEX_op_qemu_ld32, { "r", "L" } },
2091     { INDEX_op_qemu_ld64, { "r", "L" } },
2092
2093     { INDEX_op_qemu_st8, { "L", "L" } },
2094     { INDEX_op_qemu_st16, { "L", "L" } },
2095     { INDEX_op_qemu_st32, { "L", "L" } },
2096     { INDEX_op_qemu_st64, { "L", "L" } },
2097
2098 #if defined(__s390x__)
2099     { INDEX_op_mov_i64, { "r", "r" } },
2100     { INDEX_op_movi_i64, { "r" } },
2101
2102     { INDEX_op_ld8u_i64, { "r", "r" } },
2103     { INDEX_op_ld8s_i64, { "r", "r" } },
2104     { INDEX_op_ld16u_i64, { "r", "r" } },
2105     { INDEX_op_ld16s_i64, { "r", "r" } },
2106     { INDEX_op_ld32u_i64, { "r", "r" } },
2107     { INDEX_op_ld32s_i64, { "r", "r" } },
2108     { INDEX_op_ld_i64, { "r", "r" } },
2109
2110     { INDEX_op_st8_i64, { "r", "r" } },
2111     { INDEX_op_st16_i64, { "r", "r" } },
2112     { INDEX_op_st32_i64, { "r", "r" } },
2113     { INDEX_op_st_i64, { "r", "r" } },
2114
2115     { INDEX_op_add_i64, { "r", "0", "rI" } },
2116     { INDEX_op_sub_i64, { "r", "0", "rNI" } },
2117     { INDEX_op_mul_i64, { "r", "0", "rK" } },
2118
2119     { INDEX_op_div2_i64, { "b", "a", "0", "1", "r" } },
2120     { INDEX_op_divu2_i64, { "b", "a", "0", "1", "r" } },
2121
2122     { INDEX_op_and_i64, { "r", "0", "rA" } },
2123     { INDEX_op_or_i64, { "r", "0", "rO" } },
2124     { INDEX_op_xor_i64, { "r", "0", "rX" } },
2125
2126     { INDEX_op_neg_i64, { "r", "r" } },
2127
2128     { INDEX_op_shl_i64, { "r", "r", "Ri" } },
2129     { INDEX_op_shr_i64, { "r", "r", "Ri" } },
2130     { INDEX_op_sar_i64, { "r", "r", "Ri" } },
2131
2132     { INDEX_op_rotl_i64, { "r", "r", "Ri" } },
2133     { INDEX_op_rotr_i64, { "r", "r", "Ri" } },
2134
2135     { INDEX_op_ext8s_i64, { "r", "r" } },
2136     { INDEX_op_ext8u_i64, { "r", "r" } },
2137     { INDEX_op_ext16s_i64, { "r", "r" } },
2138     { INDEX_op_ext16u_i64, { "r", "r" } },
2139     { INDEX_op_ext32s_i64, { "r", "r" } },
2140     { INDEX_op_ext32u_i64, { "r", "r" } },
2141
2142     { INDEX_op_bswap16_i64, { "r", "r" } },
2143     { INDEX_op_bswap32_i64, { "r", "r" } },
2144     { INDEX_op_bswap64_i64, { "r", "r" } },
2145
2146     { INDEX_op_brcond_i64, { "r", "rC" } },
2147     { INDEX_op_setcond_i64, { "r", "r", "rC" } },
2148
2149     { INDEX_op_qemu_ld32u, { "r", "L" } },
2150     { INDEX_op_qemu_ld32s, { "r", "L" } },
2151 #endif
2152
2153     { -1 },
2154 };
2155
2156 /* ??? Linux kernels provide an AUXV entry AT_HWCAP that provides most of
2157    this information.  However, getting at that entry is not easy this far
2158    away from main.  Our options are: start searching from environ, but
2159    that fails as soon as someone does a setenv in between.  Read the data
2160    from /proc/self/auxv.  Or do the probing ourselves.  The only thing
2161    extra that AT_HWCAP gives us is HWCAP_S390_HIGH_GPRS, which indicates
2162    that the kernel saves all 64-bits of the registers around traps while
2163    in 31-bit mode.  But this is true of all "recent" kernels (ought to dig
2164    back and see from when this might not be true).  */
2165
2166 #include <signal.h>
2167
2168 static volatile sig_atomic_t got_sigill;
2169
2170 static void sigill_handler(int sig)
2171 {
2172     got_sigill = 1;
2173 }
2174
2175 static void query_facilities(void)
2176 {
2177     struct sigaction sa_old, sa_new;
2178     register int r0 __asm__("0");
2179     register void *r1 __asm__("1");
2180     int fail;
2181
2182     memset(&sa_new, 0, sizeof(sa_new));
2183     sa_new.sa_handler = sigill_handler;
2184     sigaction(SIGILL, &sa_new, &sa_old);
2185
2186     /* First, try STORE FACILITY LIST EXTENDED.  If this is present, then
2187        we need not do any more probing.  Unfortunately, this itself is an
2188        extension and the original STORE FACILITY LIST instruction is
2189        kernel-only, storing its results at absolute address 200.  */
2190     /* stfle 0(%r1) */
2191     r1 = &facilities;
2192     asm volatile(".word 0xb2b0,0x1000"
2193                  : "=r"(r0) : "0"(0), "r"(r1) : "memory", "cc");
2194
2195     if (got_sigill) {
2196         /* STORE FACILITY EXTENDED is not available.  Probe for one of each
2197            kind of instruction that we're interested in.  */
2198         /* ??? Possibly some of these are in practice never present unless
2199            the store-facility-extended facility is also present.  But since
2200            that isn't documented it's just better to probe for each.  */
2201
2202         /* Test for z/Architecture.  Required even in 31-bit mode.  */
2203         got_sigill = 0;
2204         /* agr %r0,%r0 */
2205         asm volatile(".word 0xb908,0x0000" : "=r"(r0) : : "cc");
2206         if (!got_sigill) {
2207             facilities |= FACILITY_ZARCH_ACTIVE;
2208         }
2209
2210         /* Test for long displacement.  */
2211         got_sigill = 0;
2212         /* ly %r0,0(%r1) */
2213         r1 = &facilities;
2214         asm volatile(".word 0xe300,0x1000,0x0058"
2215                      : "=r"(r0) : "r"(r1) : "cc");
2216         if (!got_sigill) {
2217             facilities |= FACILITY_LONG_DISP;
2218         }
2219
2220         /* Test for extended immediates.  */
2221         got_sigill = 0;
2222         /* afi %r0,0 */
2223         asm volatile(".word 0xc209,0x0000,0x0000" : : : "cc");
2224         if (!got_sigill) {
2225             facilities |= FACILITY_EXT_IMM;
2226         }
2227
2228         /* Test for general-instructions-extension.  */
2229         got_sigill = 0;
2230         /* msfi %r0,1 */
2231         asm volatile(".word 0xc201,0x0000,0x0001");
2232         if (!got_sigill) {
2233             facilities |= FACILITY_GEN_INST_EXT;
2234         }
2235     }
2236
2237     sigaction(SIGILL, &sa_old, NULL);
2238
2239     /* The translator currently uses these extensions unconditionally.
2240        Pruning this back to the base ESA/390 architecture doesn't seem
2241        worthwhile, since even the KVM target requires z/Arch.  */
2242     fail = 0;
2243     if ((facilities & FACILITY_ZARCH_ACTIVE) == 0) {
2244         fprintf(stderr, "TCG: z/Arch facility is required.\n");
2245         fprintf(stderr, "TCG: Boot with a 64-bit enabled kernel.\n");
2246         fail = 1;
2247     }
2248     if ((facilities & FACILITY_LONG_DISP) == 0) {
2249         fprintf(stderr, "TCG: long-displacement facility is required.\n");
2250         fail = 1;
2251     }
2252
2253     /* So far there's just enough support for 31-bit mode to let the
2254        compile succeed.  This is good enough to run QEMU with KVM.  */
2255     if (sizeof(void *) != 8) {
2256         fprintf(stderr, "TCG: 31-bit mode is not supported.\n");
2257         fail = 1;
2258     }
2259
2260     if (fail) {
2261         exit(-1);
2262     }
2263 }
2264
2265 static void tcg_target_init(TCGContext *s)
2266 {
2267 #if !defined(CONFIG_USER_ONLY)
2268     /* fail safe */
2269     if ((1 << CPU_TLB_ENTRY_BITS) != sizeof(CPUTLBEntry)) {
2270         tcg_abort();
2271     }
2272 #endif
2273
2274     query_facilities();
2275
2276     tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I32], 0, 0xffff);
2277     tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I64], 0, 0xffff);
2278
2279     tcg_regset_clear(tcg_target_call_clobber_regs);
2280     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R0);
2281     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R1);
2282     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R2);
2283     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R3);
2284     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R4);
2285     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R5);
2286     /* The return register can be considered call-clobbered.  */
2287     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R14);
2288
2289     tcg_regset_clear(s->reserved_regs);
2290     tcg_regset_set_reg(s->reserved_regs, TCG_TMP0);
2291     /* XXX many insns can't be used with R0, so we better avoid it for now */
2292     tcg_regset_set_reg(s->reserved_regs, TCG_REG_R0);
2293     tcg_regset_set_reg(s->reserved_regs, TCG_REG_CALL_STACK);
2294
2295     tcg_add_target_add_op_defs(s390_op_defs);
2296     tcg_set_frame(s, TCG_AREG0, offsetof(CPUArchState, temp_buf),
2297                   CPU_TEMP_BUF_NLONGS * sizeof(long));
2298 }
2299
2300 static void tcg_target_qemu_prologue(TCGContext *s)
2301 {
2302     /* stmg %r6,%r15,48(%r15) (save registers) */
2303     tcg_out_insn(s, RXY, STMG, TCG_REG_R6, TCG_REG_R15, TCG_REG_R15, 48);
2304
2305     /* aghi %r15,-160 (stack frame) */
2306     tcg_out_insn(s, RI, AGHI, TCG_REG_R15, -160);
2307
2308     if (GUEST_BASE >= 0x80000) {
2309         tcg_out_movi(s, TCG_TYPE_PTR, TCG_GUEST_BASE_REG, GUEST_BASE);
2310         tcg_regset_set_reg(s->reserved_regs, TCG_GUEST_BASE_REG);
2311     }
2312
2313     tcg_out_mov(s, TCG_TYPE_PTR, TCG_AREG0, tcg_target_call_iarg_regs[0]);
2314     /* br %r3 (go to TB) */
2315     tcg_out_insn(s, RR, BCR, S390_CC_ALWAYS, tcg_target_call_iarg_regs[1]);
2316
2317     tb_ret_addr = s->code_ptr;
2318
2319     /* lmg %r6,%r15,208(%r15) (restore registers) */
2320     tcg_out_insn(s, RXY, LMG, TCG_REG_R6, TCG_REG_R15, TCG_REG_R15, 208);
2321
2322     /* br %r14 (return) */
2323     tcg_out_insn(s, RR, BCR, S390_CC_ALWAYS, TCG_REG_R14);
2324 }