tcg/s390/tcg-target.inc.c

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