tcg/aarch64/tcg-target.c.inc

   1 /*
   2  * Initial TCG Implementation for aarch64
   3  *
   4  * Copyright (c) 2013 Huawei Technologies Duesseldorf GmbH
   5  * Written by Claudio Fontana
   6  *
   7  * This work is licensed under the terms of the GNU GPL, version 2 or
   8  * (at your option) any later version.
   9  *
  10  * See the COPYING file in the top-level directory for details.
  11  */
  12
  13 #include "../tcg-pool.c.inc"
  14 #include "qemu/bitops.h"
  15
  16 /* We're going to re-use TCGType in setting of the SF bit, which controls
  17    the size of the operation performed.  If we know the values match, it
  18    makes things much cleaner.  */
  19 QEMU_BUILD_BUG_ON(TCG_TYPE_I32 != 0 || TCG_TYPE_I64 != 1);
  20
  21 #ifdef CONFIG_DEBUG_TCG
  22 static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
  23     "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
  24     "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
  25     "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
  26     "x24", "x25", "x26", "x27", "x28", "fp", "x30", "sp",
  27
  28     "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
  29     "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
  30     "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
  31     "v24", "v25", "v26", "v27", "v28", "fp", "v30", "v31",
  32 };
  33 #endif /* CONFIG_DEBUG_TCG */
  34
  35 static const int tcg_target_reg_alloc_order[] = {
  36     TCG_REG_X20, TCG_REG_X21, TCG_REG_X22, TCG_REG_X23,
  37     TCG_REG_X24, TCG_REG_X25, TCG_REG_X26, TCG_REG_X27,
  38     TCG_REG_X28, /* we will reserve this for guest_base if configured */
  39
  40     TCG_REG_X8, TCG_REG_X9, TCG_REG_X10, TCG_REG_X11,
  41     TCG_REG_X12, TCG_REG_X13, TCG_REG_X14, TCG_REG_X15,
  42     TCG_REG_X16, TCG_REG_X17,
  43
  44     TCG_REG_X0, TCG_REG_X1, TCG_REG_X2, TCG_REG_X3,
  45     TCG_REG_X4, TCG_REG_X5, TCG_REG_X6, TCG_REG_X7,
  46
  47     /* X18 reserved by system */
  48     /* X19 reserved for AREG0 */
  49     /* X29 reserved as fp */
  50     /* X30 reserved as temporary */
  51
  52     TCG_REG_V0, TCG_REG_V1, TCG_REG_V2, TCG_REG_V3,
  53     TCG_REG_V4, TCG_REG_V5, TCG_REG_V6, TCG_REG_V7,
  54     /* V8 - V15 are call-saved, and skipped.  */
  55     TCG_REG_V16, TCG_REG_V17, TCG_REG_V18, TCG_REG_V19,
  56     TCG_REG_V20, TCG_REG_V21, TCG_REG_V22, TCG_REG_V23,
  57     TCG_REG_V24, TCG_REG_V25, TCG_REG_V26, TCG_REG_V27,
  58     TCG_REG_V28, TCG_REG_V29, TCG_REG_V30, TCG_REG_V31,
  59 };
  60
  61 static const int tcg_target_call_iarg_regs[8] = {
  62     TCG_REG_X0, TCG_REG_X1, TCG_REG_X2, TCG_REG_X3,
  63     TCG_REG_X4, TCG_REG_X5, TCG_REG_X6, TCG_REG_X7
  64 };
  65 static const int tcg_target_call_oarg_regs[1] = {
  66     TCG_REG_X0
  67 };
  68
  69 #define TCG_REG_TMP TCG_REG_X30
  70 #define TCG_VEC_TMP TCG_REG_V31
  71
  72 #ifndef CONFIG_SOFTMMU
  73 /* Note that XZR cannot be encoded in the address base register slot,
  74    as that actaully encodes SP.  So if we need to zero-extend the guest
  75    address, via the address index register slot, we need to load even
  76    a zero guest base into a register.  */
  77 #define USE_GUEST_BASE     (guest_base != 0 || TARGET_LONG_BITS == 32)
  78 #define TCG_REG_GUEST_BASE TCG_REG_X28
  79 #endif
  80
  81 static inline bool reloc_pc26(tcg_insn_unit *code_ptr, tcg_insn_unit *target)
  82 {
  83     ptrdiff_t offset = target - code_ptr;
  84     if (offset == sextract64(offset, 0, 26)) {
  85         /* read instruction, mask away previous PC_REL26 parameter contents,
  86            set the proper offset, then write back the instruction. */
  87         *code_ptr = deposit32(*code_ptr, 0, 26, offset);
  88         return true;
  89     }
  90     return false;
  91 }
  92
  93 static inline bool reloc_pc19(tcg_insn_unit *code_ptr, tcg_insn_unit *target)
  94 {
  95     ptrdiff_t offset = target - code_ptr;
  96     if (offset == sextract64(offset, 0, 19)) {
  97         *code_ptr = deposit32(*code_ptr, 5, 19, offset);
  98         return true;
  99     }
 100     return false;
 101 }
 102
 103 static inline bool patch_reloc(tcg_insn_unit *code_ptr, int type,
 104                                intptr_t value, intptr_t addend)
 105 {
 106     tcg_debug_assert(addend == 0);
 107     switch (type) {
 108     case R_AARCH64_JUMP26:
 109     case R_AARCH64_CALL26:
 110         return reloc_pc26(code_ptr, (tcg_insn_unit *)value);
 111     case R_AARCH64_CONDBR19:
 112         return reloc_pc19(code_ptr, (tcg_insn_unit *)value);
 113     default:
 114         g_assert_not_reached();
 115     }
 116 }
 117
 118 #define TCG_CT_CONST_AIMM 0x100
 119 #define TCG_CT_CONST_LIMM 0x200
 120 #define TCG_CT_CONST_ZERO 0x400
 121 #define TCG_CT_CONST_MONE 0x800
 122 #define TCG_CT_CONST_ORRI 0x1000
 123 #define TCG_CT_CONST_ANDI 0x2000
 124
 125 /* parse target specific constraints */
 126 static const char *target_parse_constraint(TCGArgConstraint *ct,
 127                                            const char *ct_str, TCGType type)
 128 {
 129     switch (*ct_str++) {
 130     case 'r': /* general registers */
 131         ct->ct |= TCG_CT_REG;
 132         ct->u.regs |= 0xffffffffu;
 133         break;
 134     case 'w': /* advsimd registers */
 135         ct->ct |= TCG_CT_REG;
 136         ct->u.regs |= 0xffffffff00000000ull;
 137         break;
 138     case 'l': /* qemu_ld / qemu_st address, data_reg */
 139         ct->ct |= TCG_CT_REG;
 140         ct->u.regs = 0xffffffffu;
 141 #ifdef CONFIG_SOFTMMU
 142         /* x0 and x1 will be overwritten when reading the tlb entry,
 143            and x2, and x3 for helper args, better to avoid using them. */
 144         tcg_regset_reset_reg(ct->u.regs, TCG_REG_X0);
 145         tcg_regset_reset_reg(ct->u.regs, TCG_REG_X1);
 146         tcg_regset_reset_reg(ct->u.regs, TCG_REG_X2);
 147         tcg_regset_reset_reg(ct->u.regs, TCG_REG_X3);
 148 #endif
 149         break;
 150     case 'A': /* Valid for arithmetic immediate (positive or negative).  */
 151         ct->ct |= TCG_CT_CONST_AIMM;
 152         break;
 153     case 'L': /* Valid for logical immediate.  */
 154         ct->ct |= TCG_CT_CONST_LIMM;
 155         break;
 156     case 'M': /* minus one */
 157         ct->ct |= TCG_CT_CONST_MONE;
 158         break;
 159     case 'O': /* vector orr/bic immediate */
 160         ct->ct |= TCG_CT_CONST_ORRI;
 161         break;
 162     case 'N': /* vector orr/bic immediate, inverted */
 163         ct->ct |= TCG_CT_CONST_ANDI;
 164         break;
 165     case 'Z': /* zero */
 166         ct->ct |= TCG_CT_CONST_ZERO;
 167         break;
 168     default:
 169         return NULL;
 170     }
 171     return ct_str;
 172 }
 173
 174 /* Match a constant valid for addition (12-bit, optionally shifted).  */
 175 static inline bool is_aimm(uint64_t val)
 176 {
 177     return (val & ~0xfff) == 0 || (val & ~0xfff000) == 0;
 178 }
 179
 180 /* Match a constant valid for logical operations.  */
 181 static inline bool is_limm(uint64_t val)
 182 {
 183     /* Taking a simplified view of the logical immediates for now, ignoring
 184        the replication that can happen across the field.  Match bit patterns
 185        of the forms
 186            0....01....1
 187            0..01..10..0
 188        and their inverses.  */
 189
 190     /* Make things easier below, by testing the form with msb clear. */
 191     if ((int64_t)val < 0) {
 192         val = ~val;
 193     }
 194     if (val == 0) {
 195         return false;
 196     }
 197     val += val & -val;
 198     return (val & (val - 1)) == 0;
 199 }
 200
 201 /* Return true if v16 is a valid 16-bit shifted immediate.  */
 202 static bool is_shimm16(uint16_t v16, int *cmode, int *imm8)
 203 {
 204     if (v16 == (v16 & 0xff)) {
 205         *cmode = 0x8;
 206         *imm8 = v16 & 0xff;
 207         return true;
 208     } else if (v16 == (v16 & 0xff00)) {
 209         *cmode = 0xa;
 210         *imm8 = v16 >> 8;
 211         return true;
 212     }
 213     return false;
 214 }
 215
 216 /* Return true if v32 is a valid 32-bit shifted immediate.  */
 217 static bool is_shimm32(uint32_t v32, int *cmode, int *imm8)
 218 {
 219     if (v32 == (v32 & 0xff)) {
 220         *cmode = 0x0;
 221         *imm8 = v32 & 0xff;
 222         return true;
 223     } else if (v32 == (v32 & 0xff00)) {
 224         *cmode = 0x2;
 225         *imm8 = (v32 >> 8) & 0xff;
 226         return true;
 227     } else if (v32 == (v32 & 0xff0000)) {
 228         *cmode = 0x4;
 229         *imm8 = (v32 >> 16) & 0xff;
 230         return true;
 231     } else if (v32 == (v32 & 0xff000000)) {
 232         *cmode = 0x6;
 233         *imm8 = v32 >> 24;
 234         return true;
 235     }
 236     return false;
 237 }
 238
 239 /* Return true if v32 is a valid 32-bit shifting ones immediate.  */
 240 static bool is_soimm32(uint32_t v32, int *cmode, int *imm8)
 241 {
 242     if ((v32 & 0xffff00ff) == 0xff) {
 243         *cmode = 0xc;
 244         *imm8 = (v32 >> 8) & 0xff;
 245         return true;
 246     } else if ((v32 & 0xff00ffff) == 0xffff) {
 247         *cmode = 0xd;
 248         *imm8 = (v32 >> 16) & 0xff;
 249         return true;
 250     }
 251     return false;
 252 }
 253
 254 /* Return true if v32 is a valid float32 immediate.  */
 255 static bool is_fimm32(uint32_t v32, int *cmode, int *imm8)
 256 {
 257     if (extract32(v32, 0, 19) == 0
 258         && (extract32(v32, 25, 6) == 0x20
 259             || extract32(v32, 25, 6) == 0x1f)) {
 260         *cmode = 0xf;
 261         *imm8 = (extract32(v32, 31, 1) << 7)
 262               | (extract32(v32, 25, 1) << 6)
 263               | extract32(v32, 19, 6);
 264         return true;
 265     }
 266     return false;
 267 }
 268
 269 /* Return true if v64 is a valid float64 immediate.  */
 270 static bool is_fimm64(uint64_t v64, int *cmode, int *imm8)
 271 {
 272     if (extract64(v64, 0, 48) == 0
 273         && (extract64(v64, 54, 9) == 0x100
 274             || extract64(v64, 54, 9) == 0x0ff)) {
 275         *cmode = 0xf;
 276         *imm8 = (extract64(v64, 63, 1) << 7)
 277               | (extract64(v64, 54, 1) << 6)
 278               | extract64(v64, 48, 6);
 279         return true;
 280     }
 281     return false;
 282 }
 283
 284 /*
 285  * Return non-zero if v32 can be formed by MOVI+ORR.
 286  * Place the parameters for MOVI in (cmode, imm8).
 287  * Return the cmode for ORR; the imm8 can be had via extraction from v32.
 288  */
 289 static int is_shimm32_pair(uint32_t v32, int *cmode, int *imm8)
 290 {
 291     int i;
 292
 293     for (i = 6; i > 0; i -= 2) {
 294         /* Mask out one byte we can add with ORR.  */
 295         uint32_t tmp = v32 & ~(0xffu << (i * 4));
 296         if (is_shimm32(tmp, cmode, imm8) ||
 297             is_soimm32(tmp, cmode, imm8)) {
 298             break;
 299         }
 300     }
 301     return i;
 302 }
 303
 304 /* Return true if V is a valid 16-bit or 32-bit shifted immediate.  */
 305 static bool is_shimm1632(uint32_t v32, int *cmode, int *imm8)
 306 {
 307     if (v32 == deposit32(v32, 16, 16, v32)) {
 308         return is_shimm16(v32, cmode, imm8);
 309     } else {
 310         return is_shimm32(v32, cmode, imm8);
 311     }
 312 }
 313
 314 static int tcg_target_const_match(tcg_target_long val, TCGType type,
 315                                   const TCGArgConstraint *arg_ct)
 316 {
 317     int ct = arg_ct->ct;
 318
 319     if (ct & TCG_CT_CONST) {
 320         return 1;
 321     }
 322     if (type == TCG_TYPE_I32) {
 323         val = (int32_t)val;
 324     }
 325     if ((ct & TCG_CT_CONST_AIMM) && (is_aimm(val) || is_aimm(-val))) {
 326         return 1;
 327     }
 328     if ((ct & TCG_CT_CONST_LIMM) && is_limm(val)) {
 329         return 1;
 330     }
 331     if ((ct & TCG_CT_CONST_ZERO) && val == 0) {
 332         return 1;
 333     }
 334     if ((ct & TCG_CT_CONST_MONE) && val == -1) {
 335         return 1;
 336     }
 337
 338     switch (ct & (TCG_CT_CONST_ORRI | TCG_CT_CONST_ANDI)) {
 339     case 0:
 340         break;
 341     case TCG_CT_CONST_ANDI:
 342         val = ~val;
 343         /* fallthru */
 344     case TCG_CT_CONST_ORRI:
 345         if (val == deposit64(val, 32, 32, val)) {
 346             int cmode, imm8;
 347             return is_shimm1632(val, &cmode, &imm8);
 348         }
 349         break;
 350     default:
 351         /* Both bits should not be set for the same insn.  */
 352         g_assert_not_reached();
 353     }
 354
 355     return 0;
 356 }
 357
 358 enum aarch64_cond_code {
 359     COND_EQ = 0x0,
 360     COND_NE = 0x1,
 361     COND_CS = 0x2,     /* Unsigned greater or equal */
 362     COND_HS = COND_CS, /* ALIAS greater or equal */
 363     COND_CC = 0x3,     /* Unsigned less than */
 364     COND_LO = COND_CC, /* ALIAS Lower */
 365     COND_MI = 0x4,     /* Negative */
 366     COND_PL = 0x5,     /* Zero or greater */
 367     COND_VS = 0x6,     /* Overflow */
 368     COND_VC = 0x7,     /* No overflow */
 369     COND_HI = 0x8,     /* Unsigned greater than */
 370     COND_LS = 0x9,     /* Unsigned less or equal */
 371     COND_GE = 0xa,
 372     COND_LT = 0xb,
 373     COND_GT = 0xc,
 374     COND_LE = 0xd,
 375     COND_AL = 0xe,
 376     COND_NV = 0xf, /* behaves like COND_AL here */
 377 };
 378
 379 static const enum aarch64_cond_code tcg_cond_to_aarch64[] = {
 380     [TCG_COND_EQ] = COND_EQ,
 381     [TCG_COND_NE] = COND_NE,
 382     [TCG_COND_LT] = COND_LT,
 383     [TCG_COND_GE] = COND_GE,
 384     [TCG_COND_LE] = COND_LE,
 385     [TCG_COND_GT] = COND_GT,
 386     /* unsigned */
 387     [TCG_COND_LTU] = COND_LO,
 388     [TCG_COND_GTU] = COND_HI,
 389     [TCG_COND_GEU] = COND_HS,
 390     [TCG_COND_LEU] = COND_LS,
 391 };
 392
 393 typedef enum {
 394     LDST_ST = 0,    /* store */
 395     LDST_LD = 1,    /* load */
 396     LDST_LD_S_X = 2,  /* load and sign-extend into Xt */
 397     LDST_LD_S_W = 3,  /* load and sign-extend into Wt */
 398 } AArch64LdstType;
 399
 400 /* We encode the format of the insn into the beginning of the name, so that
 401    we can have the preprocessor help "typecheck" the insn vs the output
 402    function.  Arm didn't provide us with nice names for the formats, so we
 403    use the section number of the architecture reference manual in which the
 404    instruction group is described.  */
 405 typedef enum {
 406     /* Compare and branch (immediate).  */
 407     I3201_CBZ       = 0x34000000,
 408     I3201_CBNZ      = 0x35000000,
 409
 410     /* Conditional branch (immediate).  */
 411     I3202_B_C       = 0x54000000,
 412
 413     /* Unconditional branch (immediate).  */
 414     I3206_B         = 0x14000000,
 415     I3206_BL        = 0x94000000,
 416
 417     /* Unconditional branch (register).  */
 418     I3207_BR        = 0xd61f0000,
 419     I3207_BLR       = 0xd63f0000,
 420     I3207_RET       = 0xd65f0000,
 421
 422     /* AdvSIMD load/store single structure.  */
 423     I3303_LD1R      = 0x0d40c000,
 424
 425     /* Load literal for loading the address at pc-relative offset */
 426     I3305_LDR       = 0x58000000,
 427     I3305_LDR_v64   = 0x5c000000,
 428     I3305_LDR_v128  = 0x9c000000,
 429
 430     /* Load/store register.  Described here as 3.3.12, but the helper
 431        that emits them can transform to 3.3.10 or 3.3.13.  */
 432     I3312_STRB      = 0x38000000 | LDST_ST << 22 | MO_8 << 30,
 433     I3312_STRH      = 0x38000000 | LDST_ST << 22 | MO_16 << 30,
 434     I3312_STRW      = 0x38000000 | LDST_ST << 22 | MO_32 << 30,
 435     I3312_STRX      = 0x38000000 | LDST_ST << 22 | MO_64 << 30,
 436
 437     I3312_LDRB      = 0x38000000 | LDST_LD << 22 | MO_8 << 30,
 438     I3312_LDRH      = 0x38000000 | LDST_LD << 22 | MO_16 << 30,
 439     I3312_LDRW      = 0x38000000 | LDST_LD << 22 | MO_32 << 30,
 440     I3312_LDRX      = 0x38000000 | LDST_LD << 22 | MO_64 << 30,
 441
 442     I3312_LDRSBW    = 0x38000000 | LDST_LD_S_W << 22 | MO_8 << 30,
 443     I3312_LDRSHW    = 0x38000000 | LDST_LD_S_W << 22 | MO_16 << 30,
 444
 445     I3312_LDRSBX    = 0x38000000 | LDST_LD_S_X << 22 | MO_8 << 30,
 446     I3312_LDRSHX    = 0x38000000 | LDST_LD_S_X << 22 | MO_16 << 30,
 447     I3312_LDRSWX    = 0x38000000 | LDST_LD_S_X << 22 | MO_32 << 30,
 448
 449     I3312_LDRVS     = 0x3c000000 | LDST_LD << 22 | MO_32 << 30,
 450     I3312_STRVS     = 0x3c000000 | LDST_ST << 22 | MO_32 << 30,
 451
 452     I3312_LDRVD     = 0x3c000000 | LDST_LD << 22 | MO_64 << 30,
 453     I3312_STRVD     = 0x3c000000 | LDST_ST << 22 | MO_64 << 30,
 454
 455     I3312_LDRVQ     = 0x3c000000 | 3 << 22 | 0 << 30,
 456     I3312_STRVQ     = 0x3c000000 | 2 << 22 | 0 << 30,
 457
 458     I3312_TO_I3310  = 0x00200800,
 459     I3312_TO_I3313  = 0x01000000,
 460
 461     /* Load/store register pair instructions.  */
 462     I3314_LDP       = 0x28400000,
 463     I3314_STP       = 0x28000000,
 464
 465     /* Add/subtract immediate instructions.  */
 466     I3401_ADDI      = 0x11000000,
 467     I3401_ADDSI     = 0x31000000,
 468     I3401_SUBI      = 0x51000000,
 469     I3401_SUBSI     = 0x71000000,
 470
 471     /* Bitfield instructions.  */
 472     I3402_BFM       = 0x33000000,
 473     I3402_SBFM      = 0x13000000,
 474     I3402_UBFM      = 0x53000000,
 475
 476     /* Extract instruction.  */
 477     I3403_EXTR      = 0x13800000,
 478
 479     /* Logical immediate instructions.  */
 480     I3404_ANDI      = 0x12000000,
 481     I3404_ORRI      = 0x32000000,
 482     I3404_EORI      = 0x52000000,
 483
 484     /* Move wide immediate instructions.  */
 485     I3405_MOVN      = 0x12800000,
 486     I3405_MOVZ      = 0x52800000,
 487     I3405_MOVK      = 0x72800000,
 488
 489     /* PC relative addressing instructions.  */
 490     I3406_ADR       = 0x10000000,
 491     I3406_ADRP      = 0x90000000,
 492
 493     /* Add/subtract shifted register instructions (without a shift).  */
 494     I3502_ADD       = 0x0b000000,
 495     I3502_ADDS      = 0x2b000000,
 496     I3502_SUB       = 0x4b000000,
 497     I3502_SUBS      = 0x6b000000,
 498
 499     /* Add/subtract shifted register instructions (with a shift).  */
 500     I3502S_ADD_LSL  = I3502_ADD,
 501
 502     /* Add/subtract with carry instructions.  */
 503     I3503_ADC       = 0x1a000000,
 504     I3503_SBC       = 0x5a000000,
 505
 506     /* Conditional select instructions.  */
 507     I3506_CSEL      = 0x1a800000,
 508     I3506_CSINC     = 0x1a800400,
 509     I3506_CSINV     = 0x5a800000,
 510     I3506_CSNEG     = 0x5a800400,
 511
 512     /* Data-processing (1 source) instructions.  */
 513     I3507_CLZ       = 0x5ac01000,
 514     I3507_RBIT      = 0x5ac00000,
 515     I3507_REV16     = 0x5ac00400,
 516     I3507_REV32     = 0x5ac00800,
 517     I3507_REV64     = 0x5ac00c00,
 518
 519     /* Data-processing (2 source) instructions.  */
 520     I3508_LSLV      = 0x1ac02000,
 521     I3508_LSRV      = 0x1ac02400,
 522     I3508_ASRV      = 0x1ac02800,
 523     I3508_RORV      = 0x1ac02c00,
 524     I3508_SMULH     = 0x9b407c00,
 525     I3508_UMULH     = 0x9bc07c00,
 526     I3508_UDIV      = 0x1ac00800,
 527     I3508_SDIV      = 0x1ac00c00,
 528
 529     /* Data-processing (3 source) instructions.  */
 530     I3509_MADD      = 0x1b000000,
 531     I3509_MSUB      = 0x1b008000,
 532
 533     /* Logical shifted register instructions (without a shift).  */
 534     I3510_AND       = 0x0a000000,
 535     I3510_BIC       = 0x0a200000,
 536     I3510_ORR       = 0x2a000000,
 537     I3510_ORN       = 0x2a200000,
 538     I3510_EOR       = 0x4a000000,
 539     I3510_EON       = 0x4a200000,
 540     I3510_ANDS      = 0x6a000000,
 541
 542     /* Logical shifted register instructions (with a shift).  */
 543     I3502S_AND_LSR  = I3510_AND | (1 << 22),
 544
 545     /* AdvSIMD copy */
 546     I3605_DUP      = 0x0e000400,
 547     I3605_INS      = 0x4e001c00,
 548     I3605_UMOV     = 0x0e003c00,
 549
 550     /* AdvSIMD modified immediate */
 551     I3606_MOVI      = 0x0f000400,
 552     I3606_MVNI      = 0x2f000400,
 553     I3606_BIC       = 0x2f001400,
 554     I3606_ORR       = 0x0f001400,
 555
 556     /* AdvSIMD shift by immediate */
 557     I3614_SSHR      = 0x0f000400,
 558     I3614_SSRA      = 0x0f001400,
 559     I3614_SHL       = 0x0f005400,
 560     I3614_SLI       = 0x2f005400,
 561     I3614_USHR      = 0x2f000400,
 562     I3614_USRA      = 0x2f001400,
 563
 564     /* AdvSIMD three same.  */
 565     I3616_ADD       = 0x0e208400,
 566     I3616_AND       = 0x0e201c00,
 567     I3616_BIC       = 0x0e601c00,
 568     I3616_BIF       = 0x2ee01c00,
 569     I3616_BIT       = 0x2ea01c00,
 570     I3616_BSL       = 0x2e601c00,
 571     I3616_EOR       = 0x2e201c00,
 572     I3616_MUL       = 0x0e209c00,
 573     I3616_ORR       = 0x0ea01c00,
 574     I3616_ORN       = 0x0ee01c00,
 575     I3616_SUB       = 0x2e208400,
 576     I3616_CMGT      = 0x0e203400,
 577     I3616_CMGE      = 0x0e203c00,
 578     I3616_CMTST     = 0x0e208c00,
 579     I3616_CMHI      = 0x2e203400,
 580     I3616_CMHS      = 0x2e203c00,
 581     I3616_CMEQ      = 0x2e208c00,
 582     I3616_SMAX      = 0x0e206400,
 583     I3616_SMIN      = 0x0e206c00,
 584     I3616_SSHL      = 0x0e204400,
 585     I3616_SQADD     = 0x0e200c00,
 586     I3616_SQSUB     = 0x0e202c00,
 587     I3616_UMAX      = 0x2e206400,
 588     I3616_UMIN      = 0x2e206c00,
 589     I3616_UQADD     = 0x2e200c00,
 590     I3616_UQSUB     = 0x2e202c00,
 591     I3616_USHL      = 0x2e204400,
 592
 593     /* AdvSIMD two-reg misc.  */
 594     I3617_CMGT0     = 0x0e208800,
 595     I3617_CMEQ0     = 0x0e209800,
 596     I3617_CMLT0     = 0x0e20a800,
 597     I3617_CMGE0     = 0x2e208800,
 598     I3617_CMLE0     = 0x2e20a800,
 599     I3617_NOT       = 0x2e205800,
 600     I3617_ABS       = 0x0e20b800,
 601     I3617_NEG       = 0x2e20b800,
 602
 603     /* System instructions.  */
 604     NOP             = 0xd503201f,
 605     DMB_ISH         = 0xd50338bf,
 606     DMB_LD          = 0x00000100,
 607     DMB_ST          = 0x00000200,
 608 } AArch64Insn;
 609
 610 static inline uint32_t tcg_in32(TCGContext *s)
 611 {
 612     uint32_t v = *(uint32_t *)s->code_ptr;
 613     return v;
 614 }
 615
 616 /* Emit an opcode with "type-checking" of the format.  */
 617 #define tcg_out_insn(S, FMT, OP, ...) \
 618     glue(tcg_out_insn_,FMT)(S, glue(glue(glue(I,FMT),_),OP), ## __VA_ARGS__)
 619
 620 static void tcg_out_insn_3303(TCGContext *s, AArch64Insn insn, bool q,
 621                               TCGReg rt, TCGReg rn, unsigned size)
 622 {
 623     tcg_out32(s, insn | (rt & 0x1f) | (rn << 5) | (size << 10) | (q << 30));
 624 }
 625
 626 static void tcg_out_insn_3305(TCGContext *s, AArch64Insn insn,
 627                               int imm19, TCGReg rt)
 628 {
 629     tcg_out32(s, insn | (imm19 & 0x7ffff) << 5 | rt);
 630 }
 631
 632 static void tcg_out_insn_3201(TCGContext *s, AArch64Insn insn, TCGType ext,
 633                               TCGReg rt, int imm19)
 634 {
 635     tcg_out32(s, insn | ext << 31 | (imm19 & 0x7ffff) << 5 | rt);
 636 }
 637
 638 static void tcg_out_insn_3202(TCGContext *s, AArch64Insn insn,
 639                               TCGCond c, int imm19)
 640 {
 641     tcg_out32(s, insn | tcg_cond_to_aarch64[c] | (imm19 & 0x7ffff) << 5);
 642 }
 643
 644 static void tcg_out_insn_3206(TCGContext *s, AArch64Insn insn, int imm26)
 645 {
 646     tcg_out32(s, insn | (imm26 & 0x03ffffff));
 647 }
 648
 649 static void tcg_out_insn_3207(TCGContext *s, AArch64Insn insn, TCGReg rn)
 650 {
 651     tcg_out32(s, insn | rn << 5);
 652 }
 653
 654 static void tcg_out_insn_3314(TCGContext *s, AArch64Insn insn,
 655                               TCGReg r1, TCGReg r2, TCGReg rn,
 656                               tcg_target_long ofs, bool pre, bool w)
 657 {
 658     insn |= 1u << 31; /* ext */
 659     insn |= pre << 24;
 660     insn |= w << 23;
 661
 662     tcg_debug_assert(ofs >= -0x200 && ofs < 0x200 && (ofs & 7) == 0);
 663     insn |= (ofs & (0x7f << 3)) << (15 - 3);
 664
 665     tcg_out32(s, insn | r2 << 10 | rn << 5 | r1);
 666 }
 667
 668 static void tcg_out_insn_3401(TCGContext *s, AArch64Insn insn, TCGType ext,
 669                               TCGReg rd, TCGReg rn, uint64_t aimm)
 670 {
 671     if (aimm > 0xfff) {
 672         tcg_debug_assert((aimm & 0xfff) == 0);
 673         aimm >>= 12;
 674         tcg_debug_assert(aimm <= 0xfff);
 675         aimm |= 1 << 12;  /* apply LSL 12 */
 676     }
 677     tcg_out32(s, insn | ext << 31 | aimm << 10 | rn << 5 | rd);
 678 }
 679
 680 /* This function can be used for both 3.4.2 (Bitfield) and 3.4.4
 681    (Logical immediate).  Both insn groups have N, IMMR and IMMS fields
 682    that feed the DecodeBitMasks pseudo function.  */
 683 static void tcg_out_insn_3402(TCGContext *s, AArch64Insn insn, TCGType ext,
 684                               TCGReg rd, TCGReg rn, int n, int immr, int imms)
 685 {
 686     tcg_out32(s, insn | ext << 31 | n << 22 | immr << 16 | imms << 10
 687               | rn << 5 | rd);
 688 }
 689
 690 #define tcg_out_insn_3404  tcg_out_insn_3402
 691
 692 static void tcg_out_insn_3403(TCGContext *s, AArch64Insn insn, TCGType ext,
 693                               TCGReg rd, TCGReg rn, TCGReg rm, int imms)
 694 {
 695     tcg_out32(s, insn | ext << 31 | ext << 22 | rm << 16 | imms << 10
 696               | rn << 5 | rd);
 697 }
 698
 699 /* This function is used for the Move (wide immediate) instruction group.
 700    Note that SHIFT is a full shift count, not the 2 bit HW field. */
 701 static void tcg_out_insn_3405(TCGContext *s, AArch64Insn insn, TCGType ext,
 702                               TCGReg rd, uint16_t half, unsigned shift)
 703 {
 704     tcg_debug_assert((shift & ~0x30) == 0);
 705     tcg_out32(s, insn | ext << 31 | shift << (21 - 4) | half << 5 | rd);
 706 }
 707
 708 static void tcg_out_insn_3406(TCGContext *s, AArch64Insn insn,
 709                               TCGReg rd, int64_t disp)
 710 {
 711     tcg_out32(s, insn | (disp & 3) << 29 | (disp & 0x1ffffc) << (5 - 2) | rd);
 712 }
 713
 714 /* This function is for both 3.5.2 (Add/Subtract shifted register), for
 715    the rare occasion when we actually want to supply a shift amount.  */
 716 static inline void tcg_out_insn_3502S(TCGContext *s, AArch64Insn insn,
 717                                       TCGType ext, TCGReg rd, TCGReg rn,
 718                                       TCGReg rm, int imm6)
 719 {
 720     tcg_out32(s, insn | ext << 31 | rm << 16 | imm6 << 10 | rn << 5 | rd);
 721 }
 722
 723 /* This function is for 3.5.2 (Add/subtract shifted register),
 724    and 3.5.10 (Logical shifted register), for the vast majorty of cases
 725    when we don't want to apply a shift.  Thus it can also be used for
 726    3.5.3 (Add/subtract with carry) and 3.5.8 (Data processing 2 source).  */
 727 static void tcg_out_insn_3502(TCGContext *s, AArch64Insn insn, TCGType ext,
 728                               TCGReg rd, TCGReg rn, TCGReg rm)
 729 {
 730     tcg_out32(s, insn | ext << 31 | rm << 16 | rn << 5 | rd);
 731 }
 732
 733 #define tcg_out_insn_3503  tcg_out_insn_3502
 734 #define tcg_out_insn_3508  tcg_out_insn_3502
 735 #define tcg_out_insn_3510  tcg_out_insn_3502
 736
 737 static void tcg_out_insn_3506(TCGContext *s, AArch64Insn insn, TCGType ext,
 738                               TCGReg rd, TCGReg rn, TCGReg rm, TCGCond c)
 739 {
 740     tcg_out32(s, insn | ext << 31 | rm << 16 | rn << 5 | rd
 741               | tcg_cond_to_aarch64[c] << 12);
 742 }
 743
 744 static void tcg_out_insn_3507(TCGContext *s, AArch64Insn insn, TCGType ext,
 745                               TCGReg rd, TCGReg rn)
 746 {
 747     tcg_out32(s, insn | ext << 31 | rn << 5 | rd);
 748 }
 749
 750 static void tcg_out_insn_3509(TCGContext *s, AArch64Insn insn, TCGType ext,
 751                               TCGReg rd, TCGReg rn, TCGReg rm, TCGReg ra)
 752 {
 753     tcg_out32(s, insn | ext << 31 | rm << 16 | ra << 10 | rn << 5 | rd);
 754 }
 755
 756 static void tcg_out_insn_3605(TCGContext *s, AArch64Insn insn, bool q,
 757                               TCGReg rd, TCGReg rn, int dst_idx, int src_idx)
 758 {
 759     /* Note that bit 11 set means general register input.  Therefore
 760        we can handle both register sets with one function.  */
 761     tcg_out32(s, insn | q << 30 | (dst_idx << 16) | (src_idx << 11)
 762               | (rd & 0x1f) | (~rn & 0x20) << 6 | (rn & 0x1f) << 5);
 763 }
 764
 765 static void tcg_out_insn_3606(TCGContext *s, AArch64Insn insn, bool q,
 766                               TCGReg rd, bool op, int cmode, uint8_t imm8)
 767 {
 768     tcg_out32(s, insn | q << 30 | op << 29 | cmode << 12 | (rd & 0x1f)
 769               | (imm8 & 0xe0) << (16 - 5) | (imm8 & 0x1f) << 5);
 770 }
 771
 772 static void tcg_out_insn_3614(TCGContext *s, AArch64Insn insn, bool q,
 773                               TCGReg rd, TCGReg rn, unsigned immhb)
 774 {
 775     tcg_out32(s, insn | q << 30 | immhb << 16
 776               | (rn & 0x1f) << 5 | (rd & 0x1f));
 777 }
 778
 779 static void tcg_out_insn_3616(TCGContext *s, AArch64Insn insn, bool q,
 780                               unsigned size, TCGReg rd, TCGReg rn, TCGReg rm)
 781 {
 782     tcg_out32(s, insn | q << 30 | (size << 22) | (rm & 0x1f) << 16
 783               | (rn & 0x1f) << 5 | (rd & 0x1f));
 784 }
 785
 786 static void tcg_out_insn_3617(TCGContext *s, AArch64Insn insn, bool q,
 787                               unsigned size, TCGReg rd, TCGReg rn)
 788 {
 789     tcg_out32(s, insn | q << 30 | (size << 22)
 790               | (rn & 0x1f) << 5 | (rd & 0x1f));
 791 }
 792
 793 static void tcg_out_insn_3310(TCGContext *s, AArch64Insn insn,
 794                               TCGReg rd, TCGReg base, TCGType ext,
 795                               TCGReg regoff)
 796 {
 797     /* Note the AArch64Insn constants above are for C3.3.12.  Adjust.  */
 798     tcg_out32(s, insn | I3312_TO_I3310 | regoff << 16 |
 799               0x4000 | ext << 13 | base << 5 | (rd & 0x1f));
 800 }
 801
 802 static void tcg_out_insn_3312(TCGContext *s, AArch64Insn insn,
 803                               TCGReg rd, TCGReg rn, intptr_t offset)
 804 {
 805     tcg_out32(s, insn | (offset & 0x1ff) << 12 | rn << 5 | (rd & 0x1f));
 806 }
 807
 808 static void tcg_out_insn_3313(TCGContext *s, AArch64Insn insn,
 809                               TCGReg rd, TCGReg rn, uintptr_t scaled_uimm)
 810 {
 811     /* Note the AArch64Insn constants above are for C3.3.12.  Adjust.  */
 812     tcg_out32(s, insn | I3312_TO_I3313 | scaled_uimm << 10
 813               | rn << 5 | (rd & 0x1f));
 814 }
 815
 816 /* Register to register move using ORR (shifted register with no shift). */
 817 static void tcg_out_movr(TCGContext *s, TCGType ext, TCGReg rd, TCGReg rm)
 818 {
 819     tcg_out_insn(s, 3510, ORR, ext, rd, TCG_REG_XZR, rm);
 820 }
 821
 822 /* Register to register move using ADDI (move to/from SP).  */
 823 static void tcg_out_movr_sp(TCGContext *s, TCGType ext, TCGReg rd, TCGReg rn)
 824 {
 825     tcg_out_insn(s, 3401, ADDI, ext, rd, rn, 0);
 826 }
 827
 828 /* This function is used for the Logical (immediate) instruction group.
 829    The value of LIMM must satisfy IS_LIMM.  See the comment above about
 830    only supporting simplified logical immediates.  */
 831 static void tcg_out_logicali(TCGContext *s, AArch64Insn insn, TCGType ext,
 832                              TCGReg rd, TCGReg rn, uint64_t limm)
 833 {
 834     unsigned h, l, r, c;
 835
 836     tcg_debug_assert(is_limm(limm));
 837
 838     h = clz64(limm);
 839     l = ctz64(limm);
 840     if (l == 0) {
 841         r = 0;                  /* form 0....01....1 */
 842         c = ctz64(~limm) - 1;
 843         if (h == 0) {
 844             r = clz64(~limm);   /* form 1..10..01..1 */
 845             c += r;
 846         }
 847     } else {
 848         r = 64 - l;             /* form 1....10....0 or 0..01..10..0 */
 849         c = r - h - 1;
 850     }
 851     if (ext == TCG_TYPE_I32) {
 852         r &= 31;
 853         c &= 31;
 854     }
 855
 856     tcg_out_insn_3404(s, insn, ext, rd, rn, ext, r, c);
 857 }
 858
 859 static void tcg_out_dupi_vec(TCGContext *s, TCGType type,
 860                              TCGReg rd, tcg_target_long v64)
 861 {
 862     bool q = type == TCG_TYPE_V128;
 863     int cmode, imm8, i;
 864
 865     /* Test all bytes equal first.  */
 866     if (v64 == dup_const(MO_8, v64)) {
 867         imm8 = (uint8_t)v64;
 868         tcg_out_insn(s, 3606, MOVI, q, rd, 0, 0xe, imm8);
 869         return;
 870     }
 871
 872     /*
 873      * Test all bytes 0x00 or 0xff second.  This can match cases that
 874      * might otherwise take 2 or 3 insns for MO_16 or MO_32 below.
 875      */
 876     for (i = imm8 = 0; i < 8; i++) {
 877         uint8_t byte = v64 >> (i * 8);
 878         if (byte == 0xff) {
 879             imm8 |= 1 << i;
 880         } else if (byte != 0) {
 881             goto fail_bytes;
 882         }
 883     }
 884     tcg_out_insn(s, 3606, MOVI, q, rd, 1, 0xe, imm8);
 885     return;
 886  fail_bytes:
 887
 888     /*
 889      * Tests for various replications.  For each element width, if we
 890      * cannot find an expansion there's no point checking a larger
 891      * width because we already know by replication it cannot match.
 892      */
 893     if (v64 == dup_const(MO_16, v64)) {
 894         uint16_t v16 = v64;
 895
 896         if (is_shimm16(v16, &cmode, &imm8)) {
 897             tcg_out_insn(s, 3606, MOVI, q, rd, 0, cmode, imm8);
 898             return;
 899         }
 900         if (is_shimm16(~v16, &cmode, &imm8)) {
 901             tcg_out_insn(s, 3606, MVNI, q, rd, 0, cmode, imm8);
 902             return;
 903         }
 904
 905         /*
 906          * Otherwise, all remaining constants can be loaded in two insns:
 907          * rd = v16 & 0xff, rd |= v16 & 0xff00.
 908          */
 909         tcg_out_insn(s, 3606, MOVI, q, rd, 0, 0x8, v16 & 0xff);
 910         tcg_out_insn(s, 3606, ORR, q, rd, 0, 0xa, v16 >> 8);
 911         return;
 912     } else if (v64 == dup_const(MO_32, v64)) {
 913         uint32_t v32 = v64;
 914         uint32_t n32 = ~v32;
 915
 916         if (is_shimm32(v32, &cmode, &imm8) ||
 917             is_soimm32(v32, &cmode, &imm8) ||
 918             is_fimm32(v32, &cmode, &imm8)) {
 919             tcg_out_insn(s, 3606, MOVI, q, rd, 0, cmode, imm8);
 920             return;
 921         }
 922         if (is_shimm32(n32, &cmode, &imm8) ||
 923             is_soimm32(n32, &cmode, &imm8)) {
 924             tcg_out_insn(s, 3606, MVNI, q, rd, 0, cmode, imm8);
 925             return;
 926         }
 927
 928         /*
 929          * Restrict the set of constants to those we can load with
 930          * two instructions.  Others we load from the pool.
 931          */
 932         i = is_shimm32_pair(v32, &cmode, &imm8);
 933         if (i) {
 934             tcg_out_insn(s, 3606, MOVI, q, rd, 0, cmode, imm8);
 935             tcg_out_insn(s, 3606, ORR, q, rd, 0, i, extract32(v32, i * 4, 8));
 936             return;
 937         }
 938         i = is_shimm32_pair(n32, &cmode, &imm8);
 939         if (i) {
 940             tcg_out_insn(s, 3606, MVNI, q, rd, 0, cmode, imm8);
 941             tcg_out_insn(s, 3606, BIC, q, rd, 0, i, extract32(n32, i * 4, 8));
 942             return;
 943         }
 944     } else if (is_fimm64(v64, &cmode, &imm8)) {
 945         tcg_out_insn(s, 3606, MOVI, q, rd, 1, cmode, imm8);
 946         return;
 947     }
 948
 949     /*
 950      * As a last resort, load from the constant pool.  Sadly there
 951      * is no LD1R (literal), so store the full 16-byte vector.
 952      */
 953     if (type == TCG_TYPE_V128) {
 954         new_pool_l2(s, R_AARCH64_CONDBR19, s->code_ptr, 0, v64, v64);
 955         tcg_out_insn(s, 3305, LDR_v128, 0, rd);
 956     } else {
 957         new_pool_label(s, v64, R_AARCH64_CONDBR19, s->code_ptr, 0);
 958         tcg_out_insn(s, 3305, LDR_v64, 0, rd);
 959     }
 960 }
 961
 962 static bool tcg_out_dup_vec(TCGContext *s, TCGType type, unsigned vece,
 963                             TCGReg rd, TCGReg rs)
 964 {
 965     int is_q = type - TCG_TYPE_V64;
 966     tcg_out_insn(s, 3605, DUP, is_q, rd, rs, 1 << vece, 0);
 967     return true;
 968 }
 969
 970 static bool tcg_out_dupm_vec(TCGContext *s, TCGType type, unsigned vece,
 971                              TCGReg r, TCGReg base, intptr_t offset)
 972 {
 973     TCGReg temp = TCG_REG_TMP;
 974
 975     if (offset < -0xffffff || offset > 0xffffff) {
 976         tcg_out_movi(s, TCG_TYPE_PTR, temp, offset);
 977         tcg_out_insn(s, 3502, ADD, 1, temp, temp, base);
 978         base = temp;
 979     } else {
 980         AArch64Insn add_insn = I3401_ADDI;
 981
 982         if (offset < 0) {
 983             add_insn = I3401_SUBI;
 984             offset = -offset;
 985         }
 986         if (offset & 0xfff000) {
 987             tcg_out_insn_3401(s, add_insn, 1, temp, base, offset & 0xfff000);
 988             base = temp;
 989         }
 990         if (offset & 0xfff) {
 991             tcg_out_insn_3401(s, add_insn, 1, temp, base, offset & 0xfff);
 992             base = temp;
 993         }
 994     }
 995     tcg_out_insn(s, 3303, LD1R, type == TCG_TYPE_V128, r, base, vece);
 996     return true;
 997 }
 998
 999 static void tcg_out_movi(TCGContext *s, TCGType type, TCGReg rd,
1000                          tcg_target_long value)
1001 {
1002     tcg_target_long svalue = value;
1003     tcg_target_long ivalue = ~value;
1004     tcg_target_long t0, t1, t2;
1005     int s0, s1;
1006     AArch64Insn opc;
1007
1008     switch (type) {
1009     case TCG_TYPE_I32:
1010     case TCG_TYPE_I64:
1011         tcg_debug_assert(rd < 32);
1012         break;
1013
1014     case TCG_TYPE_V64:
1015     case TCG_TYPE_V128:
1016         tcg_debug_assert(rd >= 32);
1017         tcg_out_dupi_vec(s, type, rd, value);
1018         return;
1019
1020     default:
1021         g_assert_not_reached();
1022     }
1023
1024     /* For 32-bit values, discard potential garbage in value.  For 64-bit
1025        values within [2**31, 2**32-1], we can create smaller sequences by
1026        interpreting this as a negative 32-bit number, while ensuring that
1027        the high 32 bits are cleared by setting SF=0.  */
1028     if (type == TCG_TYPE_I32 || (value & ~0xffffffffull) == 0) {
1029         svalue = (int32_t)value;
1030         value = (uint32_t)value;
1031         ivalue = (uint32_t)ivalue;
1032         type = TCG_TYPE_I32;
1033     }
1034
1035     /* Speed things up by handling the common case of small positive
1036        and negative values specially.  */
1037     if ((value & ~0xffffull) == 0) {
1038         tcg_out_insn(s, 3405, MOVZ, type, rd, value, 0);
1039         return;
1040     } else if ((ivalue & ~0xffffull) == 0) {
1041         tcg_out_insn(s, 3405, MOVN, type, rd, ivalue, 0);
1042         return;
1043     }
1044
1045     /* Check for bitfield immediates.  For the benefit of 32-bit quantities,
1046        use the sign-extended value.  That lets us match rotated values such
1047        as 0xff0000ff with the same 64-bit logic matching 0xffffffffff0000ff. */
1048     if (is_limm(svalue)) {
1049         tcg_out_logicali(s, I3404_ORRI, type, rd, TCG_REG_XZR, svalue);
1050         return;
1051     }
1052
1053     /* Look for host pointer values within 4G of the PC.  This happens
1054        often when loading pointers to QEMU's own data structures.  */
1055     if (type == TCG_TYPE_I64) {
1056         tcg_target_long disp = value - (intptr_t)s->code_ptr;
1057         if (disp == sextract64(disp, 0, 21)) {
1058             tcg_out_insn(s, 3406, ADR, rd, disp);
1059             return;
1060         }
1061         disp = (value >> 12) - ((intptr_t)s->code_ptr >> 12);
1062         if (disp == sextract64(disp, 0, 21)) {
1063             tcg_out_insn(s, 3406, ADRP, rd, disp);
1064             if (value & 0xfff) {
1065                 tcg_out_insn(s, 3401, ADDI, type, rd, rd, value & 0xfff);
1066             }
1067             return;
1068         }
1069     }
1070
1071     /* Would it take fewer insns to begin with MOVN?  */
1072     if (ctpop64(value) >= 32) {
1073         t0 = ivalue;
1074         opc = I3405_MOVN;
1075     } else {
1076         t0 = value;
1077         opc = I3405_MOVZ;
1078     }
1079     s0 = ctz64(t0) & (63 & -16);
1080     t1 = t0 & ~(0xffffUL << s0);
1081     s1 = ctz64(t1) & (63 & -16);
1082     t2 = t1 & ~(0xffffUL << s1);
1083     if (t2 == 0) {
1084         tcg_out_insn_3405(s, opc, type, rd, t0 >> s0, s0);
1085         if (t1 != 0) {
1086             tcg_out_insn(s, 3405, MOVK, type, rd, value >> s1, s1);
1087         }
1088         return;
1089     }
1090
1091     /* For more than 2 insns, dump it into the constant pool.  */
1092     new_pool_label(s, value, R_AARCH64_CONDBR19, s->code_ptr, 0);
1093     tcg_out_insn(s, 3305, LDR, 0, rd);
1094 }
1095
1096 /* Define something more legible for general use.  */
1097 #define tcg_out_ldst_r  tcg_out_insn_3310
1098
1099 static void tcg_out_ldst(TCGContext *s, AArch64Insn insn, TCGReg rd,
1100                          TCGReg rn, intptr_t offset, int lgsize)
1101 {
1102     /* If the offset is naturally aligned and in range, then we can
1103        use the scaled uimm12 encoding */
1104     if (offset >= 0 && !(offset & ((1 << lgsize) - 1))) {
1105         uintptr_t scaled_uimm = offset >> lgsize;
1106         if (scaled_uimm <= 0xfff) {
1107             tcg_out_insn_3313(s, insn, rd, rn, scaled_uimm);
1108             return;
1109         }
1110     }
1111
1112     /* Small signed offsets can use the unscaled encoding.  */
1113     if (offset >= -256 && offset < 256) {
1114         tcg_out_insn_3312(s, insn, rd, rn, offset);
1115         return;
1116     }
1117
1118     /* Worst-case scenario, move offset to temp register, use reg offset.  */
1119     tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_TMP, offset);
1120     tcg_out_ldst_r(s, insn, rd, rn, TCG_TYPE_I64, TCG_REG_TMP);
1121 }
1122
1123 static bool tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg)
1124 {
1125     if (ret == arg) {
1126         return true;
1127     }
1128     switch (type) {
1129     case TCG_TYPE_I32:
1130     case TCG_TYPE_I64:
1131         if (ret < 32 && arg < 32) {
1132             tcg_out_movr(s, type, ret, arg);
1133             break;
1134         } else if (ret < 32) {
1135             tcg_out_insn(s, 3605, UMOV, type, ret, arg, 0, 0);
1136             break;
1137         } else if (arg < 32) {
1138             tcg_out_insn(s, 3605, INS, 0, ret, arg, 4 << type, 0);
1139             break;
1140         }
1141         /* FALLTHRU */
1142
1143     case TCG_TYPE_V64:
1144         tcg_debug_assert(ret >= 32 && arg >= 32);
1145         tcg_out_insn(s, 3616, ORR, 0, 0, ret, arg, arg);
1146         break;
1147     case TCG_TYPE_V128:
1148         tcg_debug_assert(ret >= 32 && arg >= 32);
1149         tcg_out_insn(s, 3616, ORR, 1, 0, ret, arg, arg);
1150         break;
1151
1152     default:
1153         g_assert_not_reached();
1154     }
1155     return true;
1156 }
1157
1158 static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret,
1159                        TCGReg base, intptr_t ofs)
1160 {
1161     AArch64Insn insn;
1162     int lgsz;
1163
1164     switch (type) {
1165     case TCG_TYPE_I32:
1166         insn = (ret < 32 ? I3312_LDRW : I3312_LDRVS);
1167         lgsz = 2;
1168         break;
1169     case TCG_TYPE_I64:
1170         insn = (ret < 32 ? I3312_LDRX : I3312_LDRVD);
1171         lgsz = 3;
1172         break;
1173     case TCG_TYPE_V64:
1174         insn = I3312_LDRVD;
1175         lgsz = 3;
1176         break;
1177     case TCG_TYPE_V128:
1178         insn = I3312_LDRVQ;
1179         lgsz = 4;
1180         break;
1181     default:
1182         g_assert_not_reached();
1183     }
1184     tcg_out_ldst(s, insn, ret, base, ofs, lgsz);
1185 }
1186
1187 static void tcg_out_st(TCGContext *s, TCGType type, TCGReg src,
1188                        TCGReg base, intptr_t ofs)
1189 {
1190     AArch64Insn insn;
1191     int lgsz;
1192
1193     switch (type) {
1194     case TCG_TYPE_I32:
1195         insn = (src < 32 ? I3312_STRW : I3312_STRVS);
1196         lgsz = 2;
1197         break;
1198     case TCG_TYPE_I64:
1199         insn = (src < 32 ? I3312_STRX : I3312_STRVD);
1200         lgsz = 3;
1201         break;
1202     case TCG_TYPE_V64:
1203         insn = I3312_STRVD;
1204         lgsz = 3;
1205         break;
1206     case TCG_TYPE_V128:
1207         insn = I3312_STRVQ;
1208         lgsz = 4;
1209         break;
1210     default:
1211         g_assert_not_reached();
1212     }
1213     tcg_out_ldst(s, insn, src, base, ofs, lgsz);
1214 }
1215
1216 static inline bool tcg_out_sti(TCGContext *s, TCGType type, TCGArg val,
1217                                TCGReg base, intptr_t ofs)
1218 {
1219     if (type <= TCG_TYPE_I64 && val == 0) {
1220         tcg_out_st(s, type, TCG_REG_XZR, base, ofs);
1221         return true;
1222     }
1223     return false;
1224 }
1225
1226 static inline void tcg_out_bfm(TCGContext *s, TCGType ext, TCGReg rd,
1227                                TCGReg rn, unsigned int a, unsigned int b)
1228 {
1229     tcg_out_insn(s, 3402, BFM, ext, rd, rn, ext, a, b);
1230 }
1231
1232 static inline void tcg_out_ubfm(TCGContext *s, TCGType ext, TCGReg rd,
1233                                 TCGReg rn, unsigned int a, unsigned int b)
1234 {
1235     tcg_out_insn(s, 3402, UBFM, ext, rd, rn, ext, a, b);
1236 }
1237
1238 static inline void tcg_out_sbfm(TCGContext *s, TCGType ext, TCGReg rd,
1239                                 TCGReg rn, unsigned int a, unsigned int b)
1240 {
1241     tcg_out_insn(s, 3402, SBFM, ext, rd, rn, ext, a, b);
1242 }
1243
1244 static inline void tcg_out_extr(TCGContext *s, TCGType ext, TCGReg rd,
1245                                 TCGReg rn, TCGReg rm, unsigned int a)
1246 {
1247     tcg_out_insn(s, 3403, EXTR, ext, rd, rn, rm, a);
1248 }
1249
1250 static inline void tcg_out_shl(TCGContext *s, TCGType ext,
1251                                TCGReg rd, TCGReg rn, unsigned int m)
1252 {
1253     int bits = ext ? 64 : 32;
1254     int max = bits - 1;
1255     tcg_out_ubfm(s, ext, rd, rn, bits - (m & max), max - (m & max));
1256 }
1257
1258 static inline void tcg_out_shr(TCGContext *s, TCGType ext,
1259                                TCGReg rd, TCGReg rn, unsigned int m)
1260 {
1261     int max = ext ? 63 : 31;
1262     tcg_out_ubfm(s, ext, rd, rn, m & max, max);
1263 }
1264
1265 static inline void tcg_out_sar(TCGContext *s, TCGType ext,
1266                                TCGReg rd, TCGReg rn, unsigned int m)
1267 {
1268     int max = ext ? 63 : 31;
1269     tcg_out_sbfm(s, ext, rd, rn, m & max, max);
1270 }
1271
1272 static inline void tcg_out_rotr(TCGContext *s, TCGType ext,
1273                                 TCGReg rd, TCGReg rn, unsigned int m)
1274 {
1275     int max = ext ? 63 : 31;
1276     tcg_out_extr(s, ext, rd, rn, rn, m & max);
1277 }
1278
1279 static inline void tcg_out_rotl(TCGContext *s, TCGType ext,
1280                                 TCGReg rd, TCGReg rn, unsigned int m)
1281 {
1282     int bits = ext ? 64 : 32;
1283     int max = bits - 1;
1284     tcg_out_extr(s, ext, rd, rn, rn, bits - (m & max));
1285 }
1286
1287 static inline void tcg_out_dep(TCGContext *s, TCGType ext, TCGReg rd,
1288                                TCGReg rn, unsigned lsb, unsigned width)
1289 {
1290     unsigned size = ext ? 64 : 32;
1291     unsigned a = (size - lsb) & (size - 1);
1292     unsigned b = width - 1;
1293     tcg_out_bfm(s, ext, rd, rn, a, b);
1294 }
1295
1296 static void tcg_out_cmp(TCGContext *s, TCGType ext, TCGReg a,
1297                         tcg_target_long b, bool const_b)
1298 {
1299     if (const_b) {
1300         /* Using CMP or CMN aliases.  */
1301         if (b >= 0) {
1302             tcg_out_insn(s, 3401, SUBSI, ext, TCG_REG_XZR, a, b);
1303         } else {
1304             tcg_out_insn(s, 3401, ADDSI, ext, TCG_REG_XZR, a, -b);
1305         }
1306     } else {
1307         /* Using CMP alias SUBS wzr, Wn, Wm */
1308         tcg_out_insn(s, 3502, SUBS, ext, TCG_REG_XZR, a, b);
1309     }
1310 }
1311
1312 static inline void tcg_out_goto(TCGContext *s, tcg_insn_unit *target)
1313 {
1314     ptrdiff_t offset = target - s->code_ptr;
1315     tcg_debug_assert(offset == sextract64(offset, 0, 26));
1316     tcg_out_insn(s, 3206, B, offset);
1317 }
1318
1319 static inline void tcg_out_goto_long(TCGContext *s, tcg_insn_unit *target)
1320 {
1321     ptrdiff_t offset = target - s->code_ptr;
1322     if (offset == sextract64(offset, 0, 26)) {
1323         tcg_out_insn(s, 3206, BL, offset);
1324     } else {
1325         tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_TMP, (intptr_t)target);
1326         tcg_out_insn(s, 3207, BR, TCG_REG_TMP);
1327     }
1328 }
1329
1330 static inline void tcg_out_callr(TCGContext *s, TCGReg reg)
1331 {
1332     tcg_out_insn(s, 3207, BLR, reg);
1333 }
1334
1335 static inline void tcg_out_call(TCGContext *s, tcg_insn_unit *target)
1336 {
1337     ptrdiff_t offset = target - s->code_ptr;
1338     if (offset == sextract64(offset, 0, 26)) {
1339         tcg_out_insn(s, 3206, BL, offset);
1340     } else {
1341         tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_TMP, (intptr_t)target);
1342         tcg_out_callr(s, TCG_REG_TMP);
1343     }
1344 }
1345
1346 void tb_target_set_jmp_target(uintptr_t tc_ptr, uintptr_t jmp_addr,
1347                               uintptr_t addr)
1348 {
1349     tcg_insn_unit i1, i2;
1350     TCGType rt = TCG_TYPE_I64;
1351     TCGReg  rd = TCG_REG_TMP;
1352     uint64_t pair;
1353
1354     ptrdiff_t offset = addr - jmp_addr;
1355
1356     if (offset == sextract64(offset, 0, 26)) {
1357         i1 = I3206_B | ((offset >> 2) & 0x3ffffff);
1358         i2 = NOP;
1359     } else {
1360         offset = (addr >> 12) - (jmp_addr >> 12);
1361
1362         /* patch ADRP */
1363         i1 = I3406_ADRP | (offset & 3) << 29 | (offset & 0x1ffffc) << (5 - 2) | rd;
1364         /* patch ADDI */
1365         i2 = I3401_ADDI | rt << 31 | (addr & 0xfff) << 10 | rd << 5 | rd;
1366     }
1367     pair = (uint64_t)i2 << 32 | i1;
1368     atomic_set((uint64_t *)jmp_addr, pair);
1369     flush_icache_range(jmp_addr, jmp_addr + 8);
1370 }
1371
1372 static inline void tcg_out_goto_label(TCGContext *s, TCGLabel *l)
1373 {
1374     if (!l->has_value) {
1375         tcg_out_reloc(s, s->code_ptr, R_AARCH64_JUMP26, l, 0);
1376         tcg_out_insn(s, 3206, B, 0);
1377     } else {
1378         tcg_out_goto(s, l->u.value_ptr);
1379     }
1380 }
1381
1382 static void tcg_out_brcond(TCGContext *s, TCGType ext, TCGCond c, TCGArg a,
1383                            TCGArg b, bool b_const, TCGLabel *l)
1384 {
1385     intptr_t offset;
1386     bool need_cmp;
1387
1388     if (b_const && b == 0 && (c == TCG_COND_EQ || c == TCG_COND_NE)) {
1389         need_cmp = false;
1390     } else {
1391         need_cmp = true;
1392         tcg_out_cmp(s, ext, a, b, b_const);
1393     }
1394
1395     if (!l->has_value) {
1396         tcg_out_reloc(s, s->code_ptr, R_AARCH64_CONDBR19, l, 0);
1397         offset = tcg_in32(s) >> 5;
1398     } else {
1399         offset = l->u.value_ptr - s->code_ptr;
1400         tcg_debug_assert(offset == sextract64(offset, 0, 19));
1401     }
1402
1403     if (need_cmp) {
1404         tcg_out_insn(s, 3202, B_C, c, offset);
1405     } else if (c == TCG_COND_EQ) {
1406         tcg_out_insn(s, 3201, CBZ, ext, a, offset);
1407     } else {
1408         tcg_out_insn(s, 3201, CBNZ, ext, a, offset);
1409     }
1410 }
1411
1412 static inline void tcg_out_rev64(TCGContext *s, TCGReg rd, TCGReg rn)
1413 {
1414     tcg_out_insn(s, 3507, REV64, TCG_TYPE_I64, rd, rn);
1415 }
1416
1417 static inline void tcg_out_rev32(TCGContext *s, TCGReg rd, TCGReg rn)
1418 {
1419     tcg_out_insn(s, 3507, REV32, TCG_TYPE_I32, rd, rn);
1420 }
1421
1422 static inline void tcg_out_rev16(TCGContext *s, TCGReg rd, TCGReg rn)
1423 {
1424     tcg_out_insn(s, 3507, REV16, TCG_TYPE_I32, rd, rn);
1425 }
1426
1427 static inline void tcg_out_sxt(TCGContext *s, TCGType ext, MemOp s_bits,
1428                                TCGReg rd, TCGReg rn)
1429 {
1430     /* Using ALIASes SXTB, SXTH, SXTW, of SBFM Xd, Xn, #0, #7|15|31 */
1431     int bits = (8 << s_bits) - 1;
1432     tcg_out_sbfm(s, ext, rd, rn, 0, bits);
1433 }
1434
1435 static inline void tcg_out_uxt(TCGContext *s, MemOp s_bits,
1436                                TCGReg rd, TCGReg rn)
1437 {
1438     /* Using ALIASes UXTB, UXTH of UBFM Wd, Wn, #0, #7|15 */
1439     int bits = (8 << s_bits) - 1;
1440     tcg_out_ubfm(s, 0, rd, rn, 0, bits);
1441 }
1442
1443 static void tcg_out_addsubi(TCGContext *s, int ext, TCGReg rd,
1444                             TCGReg rn, int64_t aimm)
1445 {
1446     if (aimm >= 0) {
1447         tcg_out_insn(s, 3401, ADDI, ext, rd, rn, aimm);
1448     } else {
1449         tcg_out_insn(s, 3401, SUBI, ext, rd, rn, -aimm);
1450     }
1451 }
1452
1453 static inline void tcg_out_addsub2(TCGContext *s, TCGType ext, TCGReg rl,
1454                                    TCGReg rh, TCGReg al, TCGReg ah,
1455                                    tcg_target_long bl, tcg_target_long bh,
1456                                    bool const_bl, bool const_bh, bool sub)
1457 {
1458     TCGReg orig_rl = rl;
1459     AArch64Insn insn;
1460
1461     if (rl == ah || (!const_bh && rl == bh)) {
1462         rl = TCG_REG_TMP;
1463     }
1464
1465     if (const_bl) {
1466         insn = I3401_ADDSI;
1467         if ((bl < 0) ^ sub) {
1468             insn = I3401_SUBSI;
1469             bl = -bl;
1470         }
1471         if (unlikely(al == TCG_REG_XZR)) {
1472             /* ??? We want to allow al to be zero for the benefit of
1473                negation via subtraction.  However, that leaves open the
1474                possibility of adding 0+const in the low part, and the
1475                immediate add instructions encode XSP not XZR.  Don't try
1476                anything more elaborate here than loading another zero.  */
1477             al = TCG_REG_TMP;
1478             tcg_out_movi(s, ext, al, 0);
1479         }
1480         tcg_out_insn_3401(s, insn, ext, rl, al, bl);
1481     } else {
1482         tcg_out_insn_3502(s, sub ? I3502_SUBS : I3502_ADDS, ext, rl, al, bl);
1483     }
1484
1485     insn = I3503_ADC;
1486     if (const_bh) {
1487         /* Note that the only two constants we support are 0 and -1, and
1488            that SBC = rn + ~rm + c, so adc -1 is sbc 0, and vice-versa.  */
1489         if ((bh != 0) ^ sub) {
1490             insn = I3503_SBC;
1491         }
1492         bh = TCG_REG_XZR;
1493     } else if (sub) {
1494         insn = I3503_SBC;
1495     }
1496     tcg_out_insn_3503(s, insn, ext, rh, ah, bh);
1497
1498     tcg_out_mov(s, ext, orig_rl, rl);
1499 }
1500
1501 static inline void tcg_out_mb(TCGContext *s, TCGArg a0)
1502 {
1503     static const uint32_t sync[] = {
1504         [0 ... TCG_MO_ALL]            = DMB_ISH | DMB_LD | DMB_ST,
1505         [TCG_MO_ST_ST]                = DMB_ISH | DMB_ST,
1506         [TCG_MO_LD_LD]                = DMB_ISH | DMB_LD,
1507         [TCG_MO_LD_ST]                = DMB_ISH | DMB_LD,
1508         [TCG_MO_LD_ST | TCG_MO_LD_LD] = DMB_ISH | DMB_LD,
1509     };
1510     tcg_out32(s, sync[a0 & TCG_MO_ALL]);
1511 }
1512
1513 static void tcg_out_cltz(TCGContext *s, TCGType ext, TCGReg d,
1514                          TCGReg a0, TCGArg b, bool const_b, bool is_ctz)
1515 {
1516     TCGReg a1 = a0;
1517     if (is_ctz) {
1518         a1 = TCG_REG_TMP;
1519         tcg_out_insn(s, 3507, RBIT, ext, a1, a0);
1520     }
1521     if (const_b && b == (ext ? 64 : 32)) {
1522         tcg_out_insn(s, 3507, CLZ, ext, d, a1);
1523     } else {
1524         AArch64Insn sel = I3506_CSEL;
1525
1526         tcg_out_cmp(s, ext, a0, 0, 1);
1527         tcg_out_insn(s, 3507, CLZ, ext, TCG_REG_TMP, a1);
1528
1529         if (const_b) {
1530             if (b == -1) {
1531                 b = TCG_REG_XZR;
1532                 sel = I3506_CSINV;
1533             } else if (b == 0) {
1534                 b = TCG_REG_XZR;
1535             } else {
1536                 tcg_out_movi(s, ext, d, b);
1537                 b = d;
1538             }
1539         }
1540         tcg_out_insn_3506(s, sel, ext, d, TCG_REG_TMP, b, TCG_COND_NE);
1541     }
1542 }
1543
1544 #ifdef CONFIG_SOFTMMU
1545 #include "../tcg-ldst.c.inc"
1546
1547 /* helper signature: helper_ret_ld_mmu(CPUState *env, target_ulong addr,
1548  *                                     TCGMemOpIdx oi, uintptr_t ra)
1549  */
1550 static void * const qemu_ld_helpers[16] = {
1551     [MO_UB]   = helper_ret_ldub_mmu,
1552     [MO_LEUW] = helper_le_lduw_mmu,
1553     [MO_LEUL] = helper_le_ldul_mmu,
1554     [MO_LEQ]  = helper_le_ldq_mmu,
1555     [MO_BEUW] = helper_be_lduw_mmu,
1556     [MO_BEUL] = helper_be_ldul_mmu,
1557     [MO_BEQ]  = helper_be_ldq_mmu,
1558 };
1559
1560 /* helper signature: helper_ret_st_mmu(CPUState *env, target_ulong addr,
1561  *                                     uintxx_t val, TCGMemOpIdx oi,
1562  *                                     uintptr_t ra)
1563  */
1564 static void * const qemu_st_helpers[16] = {
1565     [MO_UB]   = helper_ret_stb_mmu,
1566     [MO_LEUW] = helper_le_stw_mmu,
1567     [MO_LEUL] = helper_le_stl_mmu,
1568     [MO_LEQ]  = helper_le_stq_mmu,
1569     [MO_BEUW] = helper_be_stw_mmu,
1570     [MO_BEUL] = helper_be_stl_mmu,
1571     [MO_BEQ]  = helper_be_stq_mmu,
1572 };
1573
1574 static inline void tcg_out_adr(TCGContext *s, TCGReg rd, void *target)
1575 {
1576     ptrdiff_t offset = tcg_pcrel_diff(s, target);
1577     tcg_debug_assert(offset == sextract64(offset, 0, 21));
1578     tcg_out_insn(s, 3406, ADR, rd, offset);
1579 }
1580
1581 static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1582 {
1583     TCGMemOpIdx oi = lb->oi;
1584     MemOp opc = get_memop(oi);
1585     MemOp size = opc & MO_SIZE;
1586
1587     if (!reloc_pc19(lb->label_ptr[0], s->code_ptr)) {
1588         return false;
1589     }
1590
1591     tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_X0, TCG_AREG0);
1592     tcg_out_mov(s, TARGET_LONG_BITS == 64, TCG_REG_X1, lb->addrlo_reg);
1593     tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_X2, oi);
1594     tcg_out_adr(s, TCG_REG_X3, lb->raddr);
1595     tcg_out_call(s, qemu_ld_helpers[opc & (MO_BSWAP | MO_SIZE)]);
1596     if (opc & MO_SIGN) {
1597         tcg_out_sxt(s, lb->type, size, lb->datalo_reg, TCG_REG_X0);
1598     } else {
1599         tcg_out_mov(s, size == MO_64, lb->datalo_reg, TCG_REG_X0);
1600     }
1601
1602     tcg_out_goto(s, lb->raddr);
1603     return true;
1604 }
1605
1606 static bool tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1607 {
1608     TCGMemOpIdx oi = lb->oi;
1609     MemOp opc = get_memop(oi);
1610     MemOp size = opc & MO_SIZE;
1611
1612     if (!reloc_pc19(lb->label_ptr[0], s->code_ptr)) {
1613         return false;
1614     }
1615
1616     tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_X0, TCG_AREG0);
1617     tcg_out_mov(s, TARGET_LONG_BITS == 64, TCG_REG_X1, lb->addrlo_reg);
1618     tcg_out_mov(s, size == MO_64, TCG_REG_X2, lb->datalo_reg);
1619     tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_X3, oi);
1620     tcg_out_adr(s, TCG_REG_X4, lb->raddr);
1621     tcg_out_call(s, qemu_st_helpers[opc & (MO_BSWAP | MO_SIZE)]);
1622     tcg_out_goto(s, lb->raddr);
1623     return true;
1624 }
1625
1626 static void add_qemu_ldst_label(TCGContext *s, bool is_ld, TCGMemOpIdx oi,
1627                                 TCGType ext, TCGReg data_reg, TCGReg addr_reg,
1628                                 tcg_insn_unit *raddr, tcg_insn_unit *label_ptr)
1629 {
1630     TCGLabelQemuLdst *label = new_ldst_label(s);
1631
1632     label->is_ld = is_ld;
1633     label->oi = oi;
1634     label->type = ext;
1635     label->datalo_reg = data_reg;
1636     label->addrlo_reg = addr_reg;
1637     label->raddr = raddr;
1638     label->label_ptr[0] = label_ptr;
1639 }
1640
1641 /* We expect to use a 7-bit scaled negative offset from ENV.  */
1642 QEMU_BUILD_BUG_ON(TLB_MASK_TABLE_OFS(0) > 0);
1643 QEMU_BUILD_BUG_ON(TLB_MASK_TABLE_OFS(0) < -512);
1644
1645 /* These offsets are built into the LDP below.  */
1646 QEMU_BUILD_BUG_ON(offsetof(CPUTLBDescFast, mask) != 0);
1647 QEMU_BUILD_BUG_ON(offsetof(CPUTLBDescFast, table) != 8);
1648
1649 /* Load and compare a TLB entry, emitting the conditional jump to the
1650    slow path for the failure case, which will be patched later when finalizing
1651    the slow path. Generated code returns the host addend in X1,
1652    clobbers X0,X2,X3,TMP. */
1653 static void tcg_out_tlb_read(TCGContext *s, TCGReg addr_reg, MemOp opc,
1654                              tcg_insn_unit **label_ptr, int mem_index,
1655                              bool is_read)
1656 {
1657     unsigned a_bits = get_alignment_bits(opc);
1658     unsigned s_bits = opc & MO_SIZE;
1659     unsigned a_mask = (1u << a_bits) - 1;
1660     unsigned s_mask = (1u << s_bits) - 1;
1661     TCGReg x3;
1662     TCGType mask_type;
1663     uint64_t compare_mask;
1664
1665     mask_type = (TARGET_PAGE_BITS + CPU_TLB_DYN_MAX_BITS > 32
1666                  ? TCG_TYPE_I64 : TCG_TYPE_I32);
1667
1668     /* Load env_tlb(env)->f[mmu_idx].{mask,table} into {x0,x1}.  */
1669     tcg_out_insn(s, 3314, LDP, TCG_REG_X0, TCG_REG_X1, TCG_AREG0,
1670                  TLB_MASK_TABLE_OFS(mem_index), 1, 0);
1671
1672     /* Extract the TLB index from the address into X0.  */
1673     tcg_out_insn(s, 3502S, AND_LSR, mask_type == TCG_TYPE_I64,
1674                  TCG_REG_X0, TCG_REG_X0, addr_reg,
1675                  TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS);
1676
1677     /* Add the tlb_table pointer, creating the CPUTLBEntry address into X1.  */
1678     tcg_out_insn(s, 3502, ADD, 1, TCG_REG_X1, TCG_REG_X1, TCG_REG_X0);
1679
1680     /* Load the tlb comparator into X0, and the fast path addend into X1.  */
1681     tcg_out_ld(s, TCG_TYPE_TL, TCG_REG_X0, TCG_REG_X1, is_read
1682                ? offsetof(CPUTLBEntry, addr_read)
1683                : offsetof(CPUTLBEntry, addr_write));
1684     tcg_out_ld(s, TCG_TYPE_PTR, TCG_REG_X1, TCG_REG_X1,
1685                offsetof(CPUTLBEntry, addend));
1686
1687     /* For aligned accesses, we check the first byte and include the alignment
1688        bits within the address.  For unaligned access, we check that we don't
1689        cross pages using the address of the last byte of the access.  */
1690     if (a_bits >= s_bits) {
1691         x3 = addr_reg;
1692     } else {
1693         tcg_out_insn(s, 3401, ADDI, TARGET_LONG_BITS == 64,
1694                      TCG_REG_X3, addr_reg, s_mask - a_mask);
1695         x3 = TCG_REG_X3;
1696     }
1697     compare_mask = (uint64_t)TARGET_PAGE_MASK | a_mask;
1698
1699     /* Store the page mask part of the address into X3.  */
1700     tcg_out_logicali(s, I3404_ANDI, TARGET_LONG_BITS == 64,
1701                      TCG_REG_X3, x3, compare_mask);
1702
1703     /* Perform the address comparison. */
1704     tcg_out_cmp(s, TARGET_LONG_BITS == 64, TCG_REG_X0, TCG_REG_X3, 0);
1705
1706     /* If not equal, we jump to the slow path. */
1707     *label_ptr = s->code_ptr;
1708     tcg_out_insn(s, 3202, B_C, TCG_COND_NE, 0);
1709 }
1710
1711 #endif /* CONFIG_SOFTMMU */
1712
1713 static void tcg_out_qemu_ld_direct(TCGContext *s, MemOp memop, TCGType ext,
1714                                    TCGReg data_r, TCGReg addr_r,
1715                                    TCGType otype, TCGReg off_r)
1716 {
1717     const MemOp bswap = memop & MO_BSWAP;
1718
1719     switch (memop & MO_SSIZE) {
1720     case MO_UB:
1721         tcg_out_ldst_r(s, I3312_LDRB, data_r, addr_r, otype, off_r);
1722         break;
1723     case MO_SB:
1724         tcg_out_ldst_r(s, ext ? I3312_LDRSBX : I3312_LDRSBW,
1725                        data_r, addr_r, otype, off_r);
1726         break;
1727     case MO_UW:
1728         tcg_out_ldst_r(s, I3312_LDRH, data_r, addr_r, otype, off_r);
1729         if (bswap) {
1730             tcg_out_rev16(s, data_r, data_r);
1731         }
1732         break;
1733     case MO_SW:
1734         if (bswap) {
1735             tcg_out_ldst_r(s, I3312_LDRH, data_r, addr_r, otype, off_r);
1736             tcg_out_rev16(s, data_r, data_r);
1737             tcg_out_sxt(s, ext, MO_16, data_r, data_r);
1738         } else {
1739             tcg_out_ldst_r(s, (ext ? I3312_LDRSHX : I3312_LDRSHW),
1740                            data_r, addr_r, otype, off_r);
1741         }
1742         break;
1743     case MO_UL:
1744         tcg_out_ldst_r(s, I3312_LDRW, data_r, addr_r, otype, off_r);
1745         if (bswap) {
1746             tcg_out_rev32(s, data_r, data_r);
1747         }
1748         break;
1749     case MO_SL:
1750         if (bswap) {
1751             tcg_out_ldst_r(s, I3312_LDRW, data_r, addr_r, otype, off_r);
1752             tcg_out_rev32(s, data_r, data_r);
1753             tcg_out_sxt(s, TCG_TYPE_I64, MO_32, data_r, data_r);
1754         } else {
1755             tcg_out_ldst_r(s, I3312_LDRSWX, data_r, addr_r, otype, off_r);
1756         }
1757         break;
1758     case MO_Q:
1759         tcg_out_ldst_r(s, I3312_LDRX, data_r, addr_r, otype, off_r);
1760         if (bswap) {
1761             tcg_out_rev64(s, data_r, data_r);
1762         }
1763         break;
1764     default:
1765         tcg_abort();
1766     }
1767 }
1768
1769 static void tcg_out_qemu_st_direct(TCGContext *s, MemOp memop,
1770                                    TCGReg data_r, TCGReg addr_r,
1771                                    TCGType otype, TCGReg off_r)
1772 {
1773     const MemOp bswap = memop & MO_BSWAP;
1774
1775     switch (memop & MO_SIZE) {
1776     case MO_8:
1777         tcg_out_ldst_r(s, I3312_STRB, data_r, addr_r, otype, off_r);
1778         break;
1779     case MO_16:
1780         if (bswap && data_r != TCG_REG_XZR) {
1781             tcg_out_rev16(s, TCG_REG_TMP, data_r);
1782             data_r = TCG_REG_TMP;
1783         }
1784         tcg_out_ldst_r(s, I3312_STRH, data_r, addr_r, otype, off_r);
1785         break;
1786     case MO_32:
1787         if (bswap && data_r != TCG_REG_XZR) {
1788             tcg_out_rev32(s, TCG_REG_TMP, data_r);
1789             data_r = TCG_REG_TMP;
1790         }
1791         tcg_out_ldst_r(s, I3312_STRW, data_r, addr_r, otype, off_r);
1792         break;
1793     case MO_64:
1794         if (bswap && data_r != TCG_REG_XZR) {
1795             tcg_out_rev64(s, TCG_REG_TMP, data_r);
1796             data_r = TCG_REG_TMP;
1797         }
1798         tcg_out_ldst_r(s, I3312_STRX, data_r, addr_r, otype, off_r);
1799         break;
1800     default:
1801         tcg_abort();
1802     }
1803 }
1804
1805 static void tcg_out_qemu_ld(TCGContext *s, TCGReg data_reg, TCGReg addr_reg,
1806                             TCGMemOpIdx oi, TCGType ext)
1807 {
1808     MemOp memop = get_memop(oi);
1809     const TCGType otype = TARGET_LONG_BITS == 64 ? TCG_TYPE_I64 : TCG_TYPE_I32;
1810 #ifdef CONFIG_SOFTMMU
1811     unsigned mem_index = get_mmuidx(oi);
1812     tcg_insn_unit *label_ptr;
1813
1814     tcg_out_tlb_read(s, addr_reg, memop, &label_ptr, mem_index, 1);
1815     tcg_out_qemu_ld_direct(s, memop, ext, data_reg,
1816                            TCG_REG_X1, otype, addr_reg);
1817     add_qemu_ldst_label(s, true, oi, ext, data_reg, addr_reg,
1818                         s->code_ptr, label_ptr);
1819 #else /* !CONFIG_SOFTMMU */
1820     if (USE_GUEST_BASE) {
1821         tcg_out_qemu_ld_direct(s, memop, ext, data_reg,
1822                                TCG_REG_GUEST_BASE, otype, addr_reg);
1823     } else {
1824         tcg_out_qemu_ld_direct(s, memop, ext, data_reg,
1825                                addr_reg, TCG_TYPE_I64, TCG_REG_XZR);
1826     }
1827 #endif /* CONFIG_SOFTMMU */
1828 }
1829
1830 static void tcg_out_qemu_st(TCGContext *s, TCGReg data_reg, TCGReg addr_reg,
1831                             TCGMemOpIdx oi)
1832 {
1833     MemOp memop = get_memop(oi);
1834     const TCGType otype = TARGET_LONG_BITS == 64 ? TCG_TYPE_I64 : TCG_TYPE_I32;
1835 #ifdef CONFIG_SOFTMMU
1836     unsigned mem_index = get_mmuidx(oi);
1837     tcg_insn_unit *label_ptr;
1838
1839     tcg_out_tlb_read(s, addr_reg, memop, &label_ptr, mem_index, 0);
1840     tcg_out_qemu_st_direct(s, memop, data_reg,
1841                            TCG_REG_X1, otype, addr_reg);
1842     add_qemu_ldst_label(s, false, oi, (memop & MO_SIZE)== MO_64,
1843                         data_reg, addr_reg, s->code_ptr, label_ptr);
1844 #else /* !CONFIG_SOFTMMU */
1845     if (USE_GUEST_BASE) {
1846         tcg_out_qemu_st_direct(s, memop, data_reg,
1847                                TCG_REG_GUEST_BASE, otype, addr_reg);
1848     } else {
1849         tcg_out_qemu_st_direct(s, memop, data_reg,
1850                                addr_reg, TCG_TYPE_I64, TCG_REG_XZR);
1851     }
1852 #endif /* CONFIG_SOFTMMU */
1853 }
1854
1855 static tcg_insn_unit *tb_ret_addr;
1856
1857 static void tcg_out_op(TCGContext *s, TCGOpcode opc,
1858                        const TCGArg args[TCG_MAX_OP_ARGS],
1859                        const int const_args[TCG_MAX_OP_ARGS])
1860 {
1861     /* 99% of the time, we can signal the use of extension registers
1862        by looking to see if the opcode handles 64-bit data.  */
1863     TCGType ext = (tcg_op_defs[opc].flags & TCG_OPF_64BIT) != 0;
1864
1865     /* Hoist the loads of the most common arguments.  */
1866     TCGArg a0 = args[0];
1867     TCGArg a1 = args[1];
1868     TCGArg a2 = args[2];
1869     int c2 = const_args[2];
1870
1871     /* Some operands are defined with "rZ" constraint, a register or
1872        the zero register.  These need not actually test args[I] == 0.  */
1873 #define REG0(I)  (const_args[I] ? TCG_REG_XZR : (TCGReg)args[I])
1874
1875     switch (opc) {
1876     case INDEX_op_exit_tb:
1877         /* Reuse the zeroing that exists for goto_ptr.  */
1878         if (a0 == 0) {
1879             tcg_out_goto_long(s, s->code_gen_epilogue);
1880         } else {
1881             tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_X0, a0);
1882             tcg_out_goto_long(s, tb_ret_addr);
1883         }
1884         break;
1885
1886     case INDEX_op_goto_tb:
1887         if (s->tb_jmp_insn_offset != NULL) {
1888             /* TCG_TARGET_HAS_direct_jump */
1889             /* Ensure that ADRP+ADD are 8-byte aligned so that an atomic
1890                write can be used to patch the target address. */
1891             if ((uintptr_t)s->code_ptr & 7) {
1892                 tcg_out32(s, NOP);
1893             }
1894             s->tb_jmp_insn_offset[a0] = tcg_current_code_size(s);
1895             /* actual branch destination will be patched by
1896                tb_target_set_jmp_target later. */
1897             tcg_out_insn(s, 3406, ADRP, TCG_REG_TMP, 0);
1898             tcg_out_insn(s, 3401, ADDI, TCG_TYPE_I64, TCG_REG_TMP, TCG_REG_TMP, 0);
1899         } else {
1900             /* !TCG_TARGET_HAS_direct_jump */
1901             tcg_debug_assert(s->tb_jmp_target_addr != NULL);
1902             intptr_t offset = tcg_pcrel_diff(s, (s->tb_jmp_target_addr + a0)) >> 2;
1903             tcg_out_insn(s, 3305, LDR, offset, TCG_REG_TMP);
1904         }
1905         tcg_out_insn(s, 3207, BR, TCG_REG_TMP);
1906         set_jmp_reset_offset(s, a0);
1907         break;
1908
1909     case INDEX_op_goto_ptr:
1910         tcg_out_insn(s, 3207, BR, a0);
1911         break;
1912
1913     case INDEX_op_br:
1914         tcg_out_goto_label(s, arg_label(a0));
1915         break;
1916
1917     case INDEX_op_ld8u_i32:
1918     case INDEX_op_ld8u_i64:
1919         tcg_out_ldst(s, I3312_LDRB, a0, a1, a2, 0);
1920         break;
1921     case INDEX_op_ld8s_i32:
1922         tcg_out_ldst(s, I3312_LDRSBW, a0, a1, a2, 0);
1923         break;
1924     case INDEX_op_ld8s_i64:
1925         tcg_out_ldst(s, I3312_LDRSBX, a0, a1, a2, 0);
1926         break;
1927     case INDEX_op_ld16u_i32:
1928     case INDEX_op_ld16u_i64:
1929         tcg_out_ldst(s, I3312_LDRH, a0, a1, a2, 1);
1930         break;
1931     case INDEX_op_ld16s_i32:
1932         tcg_out_ldst(s, I3312_LDRSHW, a0, a1, a2, 1);
1933         break;
1934     case INDEX_op_ld16s_i64:
1935         tcg_out_ldst(s, I3312_LDRSHX, a0, a1, a2, 1);
1936         break;
1937     case INDEX_op_ld_i32:
1938     case INDEX_op_ld32u_i64:
1939         tcg_out_ldst(s, I3312_LDRW, a0, a1, a2, 2);
1940         break;
1941     case INDEX_op_ld32s_i64:
1942         tcg_out_ldst(s, I3312_LDRSWX, a0, a1, a2, 2);
1943         break;
1944     case INDEX_op_ld_i64:
1945         tcg_out_ldst(s, I3312_LDRX, a0, a1, a2, 3);
1946         break;
1947
1948     case INDEX_op_st8_i32:
1949     case INDEX_op_st8_i64:
1950         tcg_out_ldst(s, I3312_STRB, REG0(0), a1, a2, 0);
1951         break;
1952     case INDEX_op_st16_i32:
1953     case INDEX_op_st16_i64:
1954         tcg_out_ldst(s, I3312_STRH, REG0(0), a1, a2, 1);
1955         break;
1956     case INDEX_op_st_i32:
1957     case INDEX_op_st32_i64:
1958         tcg_out_ldst(s, I3312_STRW, REG0(0), a1, a2, 2);
1959         break;
1960     case INDEX_op_st_i64:
1961         tcg_out_ldst(s, I3312_STRX, REG0(0), a1, a2, 3);
1962         break;
1963
1964     case INDEX_op_add_i32:
1965         a2 = (int32_t)a2;
1966         /* FALLTHRU */
1967     case INDEX_op_add_i64:
1968         if (c2) {
1969             tcg_out_addsubi(s, ext, a0, a1, a2);
1970         } else {
1971             tcg_out_insn(s, 3502, ADD, ext, a0, a1, a2);
1972         }
1973         break;
1974
1975     case INDEX_op_sub_i32:
1976         a2 = (int32_t)a2;
1977         /* FALLTHRU */
1978     case INDEX_op_sub_i64:
1979         if (c2) {
1980             tcg_out_addsubi(s, ext, a0, a1, -a2);
1981         } else {
1982             tcg_out_insn(s, 3502, SUB, ext, a0, a1, a2);
1983         }
1984         break;
1985
1986     case INDEX_op_neg_i64:
1987     case INDEX_op_neg_i32:
1988         tcg_out_insn(s, 3502, SUB, ext, a0, TCG_REG_XZR, a1);
1989         break;
1990
1991     case INDEX_op_and_i32:
1992         a2 = (int32_t)a2;
1993         /* FALLTHRU */
1994     case INDEX_op_and_i64:
1995         if (c2) {
1996             tcg_out_logicali(s, I3404_ANDI, ext, a0, a1, a2);
1997         } else {
1998             tcg_out_insn(s, 3510, AND, ext, a0, a1, a2);
1999         }
2000         break;
2001
2002     case INDEX_op_andc_i32:
2003         a2 = (int32_t)a2;
2004         /* FALLTHRU */
2005     case INDEX_op_andc_i64:
2006         if (c2) {
2007             tcg_out_logicali(s, I3404_ANDI, ext, a0, a1, ~a2);
2008         } else {
2009             tcg_out_insn(s, 3510, BIC, ext, a0, a1, a2);
2010         }
2011         break;
2012
2013     case INDEX_op_or_i32:
2014         a2 = (int32_t)a2;
2015         /* FALLTHRU */
2016     case INDEX_op_or_i64:
2017         if (c2) {
2018             tcg_out_logicali(s, I3404_ORRI, ext, a0, a1, a2);
2019         } else {
2020             tcg_out_insn(s, 3510, ORR, ext, a0, a1, a2);
2021         }
2022         break;
2023
2024     case INDEX_op_orc_i32:
2025         a2 = (int32_t)a2;
2026         /* FALLTHRU */
2027     case INDEX_op_orc_i64:
2028         if (c2) {
2029             tcg_out_logicali(s, I3404_ORRI, ext, a0, a1, ~a2);
2030         } else {
2031             tcg_out_insn(s, 3510, ORN, ext, a0, a1, a2);
2032         }
2033         break;
2034
2035     case INDEX_op_xor_i32:
2036         a2 = (int32_t)a2;
2037         /* FALLTHRU */
2038     case INDEX_op_xor_i64:
2039         if (c2) {
2040             tcg_out_logicali(s, I3404_EORI, ext, a0, a1, a2);
2041         } else {
2042             tcg_out_insn(s, 3510, EOR, ext, a0, a1, a2);
2043         }
2044         break;
2045
2046     case INDEX_op_eqv_i32:
2047         a2 = (int32_t)a2;
2048         /* FALLTHRU */
2049     case INDEX_op_eqv_i64:
2050         if (c2) {
2051             tcg_out_logicali(s, I3404_EORI, ext, a0, a1, ~a2);
2052         } else {
2053             tcg_out_insn(s, 3510, EON, ext, a0, a1, a2);
2054         }
2055         break;
2056
2057     case INDEX_op_not_i64:
2058     case INDEX_op_not_i32:
2059         tcg_out_insn(s, 3510, ORN, ext, a0, TCG_REG_XZR, a1);
2060         break;
2061
2062     case INDEX_op_mul_i64:
2063     case INDEX_op_mul_i32:
2064         tcg_out_insn(s, 3509, MADD, ext, a0, a1, a2, TCG_REG_XZR);
2065         break;
2066
2067     case INDEX_op_div_i64:
2068     case INDEX_op_div_i32:
2069         tcg_out_insn(s, 3508, SDIV, ext, a0, a1, a2);
2070         break;
2071     case INDEX_op_divu_i64:
2072     case INDEX_op_divu_i32:
2073         tcg_out_insn(s, 3508, UDIV, ext, a0, a1, a2);
2074         break;
2075
2076     case INDEX_op_rem_i64:
2077     case INDEX_op_rem_i32:
2078         tcg_out_insn(s, 3508, SDIV, ext, TCG_REG_TMP, a1, a2);
2079         tcg_out_insn(s, 3509, MSUB, ext, a0, TCG_REG_TMP, a2, a1);
2080         break;
2081     case INDEX_op_remu_i64:
2082     case INDEX_op_remu_i32:
2083         tcg_out_insn(s, 3508, UDIV, ext, TCG_REG_TMP, a1, a2);
2084         tcg_out_insn(s, 3509, MSUB, ext, a0, TCG_REG_TMP, a2, a1);
2085         break;
2086
2087     case INDEX_op_shl_i64:
2088     case INDEX_op_shl_i32:
2089         if (c2) {
2090             tcg_out_shl(s, ext, a0, a1, a2);
2091         } else {
2092             tcg_out_insn(s, 3508, LSLV, ext, a0, a1, a2);
2093         }
2094         break;
2095
2096     case INDEX_op_shr_i64:
2097     case INDEX_op_shr_i32:
2098         if (c2) {
2099             tcg_out_shr(s, ext, a0, a1, a2);
2100         } else {
2101             tcg_out_insn(s, 3508, LSRV, ext, a0, a1, a2);
2102         }
2103         break;
2104
2105     case INDEX_op_sar_i64:
2106     case INDEX_op_sar_i32:
2107         if (c2) {
2108             tcg_out_sar(s, ext, a0, a1, a2);
2109         } else {
2110             tcg_out_insn(s, 3508, ASRV, ext, a0, a1, a2);
2111         }
2112         break;
2113
2114     case INDEX_op_rotr_i64:
2115     case INDEX_op_rotr_i32:
2116         if (c2) {
2117             tcg_out_rotr(s, ext, a0, a1, a2);
2118         } else {
2119             tcg_out_insn(s, 3508, RORV, ext, a0, a1, a2);
2120         }
2121         break;
2122
2123     case INDEX_op_rotl_i64:
2124     case INDEX_op_rotl_i32:
2125         if (c2) {
2126             tcg_out_rotl(s, ext, a0, a1, a2);
2127         } else {
2128             tcg_out_insn(s, 3502, SUB, 0, TCG_REG_TMP, TCG_REG_XZR, a2);
2129             tcg_out_insn(s, 3508, RORV, ext, a0, a1, TCG_REG_TMP);
2130         }
2131         break;
2132
2133     case INDEX_op_clz_i64:
2134     case INDEX_op_clz_i32:
2135         tcg_out_cltz(s, ext, a0, a1, a2, c2, false);
2136         break;
2137     case INDEX_op_ctz_i64:
2138     case INDEX_op_ctz_i32:
2139         tcg_out_cltz(s, ext, a0, a1, a2, c2, true);
2140         break;
2141
2142     case INDEX_op_brcond_i32:
2143         a1 = (int32_t)a1;
2144         /* FALLTHRU */
2145     case INDEX_op_brcond_i64:
2146         tcg_out_brcond(s, ext, a2, a0, a1, const_args[1], arg_label(args[3]));
2147         break;
2148
2149     case INDEX_op_setcond_i32:
2150         a2 = (int32_t)a2;
2151         /* FALLTHRU */
2152     case INDEX_op_setcond_i64:
2153         tcg_out_cmp(s, ext, a1, a2, c2);
2154         /* Use CSET alias of CSINC Wd, WZR, WZR, invert(cond).  */
2155         tcg_out_insn(s, 3506, CSINC, TCG_TYPE_I32, a0, TCG_REG_XZR,
2156                      TCG_REG_XZR, tcg_invert_cond(args[3]));
2157         break;
2158
2159     case INDEX_op_movcond_i32:
2160         a2 = (int32_t)a2;
2161         /* FALLTHRU */
2162     case INDEX_op_movcond_i64:
2163         tcg_out_cmp(s, ext, a1, a2, c2);
2164         tcg_out_insn(s, 3506, CSEL, ext, a0, REG0(3), REG0(4), args[5]);
2165         break;
2166
2167     case INDEX_op_qemu_ld_i32:
2168     case INDEX_op_qemu_ld_i64:
2169         tcg_out_qemu_ld(s, a0, a1, a2, ext);
2170         break;
2171     case INDEX_op_qemu_st_i32:
2172     case INDEX_op_qemu_st_i64:
2173         tcg_out_qemu_st(s, REG0(0), a1, a2);
2174         break;
2175
2176     case INDEX_op_bswap64_i64:
2177         tcg_out_rev64(s, a0, a1);
2178         break;
2179     case INDEX_op_bswap32_i64:
2180     case INDEX_op_bswap32_i32:
2181         tcg_out_rev32(s, a0, a1);
2182         break;
2183     case INDEX_op_bswap16_i64:
2184     case INDEX_op_bswap16_i32:
2185         tcg_out_rev16(s, a0, a1);
2186         break;
2187
2188     case INDEX_op_ext8s_i64:
2189     case INDEX_op_ext8s_i32:
2190         tcg_out_sxt(s, ext, MO_8, a0, a1);
2191         break;
2192     case INDEX_op_ext16s_i64:
2193     case INDEX_op_ext16s_i32:
2194         tcg_out_sxt(s, ext, MO_16, a0, a1);
2195         break;
2196     case INDEX_op_ext_i32_i64:
2197     case INDEX_op_ext32s_i64:
2198         tcg_out_sxt(s, TCG_TYPE_I64, MO_32, a0, a1);
2199         break;
2200     case INDEX_op_ext8u_i64:
2201     case INDEX_op_ext8u_i32:
2202         tcg_out_uxt(s, MO_8, a0, a1);
2203         break;
2204     case INDEX_op_ext16u_i64:
2205     case INDEX_op_ext16u_i32:
2206         tcg_out_uxt(s, MO_16, a0, a1);
2207         break;
2208     case INDEX_op_extu_i32_i64:
2209     case INDEX_op_ext32u_i64:
2210         tcg_out_movr(s, TCG_TYPE_I32, a0, a1);
2211         break;
2212
2213     case INDEX_op_deposit_i64:
2214     case INDEX_op_deposit_i32:
2215         tcg_out_dep(s, ext, a0, REG0(2), args[3], args[4]);
2216         break;
2217
2218     case INDEX_op_extract_i64:
2219     case INDEX_op_extract_i32:
2220         tcg_out_ubfm(s, ext, a0, a1, a2, a2 + args[3] - 1);
2221         break;
2222
2223     case INDEX_op_sextract_i64:
2224     case INDEX_op_sextract_i32:
2225         tcg_out_sbfm(s, ext, a0, a1, a2, a2 + args[3] - 1);
2226         break;
2227
2228     case INDEX_op_extract2_i64:
2229     case INDEX_op_extract2_i32:
2230         tcg_out_extr(s, ext, a0, REG0(2), REG0(1), args[3]);
2231         break;
2232
2233     case INDEX_op_add2_i32:
2234         tcg_out_addsub2(s, TCG_TYPE_I32, a0, a1, REG0(2), REG0(3),
2235                         (int32_t)args[4], args[5], const_args[4],
2236                         const_args[5], false);
2237         break;
2238     case INDEX_op_add2_i64:
2239         tcg_out_addsub2(s, TCG_TYPE_I64, a0, a1, REG0(2), REG0(3), args[4],
2240                         args[5], const_args[4], const_args[5], false);
2241         break;
2242     case INDEX_op_sub2_i32:
2243         tcg_out_addsub2(s, TCG_TYPE_I32, a0, a1, REG0(2), REG0(3),
2244                         (int32_t)args[4], args[5], const_args[4],
2245                         const_args[5], true);
2246         break;
2247     case INDEX_op_sub2_i64:
2248         tcg_out_addsub2(s, TCG_TYPE_I64, a0, a1, REG0(2), REG0(3), args[4],
2249                         args[5], const_args[4], const_args[5], true);
2250         break;
2251
2252     case INDEX_op_muluh_i64:
2253         tcg_out_insn(s, 3508, UMULH, TCG_TYPE_I64, a0, a1, a2);
2254         break;
2255     case INDEX_op_mulsh_i64:
2256         tcg_out_insn(s, 3508, SMULH, TCG_TYPE_I64, a0, a1, a2);
2257         break;
2258
2259     case INDEX_op_mb:
2260         tcg_out_mb(s, a0);
2261         break;
2262
2263     case INDEX_op_mov_i32:  /* Always emitted via tcg_out_mov.  */
2264     case INDEX_op_mov_i64:
2265     case INDEX_op_movi_i32: /* Always emitted via tcg_out_movi.  */
2266     case INDEX_op_movi_i64:
2267     case INDEX_op_call:     /* Always emitted via tcg_out_call.  */
2268     default:
2269         g_assert_not_reached();
2270     }
2271
2272 #undef REG0
2273 }
2274
2275 static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
2276                            unsigned vecl, unsigned vece,
2277                            const TCGArg *args, const int *const_args)
2278 {
2279     static const AArch64Insn cmp_insn[16] = {
2280         [TCG_COND_EQ] = I3616_CMEQ,
2281         [TCG_COND_GT] = I3616_CMGT,
2282         [TCG_COND_GE] = I3616_CMGE,
2283         [TCG_COND_GTU] = I3616_CMHI,
2284         [TCG_COND_GEU] = I3616_CMHS,
2285     };
2286     static const AArch64Insn cmp0_insn[16] = {
2287         [TCG_COND_EQ] = I3617_CMEQ0,
2288         [TCG_COND_GT] = I3617_CMGT0,
2289         [TCG_COND_GE] = I3617_CMGE0,
2290         [TCG_COND_LT] = I3617_CMLT0,
2291         [TCG_COND_LE] = I3617_CMLE0,
2292     };
2293
2294     TCGType type = vecl + TCG_TYPE_V64;
2295     unsigned is_q = vecl;
2296     TCGArg a0, a1, a2, a3;
2297     int cmode, imm8;
2298
2299     a0 = args[0];
2300     a1 = args[1];
2301     a2 = args[2];
2302
2303     switch (opc) {
2304     case INDEX_op_ld_vec:
2305         tcg_out_ld(s, type, a0, a1, a2);
2306         break;
2307     case INDEX_op_st_vec:
2308         tcg_out_st(s, type, a0, a1, a2);
2309         break;
2310     case INDEX_op_dupm_vec:
2311         tcg_out_dupm_vec(s, type, vece, a0, a1, a2);
2312         break;
2313     case INDEX_op_add_vec:
2314         tcg_out_insn(s, 3616, ADD, is_q, vece, a0, a1, a2);
2315         break;
2316     case INDEX_op_sub_vec:
2317         tcg_out_insn(s, 3616, SUB, is_q, vece, a0, a1, a2);
2318         break;
2319     case INDEX_op_mul_vec:
2320         tcg_out_insn(s, 3616, MUL, is_q, vece, a0, a1, a2);
2321         break;
2322     case INDEX_op_neg_vec:
2323         tcg_out_insn(s, 3617, NEG, is_q, vece, a0, a1);
2324         break;
2325     case INDEX_op_abs_vec:
2326         tcg_out_insn(s, 3617, ABS, is_q, vece, a0, a1);
2327         break;
2328     case INDEX_op_and_vec:
2329         if (const_args[2]) {
2330             is_shimm1632(~a2, &cmode, &imm8);
2331             if (a0 == a1) {
2332                 tcg_out_insn(s, 3606, BIC, is_q, a0, 0, cmode, imm8);
2333                 return;
2334             }
2335             tcg_out_insn(s, 3606, MVNI, is_q, a0, 0, cmode, imm8);
2336             a2 = a0;
2337         }
2338         tcg_out_insn(s, 3616, AND, is_q, 0, a0, a1, a2);
2339         break;
2340     case INDEX_op_or_vec:
2341         if (const_args[2]) {
2342             is_shimm1632(a2, &cmode, &imm8);
2343             if (a0 == a1) {
2344                 tcg_out_insn(s, 3606, ORR, is_q, a0, 0, cmode, imm8);
2345                 return;
2346             }
2347             tcg_out_insn(s, 3606, MOVI, is_q, a0, 0, cmode, imm8);
2348             a2 = a0;
2349         }
2350         tcg_out_insn(s, 3616, ORR, is_q, 0, a0, a1, a2);
2351         break;
2352     case INDEX_op_andc_vec:
2353         if (const_args[2]) {
2354             is_shimm1632(a2, &cmode, &imm8);
2355             if (a0 == a1) {
2356                 tcg_out_insn(s, 3606, BIC, is_q, a0, 0, cmode, imm8);
2357                 return;
2358             }
2359             tcg_out_insn(s, 3606, MOVI, is_q, a0, 0, cmode, imm8);
2360             a2 = a0;
2361         }
2362         tcg_out_insn(s, 3616, BIC, is_q, 0, a0, a1, a2);
2363         break;
2364     case INDEX_op_orc_vec:
2365         if (const_args[2]) {
2366             is_shimm1632(~a2, &cmode, &imm8);
2367             if (a0 == a1) {
2368                 tcg_out_insn(s, 3606, ORR, is_q, a0, 0, cmode, imm8);
2369                 return;
2370             }
2371             tcg_out_insn(s, 3606, MVNI, is_q, a0, 0, cmode, imm8);
2372             a2 = a0;
2373         }
2374         tcg_out_insn(s, 3616, ORN, is_q, 0, a0, a1, a2);
2375         break;
2376     case INDEX_op_xor_vec:
2377         tcg_out_insn(s, 3616, EOR, is_q, 0, a0, a1, a2);
2378         break;
2379     case INDEX_op_ssadd_vec:
2380         tcg_out_insn(s, 3616, SQADD, is_q, vece, a0, a1, a2);
2381         break;
2382     case INDEX_op_sssub_vec:
2383         tcg_out_insn(s, 3616, SQSUB, is_q, vece, a0, a1, a2);
2384         break;
2385     case INDEX_op_usadd_vec:
2386         tcg_out_insn(s, 3616, UQADD, is_q, vece, a0, a1, a2);
2387         break;
2388     case INDEX_op_ussub_vec:
2389         tcg_out_insn(s, 3616, UQSUB, is_q, vece, a0, a1, a2);
2390         break;
2391     case INDEX_op_smax_vec:
2392         tcg_out_insn(s, 3616, SMAX, is_q, vece, a0, a1, a2);
2393         break;
2394     case INDEX_op_smin_vec:
2395         tcg_out_insn(s, 3616, SMIN, is_q, vece, a0, a1, a2);
2396         break;
2397     case INDEX_op_umax_vec:
2398         tcg_out_insn(s, 3616, UMAX, is_q, vece, a0, a1, a2);
2399         break;
2400     case INDEX_op_umin_vec:
2401         tcg_out_insn(s, 3616, UMIN, is_q, vece, a0, a1, a2);
2402         break;
2403     case INDEX_op_not_vec:
2404         tcg_out_insn(s, 3617, NOT, is_q, 0, a0, a1);
2405         break;
2406     case INDEX_op_shli_vec:
2407         tcg_out_insn(s, 3614, SHL, is_q, a0, a1, a2 + (8 << vece));
2408         break;
2409     case INDEX_op_shri_vec:
2410         tcg_out_insn(s, 3614, USHR, is_q, a0, a1, (16 << vece) - a2);
2411         break;
2412     case INDEX_op_sari_vec:
2413         tcg_out_insn(s, 3614, SSHR, is_q, a0, a1, (16 << vece) - a2);
2414         break;
2415     case INDEX_op_aa64_sli_vec:
2416         tcg_out_insn(s, 3614, SLI, is_q, a0, a2, args[3] + (8 << vece));
2417         break;
2418     case INDEX_op_shlv_vec:
2419         tcg_out_insn(s, 3616, USHL, is_q, vece, a0, a1, a2);
2420         break;
2421     case INDEX_op_aa64_sshl_vec:
2422         tcg_out_insn(s, 3616, SSHL, is_q, vece, a0, a1, a2);
2423         break;
2424     case INDEX_op_cmp_vec:
2425         {
2426             TCGCond cond = args[3];
2427             AArch64Insn insn;
2428
2429             if (cond == TCG_COND_NE) {
2430                 if (const_args[2]) {
2431                     tcg_out_insn(s, 3616, CMTST, is_q, vece, a0, a1, a1);
2432                 } else {
2433                     tcg_out_insn(s, 3616, CMEQ, is_q, vece, a0, a1, a2);
2434                     tcg_out_insn(s, 3617, NOT, is_q, 0, a0, a0);
2435                 }
2436             } else {
2437                 if (const_args[2]) {
2438                     insn = cmp0_insn[cond];
2439                     if (insn) {
2440                         tcg_out_insn_3617(s, insn, is_q, vece, a0, a1);
2441                         break;
2442                     }
2443                     tcg_out_dupi_vec(s, type, TCG_VEC_TMP, 0);
2444                     a2 = TCG_VEC_TMP;
2445                 }
2446                 insn = cmp_insn[cond];
2447                 if (insn == 0) {
2448                     TCGArg t;
2449                     t = a1, a1 = a2, a2 = t;
2450                     cond = tcg_swap_cond(cond);
2451                     insn = cmp_insn[cond];
2452                     tcg_debug_assert(insn != 0);
2453                 }
2454                 tcg_out_insn_3616(s, insn, is_q, vece, a0, a1, a2);
2455             }
2456         }
2457         break;
2458
2459     case INDEX_op_bitsel_vec:
2460         a3 = args[3];
2461         if (a0 == a3) {
2462             tcg_out_insn(s, 3616, BIT, is_q, 0, a0, a2, a1);
2463         } else if (a0 == a2) {
2464             tcg_out_insn(s, 3616, BIF, is_q, 0, a0, a3, a1);
2465         } else {
2466             if (a0 != a1) {
2467                 tcg_out_mov(s, type, a0, a1);
2468             }
2469             tcg_out_insn(s, 3616, BSL, is_q, 0, a0, a2, a3);
2470         }
2471         break;
2472
2473     case INDEX_op_mov_vec:  /* Always emitted via tcg_out_mov.  */
2474     case INDEX_op_dupi_vec: /* Always emitted via tcg_out_movi.  */
2475     case INDEX_op_dup_vec:  /* Always emitted via tcg_out_dup_vec.  */
2476     default:
2477         g_assert_not_reached();
2478     }
2479 }
2480
2481 int tcg_can_emit_vec_op(TCGOpcode opc, TCGType type, unsigned vece)
2482 {
2483     switch (opc) {
2484     case INDEX_op_add_vec:
2485     case INDEX_op_sub_vec:
2486     case INDEX_op_and_vec:
2487     case INDEX_op_or_vec:
2488     case INDEX_op_xor_vec:
2489     case INDEX_op_andc_vec:
2490     case INDEX_op_orc_vec:
2491     case INDEX_op_neg_vec:
2492     case INDEX_op_abs_vec:
2493     case INDEX_op_not_vec:
2494     case INDEX_op_cmp_vec:
2495     case INDEX_op_shli_vec:
2496     case INDEX_op_shri_vec:
2497     case INDEX_op_sari_vec:
2498     case INDEX_op_ssadd_vec:
2499     case INDEX_op_sssub_vec:
2500     case INDEX_op_usadd_vec:
2501     case INDEX_op_ussub_vec:
2502     case INDEX_op_shlv_vec:
2503     case INDEX_op_bitsel_vec:
2504         return 1;
2505     case INDEX_op_rotli_vec:
2506     case INDEX_op_shrv_vec:
2507     case INDEX_op_sarv_vec:
2508     case INDEX_op_rotlv_vec:
2509     case INDEX_op_rotrv_vec:
2510         return -1;
2511     case INDEX_op_mul_vec:
2512     case INDEX_op_smax_vec:
2513     case INDEX_op_smin_vec:
2514     case INDEX_op_umax_vec:
2515     case INDEX_op_umin_vec:
2516         return vece < MO_64;
2517
2518     default:
2519         return 0;
2520     }
2521 }
2522
2523 void tcg_expand_vec_op(TCGOpcode opc, TCGType type, unsigned vece,
2524                        TCGArg a0, ...)
2525 {
2526     va_list va;
2527     TCGv_vec v0, v1, v2, t1, t2;
2528     TCGArg a2;
2529
2530     va_start(va, a0);
2531     v0 = temp_tcgv_vec(arg_temp(a0));
2532     v1 = temp_tcgv_vec(arg_temp(va_arg(va, TCGArg)));
2533     a2 = va_arg(va, TCGArg);
2534     v2 = temp_tcgv_vec(arg_temp(a2));
2535
2536     switch (opc) {
2537     case INDEX_op_rotli_vec:
2538         t1 = tcg_temp_new_vec(type);
2539         tcg_gen_shri_vec(vece, t1, v1, -a2 & ((8 << vece) - 1));
2540         vec_gen_4(INDEX_op_aa64_sli_vec, type, vece,
2541                   tcgv_vec_arg(v0), tcgv_vec_arg(t1), tcgv_vec_arg(v1), a2);
2542         tcg_temp_free_vec(t1);
2543         break;
2544
2545     case INDEX_op_shrv_vec:
2546     case INDEX_op_sarv_vec:
2547         /* Right shifts are negative left shifts for AArch64.  */
2548         t1 = tcg_temp_new_vec(type);
2549         tcg_gen_neg_vec(vece, t1, v2);
2550         opc = (opc == INDEX_op_shrv_vec
2551                ? INDEX_op_shlv_vec : INDEX_op_aa64_sshl_vec);
2552         vec_gen_3(opc, type, vece, tcgv_vec_arg(v0),
2553                   tcgv_vec_arg(v1), tcgv_vec_arg(t1));
2554         tcg_temp_free_vec(t1);
2555         break;
2556
2557     case INDEX_op_rotlv_vec:
2558         t1 = tcg_temp_new_vec(type);
2559         tcg_gen_dupi_vec(vece, t1, 8 << vece);
2560         tcg_gen_sub_vec(vece, t1, v2, t1);
2561         /* Right shifts are negative left shifts for AArch64.  */
2562         vec_gen_3(INDEX_op_shlv_vec, type, vece, tcgv_vec_arg(t1),
2563                   tcgv_vec_arg(v1), tcgv_vec_arg(t1));
2564         vec_gen_3(INDEX_op_shlv_vec, type, vece, tcgv_vec_arg(v0),
2565                   tcgv_vec_arg(v1), tcgv_vec_arg(v2));
2566         tcg_gen_or_vec(vece, v0, v0, t1);
2567         tcg_temp_free_vec(t1);
2568         break;
2569
2570     case INDEX_op_rotrv_vec:
2571         t1 = tcg_temp_new_vec(type);
2572         t2 = tcg_temp_new_vec(type);
2573         tcg_gen_neg_vec(vece, t1, v2);
2574         tcg_gen_dupi_vec(vece, t2, 8 << vece);
2575         tcg_gen_add_vec(vece, t2, t1, t2);
2576         /* Right shifts are negative left shifts for AArch64.  */
2577         vec_gen_3(INDEX_op_shlv_vec, type, vece, tcgv_vec_arg(t1),
2578                   tcgv_vec_arg(v1), tcgv_vec_arg(t1));
2579         vec_gen_3(INDEX_op_shlv_vec, type, vece, tcgv_vec_arg(t2),
2580                   tcgv_vec_arg(v1), tcgv_vec_arg(t2));
2581         tcg_gen_or_vec(vece, v0, t1, t2);
2582         tcg_temp_free_vec(t1);
2583         tcg_temp_free_vec(t2);
2584         break;
2585
2586     default:
2587         g_assert_not_reached();
2588     }
2589
2590     va_end(va);
2591 }
2592
2593 static const TCGTargetOpDef *tcg_target_op_def(TCGOpcode op)
2594 {
2595     static const TCGTargetOpDef r = { .args_ct_str = { "r" } };
2596     static const TCGTargetOpDef r_r = { .args_ct_str = { "r", "r" } };
2597     static const TCGTargetOpDef w_w = { .args_ct_str = { "w", "w" } };
2598     static const TCGTargetOpDef w_r = { .args_ct_str = { "w", "r" } };
2599     static const TCGTargetOpDef w_wr = { .args_ct_str = { "w", "wr" } };
2600     static const TCGTargetOpDef r_l = { .args_ct_str = { "r", "l" } };
2601     static const TCGTargetOpDef r_rA = { .args_ct_str = { "r", "rA" } };
2602     static const TCGTargetOpDef rZ_r = { .args_ct_str = { "rZ", "r" } };
2603     static const TCGTargetOpDef lZ_l = { .args_ct_str = { "lZ", "l" } };
2604     static const TCGTargetOpDef r_r_r = { .args_ct_str = { "r", "r", "r" } };
2605     static const TCGTargetOpDef w_w_w = { .args_ct_str = { "w", "w", "w" } };
2606     static const TCGTargetOpDef w_0_w = { .args_ct_str = { "w", "0", "w" } };
2607     static const TCGTargetOpDef w_w_wO = { .args_ct_str = { "w", "w", "wO" } };
2608     static const TCGTargetOpDef w_w_wN = { .args_ct_str = { "w", "w", "wN" } };
2609     static const TCGTargetOpDef w_w_wZ = { .args_ct_str = { "w", "w", "wZ" } };
2610     static const TCGTargetOpDef r_r_ri = { .args_ct_str = { "r", "r", "ri" } };
2611     static const TCGTargetOpDef r_r_rA = { .args_ct_str = { "r", "r", "rA" } };
2612     static const TCGTargetOpDef r_r_rL = { .args_ct_str = { "r", "r", "rL" } };
2613     static const TCGTargetOpDef r_r_rAL
2614         = { .args_ct_str = { "r", "r", "rAL" } };
2615     static const TCGTargetOpDef dep
2616         = { .args_ct_str = { "r", "0", "rZ" } };
2617     static const TCGTargetOpDef ext2
2618         = { .args_ct_str = { "r", "rZ", "rZ" } };
2619     static const TCGTargetOpDef movc
2620         = { .args_ct_str = { "r", "r", "rA", "rZ", "rZ" } };
2621     static const TCGTargetOpDef add2
2622         = { .args_ct_str = { "r", "r", "rZ", "rZ", "rA", "rMZ" } };
2623     static const TCGTargetOpDef w_w_w_w
2624         = { .args_ct_str = { "w", "w", "w", "w" } };
2625
2626     switch (op) {
2627     case INDEX_op_goto_ptr:
2628         return &r;
2629
2630     case INDEX_op_ld8u_i32:
2631     case INDEX_op_ld8s_i32:
2632     case INDEX_op_ld16u_i32:
2633     case INDEX_op_ld16s_i32:
2634     case INDEX_op_ld_i32:
2635     case INDEX_op_ld8u_i64:
2636     case INDEX_op_ld8s_i64:
2637     case INDEX_op_ld16u_i64:
2638     case INDEX_op_ld16s_i64:
2639     case INDEX_op_ld32u_i64:
2640     case INDEX_op_ld32s_i64:
2641     case INDEX_op_ld_i64:
2642     case INDEX_op_neg_i32:
2643     case INDEX_op_neg_i64:
2644     case INDEX_op_not_i32:
2645     case INDEX_op_not_i64:
2646     case INDEX_op_bswap16_i32:
2647     case INDEX_op_bswap32_i32:
2648     case INDEX_op_bswap16_i64:
2649     case INDEX_op_bswap32_i64:
2650     case INDEX_op_bswap64_i64:
2651     case INDEX_op_ext8s_i32:
2652     case INDEX_op_ext16s_i32:
2653     case INDEX_op_ext8u_i32:
2654     case INDEX_op_ext16u_i32:
2655     case INDEX_op_ext8s_i64:
2656     case INDEX_op_ext16s_i64:
2657     case INDEX_op_ext32s_i64:
2658     case INDEX_op_ext8u_i64:
2659     case INDEX_op_ext16u_i64:
2660     case INDEX_op_ext32u_i64:
2661     case INDEX_op_ext_i32_i64:
2662     case INDEX_op_extu_i32_i64:
2663     case INDEX_op_extract_i32:
2664     case INDEX_op_extract_i64:
2665     case INDEX_op_sextract_i32:
2666     case INDEX_op_sextract_i64:
2667         return &r_r;
2668
2669     case INDEX_op_st8_i32:
2670     case INDEX_op_st16_i32:
2671     case INDEX_op_st_i32:
2672     case INDEX_op_st8_i64:
2673     case INDEX_op_st16_i64:
2674     case INDEX_op_st32_i64:
2675     case INDEX_op_st_i64:
2676         return &rZ_r;
2677
2678     case INDEX_op_add_i32:
2679     case INDEX_op_add_i64:
2680     case INDEX_op_sub_i32:
2681     case INDEX_op_sub_i64:
2682     case INDEX_op_setcond_i32:
2683     case INDEX_op_setcond_i64:
2684         return &r_r_rA;
2685
2686     case INDEX_op_mul_i32:
2687     case INDEX_op_mul_i64:
2688     case INDEX_op_div_i32:
2689     case INDEX_op_div_i64:
2690     case INDEX_op_divu_i32:
2691     case INDEX_op_divu_i64:
2692     case INDEX_op_rem_i32:
2693     case INDEX_op_rem_i64:
2694     case INDEX_op_remu_i32:
2695     case INDEX_op_remu_i64:
2696     case INDEX_op_muluh_i64:
2697     case INDEX_op_mulsh_i64:
2698         return &r_r_r;
2699
2700     case INDEX_op_and_i32:
2701     case INDEX_op_and_i64:
2702     case INDEX_op_or_i32:
2703     case INDEX_op_or_i64:
2704     case INDEX_op_xor_i32:
2705     case INDEX_op_xor_i64:
2706     case INDEX_op_andc_i32:
2707     case INDEX_op_andc_i64:
2708     case INDEX_op_orc_i32:
2709     case INDEX_op_orc_i64:
2710     case INDEX_op_eqv_i32:
2711     case INDEX_op_eqv_i64:
2712         return &r_r_rL;
2713
2714     case INDEX_op_shl_i32:
2715     case INDEX_op_shr_i32:
2716     case INDEX_op_sar_i32:
2717     case INDEX_op_rotl_i32:
2718     case INDEX_op_rotr_i32:
2719     case INDEX_op_shl_i64:
2720     case INDEX_op_shr_i64:
2721     case INDEX_op_sar_i64:
2722     case INDEX_op_rotl_i64:
2723     case INDEX_op_rotr_i64:
2724         return &r_r_ri;
2725
2726     case INDEX_op_clz_i32:
2727     case INDEX_op_ctz_i32:
2728     case INDEX_op_clz_i64:
2729     case INDEX_op_ctz_i64:
2730         return &r_r_rAL;
2731
2732     case INDEX_op_brcond_i32:
2733     case INDEX_op_brcond_i64:
2734         return &r_rA;
2735
2736     case INDEX_op_movcond_i32:
2737     case INDEX_op_movcond_i64:
2738         return &movc;
2739
2740     case INDEX_op_qemu_ld_i32:
2741     case INDEX_op_qemu_ld_i64:
2742         return &r_l;
2743     case INDEX_op_qemu_st_i32:
2744     case INDEX_op_qemu_st_i64:
2745         return &lZ_l;
2746
2747     case INDEX_op_deposit_i32:
2748     case INDEX_op_deposit_i64:
2749         return &dep;
2750
2751     case INDEX_op_extract2_i32:
2752     case INDEX_op_extract2_i64:
2753         return &ext2;
2754
2755     case INDEX_op_add2_i32:
2756     case INDEX_op_add2_i64:
2757     case INDEX_op_sub2_i32:
2758     case INDEX_op_sub2_i64:
2759         return &add2;
2760
2761     case INDEX_op_add_vec:
2762     case INDEX_op_sub_vec:
2763     case INDEX_op_mul_vec:
2764     case INDEX_op_xor_vec:
2765     case INDEX_op_ssadd_vec:
2766     case INDEX_op_sssub_vec:
2767     case INDEX_op_usadd_vec:
2768     case INDEX_op_ussub_vec:
2769     case INDEX_op_smax_vec:
2770     case INDEX_op_smin_vec:
2771     case INDEX_op_umax_vec:
2772     case INDEX_op_umin_vec:
2773     case INDEX_op_shlv_vec:
2774     case INDEX_op_shrv_vec:
2775     case INDEX_op_sarv_vec:
2776     case INDEX_op_aa64_sshl_vec:
2777         return &w_w_w;
2778     case INDEX_op_not_vec:
2779     case INDEX_op_neg_vec:
2780     case INDEX_op_abs_vec:
2781     case INDEX_op_shli_vec:
2782     case INDEX_op_shri_vec:
2783     case INDEX_op_sari_vec:
2784         return &w_w;
2785     case INDEX_op_ld_vec:
2786     case INDEX_op_st_vec:
2787     case INDEX_op_dupm_vec:
2788         return &w_r;
2789     case INDEX_op_dup_vec:
2790         return &w_wr;
2791     case INDEX_op_or_vec:
2792     case INDEX_op_andc_vec:
2793         return &w_w_wO;
2794     case INDEX_op_and_vec:
2795     case INDEX_op_orc_vec:
2796         return &w_w_wN;
2797     case INDEX_op_cmp_vec:
2798         return &w_w_wZ;
2799     case INDEX_op_bitsel_vec:
2800         return &w_w_w_w;
2801     case INDEX_op_aa64_sli_vec:
2802         return &w_0_w;
2803
2804     default:
2805         return NULL;
2806     }
2807 }
2808
2809 static void tcg_target_init(TCGContext *s)
2810 {
2811     tcg_target_available_regs[TCG_TYPE_I32] = 0xffffffffu;
2812     tcg_target_available_regs[TCG_TYPE_I64] = 0xffffffffu;
2813     tcg_target_available_regs[TCG_TYPE_V64] = 0xffffffff00000000ull;
2814     tcg_target_available_regs[TCG_TYPE_V128] = 0xffffffff00000000ull;
2815
2816     tcg_target_call_clobber_regs = -1ull;
2817     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X19);
2818     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X20);
2819     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X21);
2820     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X22);
2821     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X23);
2822     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X24);
2823     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X25);
2824     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X26);
2825     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X27);
2826     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X28);
2827     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_X29);
2828     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_V8);
2829     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_V9);
2830     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_V10);
2831     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_V11);
2832     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_V12);
2833     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_V13);
2834     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_V14);
2835     tcg_regset_reset_reg(tcg_target_call_clobber_regs, TCG_REG_V15);
2836
2837     s->reserved_regs = 0;
2838     tcg_regset_set_reg(s->reserved_regs, TCG_REG_SP);
2839     tcg_regset_set_reg(s->reserved_regs, TCG_REG_FP);
2840     tcg_regset_set_reg(s->reserved_regs, TCG_REG_TMP);
2841     tcg_regset_set_reg(s->reserved_regs, TCG_REG_X18); /* platform register */
2842     tcg_regset_set_reg(s->reserved_regs, TCG_VEC_TMP);
2843 }
2844
2845 /* Saving pairs: (X19, X20) .. (X27, X28), (X29(fp), X30(lr)).  */
2846 #define PUSH_SIZE  ((30 - 19 + 1) * 8)
2847
2848 #define FRAME_SIZE \
2849     ((PUSH_SIZE \
2850       + TCG_STATIC_CALL_ARGS_SIZE \
2851       + CPU_TEMP_BUF_NLONGS * sizeof(long) \
2852       + TCG_TARGET_STACK_ALIGN - 1) \
2853      & ~(TCG_TARGET_STACK_ALIGN - 1))
2854
2855 /* We're expecting a 2 byte uleb128 encoded value.  */
2856 QEMU_BUILD_BUG_ON(FRAME_SIZE >= (1 << 14));
2857
2858 /* We're expecting to use a single ADDI insn.  */
2859 QEMU_BUILD_BUG_ON(FRAME_SIZE - PUSH_SIZE > 0xfff);
2860
2861 static void tcg_target_qemu_prologue(TCGContext *s)
2862 {
2863     TCGReg r;
2864
2865     /* Push (FP, LR) and allocate space for all saved registers.  */
2866     tcg_out_insn(s, 3314, STP, TCG_REG_FP, TCG_REG_LR,
2867                  TCG_REG_SP, -PUSH_SIZE, 1, 1);
2868
2869     /* Set up frame pointer for canonical unwinding.  */
2870     tcg_out_movr_sp(s, TCG_TYPE_I64, TCG_REG_FP, TCG_REG_SP);
2871
2872     /* Store callee-preserved regs x19..x28.  */
2873     for (r = TCG_REG_X19; r <= TCG_REG_X27; r += 2) {
2874         int ofs = (r - TCG_REG_X19 + 2) * 8;
2875         tcg_out_insn(s, 3314, STP, r, r + 1, TCG_REG_SP, ofs, 1, 0);
2876     }
2877
2878     /* Make stack space for TCG locals.  */
2879     tcg_out_insn(s, 3401, SUBI, TCG_TYPE_I64, TCG_REG_SP, TCG_REG_SP,
2880                  FRAME_SIZE - PUSH_SIZE);
2881
2882     /* Inform TCG about how to find TCG locals with register, offset, size.  */
2883     tcg_set_frame(s, TCG_REG_SP, TCG_STATIC_CALL_ARGS_SIZE,
2884                   CPU_TEMP_BUF_NLONGS * sizeof(long));
2885
2886 #if !defined(CONFIG_SOFTMMU)
2887     if (USE_GUEST_BASE) {
2888         tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_GUEST_BASE, guest_base);
2889         tcg_regset_set_reg(s->reserved_regs, TCG_REG_GUEST_BASE);
2890     }
2891 #endif
2892
2893     tcg_out_mov(s, TCG_TYPE_PTR, TCG_AREG0, tcg_target_call_iarg_regs[0]);
2894     tcg_out_insn(s, 3207, BR, tcg_target_call_iarg_regs[1]);
2895
2896     /*
2897      * Return path for goto_ptr. Set return value to 0, a-la exit_tb,
2898      * and fall through to the rest of the epilogue.
2899      */
2900     s->code_gen_epilogue = s->code_ptr;
2901     tcg_out_movi(s, TCG_TYPE_REG, TCG_REG_X0, 0);
2902
2903     /* TB epilogue */
2904     tb_ret_addr = s->code_ptr;
2905
2906     /* Remove TCG locals stack space.  */
2907     tcg_out_insn(s, 3401, ADDI, TCG_TYPE_I64, TCG_REG_SP, TCG_REG_SP,
2908                  FRAME_SIZE - PUSH_SIZE);
2909
2910     /* Restore registers x19..x28.  */
2911     for (r = TCG_REG_X19; r <= TCG_REG_X27; r += 2) {
2912         int ofs = (r - TCG_REG_X19 + 2) * 8;
2913         tcg_out_insn(s, 3314, LDP, r, r + 1, TCG_REG_SP, ofs, 1, 0);
2914     }
2915
2916     /* Pop (FP, LR), restore SP to previous frame.  */
2917     tcg_out_insn(s, 3314, LDP, TCG_REG_FP, TCG_REG_LR,
2918                  TCG_REG_SP, PUSH_SIZE, 0, 1);
2919     tcg_out_insn(s, 3207, RET, TCG_REG_LR);
2920 }
2921
2922 static void tcg_out_nop_fill(tcg_insn_unit *p, int count)
2923 {
2924     int i;
2925     for (i = 0; i < count; ++i) {
2926         p[i] = NOP;
2927     }
2928 }
2929
2930 typedef struct {
2931     DebugFrameHeader h;
2932     uint8_t fde_def_cfa[4];
2933     uint8_t fde_reg_ofs[24];
2934 } DebugFrame;
2935
2936 #define ELF_HOST_MACHINE EM_AARCH64
2937
2938 static const DebugFrame debug_frame = {
2939     .h.cie.len = sizeof(DebugFrameCIE)-4, /* length after .len member */
2940     .h.cie.id = -1,
2941     .h.cie.version = 1,
2942     .h.cie.code_align = 1,
2943     .h.cie.data_align = 0x78,             /* sleb128 -8 */
2944     .h.cie.return_column = TCG_REG_LR,
2945
2946     /* Total FDE size does not include the "len" member.  */
2947     .h.fde.len = sizeof(DebugFrame) - offsetof(DebugFrame, h.fde.cie_offset),
2948
2949     .fde_def_cfa = {
2950         12, TCG_REG_SP,                 /* DW_CFA_def_cfa sp, ... */
2951         (FRAME_SIZE & 0x7f) | 0x80,     /* ... uleb128 FRAME_SIZE */
2952         (FRAME_SIZE >> 7)
2953     },
2954     .fde_reg_ofs = {
2955         0x80 + 28, 1,                   /* DW_CFA_offset, x28,  -8 */
2956         0x80 + 27, 2,                   /* DW_CFA_offset, x27, -16 */
2957         0x80 + 26, 3,                   /* DW_CFA_offset, x26, -24 */
2958         0x80 + 25, 4,                   /* DW_CFA_offset, x25, -32 */
2959         0x80 + 24, 5,                   /* DW_CFA_offset, x24, -40 */
2960         0x80 + 23, 6,                   /* DW_CFA_offset, x23, -48 */
2961         0x80 + 22, 7,                   /* DW_CFA_offset, x22, -56 */
2962         0x80 + 21, 8,                   /* DW_CFA_offset, x21, -64 */
2963         0x80 + 20, 9,                   /* DW_CFA_offset, x20, -72 */
2964         0x80 + 19, 10,                  /* DW_CFA_offset, x1p, -80 */
2965         0x80 + 30, 11,                  /* DW_CFA_offset,  lr, -88 */
2966         0x80 + 29, 12,                  /* DW_CFA_offset,  fp, -96 */
2967     }
2968 };
2969
2970 void tcg_register_jit(void *buf, size_t buf_size)
2971 {
2972     tcg_register_jit_int(buf, buf_size, &debug_frame, sizeof(debug_frame));
2973 }