target/arm/translate.c

   1 /*
   2  *  ARM translation
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *  Copyright (c) 2005-2007 CodeSourcery
   6  *  Copyright (c) 2007 OpenedHand, Ltd.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21 #include "qemu/osdep.h"
  22
  23 #include "cpu.h"
  24 #include "internals.h"
  25 #include "disas/disas.h"
  26 #include "exec/exec-all.h"
  27 #include "tcg/tcg-op.h"
  28 #include "tcg/tcg-op-gvec.h"
  29 #include "qemu/log.h"
  30 #include "qemu/bitops.h"
  31 #include "arm_ldst.h"
  32 #include "hw/semihosting/semihost.h"
  33
  34 #include "exec/helper-proto.h"
  35 #include "exec/helper-gen.h"
  36
  37 #include "trace-tcg.h"
  38 #include "exec/log.h"
  39
  40
  41 #define ENABLE_ARCH_4T    arm_dc_feature(s, ARM_FEATURE_V4T)
  42 #define ENABLE_ARCH_5     arm_dc_feature(s, ARM_FEATURE_V5)
  43 /* currently all emulated v5 cores are also v5TE, so don't bother */
  44 #define ENABLE_ARCH_5TE   arm_dc_feature(s, ARM_FEATURE_V5)
  45 #define ENABLE_ARCH_5J    dc_isar_feature(aa32_jazelle, s)
  46 #define ENABLE_ARCH_6     arm_dc_feature(s, ARM_FEATURE_V6)
  47 #define ENABLE_ARCH_6K    arm_dc_feature(s, ARM_FEATURE_V6K)
  48 #define ENABLE_ARCH_6T2   arm_dc_feature(s, ARM_FEATURE_THUMB2)
  49 #define ENABLE_ARCH_7     arm_dc_feature(s, ARM_FEATURE_V7)
  50 #define ENABLE_ARCH_8     arm_dc_feature(s, ARM_FEATURE_V8)
  51
  52 #define ARCH(x) do { if (!ENABLE_ARCH_##x) goto illegal_op; } while(0)
  53
  54 #include "translate.h"
  55
  56 #if defined(CONFIG_USER_ONLY)
  57 #define IS_USER(s) 1
  58 #else
  59 #define IS_USER(s) (s->user)
  60 #endif
  61
  62 /* We reuse the same 64-bit temporaries for efficiency.  */
  63 static TCGv_i64 cpu_V0, cpu_V1, cpu_M0;
  64 static TCGv_i32 cpu_R[16];
  65 TCGv_i32 cpu_CF, cpu_NF, cpu_VF, cpu_ZF;
  66 TCGv_i64 cpu_exclusive_addr;
  67 TCGv_i64 cpu_exclusive_val;
  68
  69 #include "exec/gen-icount.h"
  70
  71 static const char * const regnames[] =
  72     { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  73       "r8", "r9", "r10", "r11", "r12", "r13", "r14", "pc" };
  74
  75 /* Function prototypes for gen_ functions calling Neon helpers.  */
  76 typedef void NeonGenThreeOpEnvFn(TCGv_i32, TCGv_env, TCGv_i32,
  77                                  TCGv_i32, TCGv_i32);
  78 /* Function prototypes for gen_ functions for fix point conversions */
  79 typedef void VFPGenFixPointFn(TCGv_i32, TCGv_i32, TCGv_i32, TCGv_ptr);
  80
  81 /* initialize TCG globals.  */
  82 void arm_translate_init(void)
  83 {
  84     int i;
  85
  86     for (i = 0; i < 16; i++) {
  87         cpu_R[i] = tcg_global_mem_new_i32(cpu_env,
  88                                           offsetof(CPUARMState, regs[i]),
  89                                           regnames[i]);
  90     }
  91     cpu_CF = tcg_global_mem_new_i32(cpu_env, offsetof(CPUARMState, CF), "CF");
  92     cpu_NF = tcg_global_mem_new_i32(cpu_env, offsetof(CPUARMState, NF), "NF");
  93     cpu_VF = tcg_global_mem_new_i32(cpu_env, offsetof(CPUARMState, VF), "VF");
  94     cpu_ZF = tcg_global_mem_new_i32(cpu_env, offsetof(CPUARMState, ZF), "ZF");
  95
  96     cpu_exclusive_addr = tcg_global_mem_new_i64(cpu_env,
  97         offsetof(CPUARMState, exclusive_addr), "exclusive_addr");
  98     cpu_exclusive_val = tcg_global_mem_new_i64(cpu_env,
  99         offsetof(CPUARMState, exclusive_val), "exclusive_val");
 100
 101     a64_translate_init();
 102 }
 103
 104 /* Flags for the disas_set_da_iss info argument:
 105  * lower bits hold the Rt register number, higher bits are flags.
 106  */
 107 typedef enum ISSInfo {
 108     ISSNone = 0,
 109     ISSRegMask = 0x1f,
 110     ISSInvalid = (1 << 5),
 111     ISSIsAcqRel = (1 << 6),
 112     ISSIsWrite = (1 << 7),
 113     ISSIs16Bit = (1 << 8),
 114 } ISSInfo;
 115
 116 /* Save the syndrome information for a Data Abort */
 117 static void disas_set_da_iss(DisasContext *s, MemOp memop, ISSInfo issinfo)
 118 {
 119     uint32_t syn;
 120     int sas = memop & MO_SIZE;
 121     bool sse = memop & MO_SIGN;
 122     bool is_acqrel = issinfo & ISSIsAcqRel;
 123     bool is_write = issinfo & ISSIsWrite;
 124     bool is_16bit = issinfo & ISSIs16Bit;
 125     int srt = issinfo & ISSRegMask;
 126
 127     if (issinfo & ISSInvalid) {
 128         /* Some callsites want to conditionally provide ISS info,
 129          * eg "only if this was not a writeback"
 130          */
 131         return;
 132     }
 133
 134     if (srt == 15) {
 135         /* For AArch32, insns where the src/dest is R15 never generate
 136          * ISS information. Catching that here saves checking at all
 137          * the call sites.
 138          */
 139         return;
 140     }
 141
 142     syn = syn_data_abort_with_iss(0, sas, sse, srt, 0, is_acqrel,
 143                                   0, 0, 0, is_write, 0, is_16bit);
 144     disas_set_insn_syndrome(s, syn);
 145 }
 146
 147 static inline int get_a32_user_mem_index(DisasContext *s)
 148 {
 149     /* Return the core mmu_idx to use for A32/T32 "unprivileged load/store"
 150      * insns:
 151      *  if PL2, UNPREDICTABLE (we choose to implement as if PL0)
 152      *  otherwise, access as if at PL0.
 153      */
 154     switch (s->mmu_idx) {
 155     case ARMMMUIdx_E2:        /* this one is UNPREDICTABLE */
 156     case ARMMMUIdx_E10_0:
 157     case ARMMMUIdx_E10_1:
 158     case ARMMMUIdx_E10_1_PAN:
 159         return arm_to_core_mmu_idx(ARMMMUIdx_E10_0);
 160     case ARMMMUIdx_SE3:
 161     case ARMMMUIdx_SE10_0:
 162     case ARMMMUIdx_SE10_1:
 163     case ARMMMUIdx_SE10_1_PAN:
 164         return arm_to_core_mmu_idx(ARMMMUIdx_SE10_0);
 165     case ARMMMUIdx_MUser:
 166     case ARMMMUIdx_MPriv:
 167         return arm_to_core_mmu_idx(ARMMMUIdx_MUser);
 168     case ARMMMUIdx_MUserNegPri:
 169     case ARMMMUIdx_MPrivNegPri:
 170         return arm_to_core_mmu_idx(ARMMMUIdx_MUserNegPri);
 171     case ARMMMUIdx_MSUser:
 172     case ARMMMUIdx_MSPriv:
 173         return arm_to_core_mmu_idx(ARMMMUIdx_MSUser);
 174     case ARMMMUIdx_MSUserNegPri:
 175     case ARMMMUIdx_MSPrivNegPri:
 176         return arm_to_core_mmu_idx(ARMMMUIdx_MSUserNegPri);
 177     default:
 178         g_assert_not_reached();
 179     }
 180 }
 181
 182 static inline TCGv_i32 load_cpu_offset(int offset)
 183 {
 184     TCGv_i32 tmp = tcg_temp_new_i32();
 185     tcg_gen_ld_i32(tmp, cpu_env, offset);
 186     return tmp;
 187 }
 188
 189 #define load_cpu_field(name) load_cpu_offset(offsetof(CPUARMState, name))
 190
 191 static inline void store_cpu_offset(TCGv_i32 var, int offset)
 192 {
 193     tcg_gen_st_i32(var, cpu_env, offset);
 194     tcg_temp_free_i32(var);
 195 }
 196
 197 #define store_cpu_field(var, name) \
 198     store_cpu_offset(var, offsetof(CPUARMState, name))
 199
 200 /* The architectural value of PC.  */
 201 static uint32_t read_pc(DisasContext *s)
 202 {
 203     return s->pc_curr + (s->thumb ? 4 : 8);
 204 }
 205
 206 /* Set a variable to the value of a CPU register.  */
 207 static void load_reg_var(DisasContext *s, TCGv_i32 var, int reg)
 208 {
 209     if (reg == 15) {
 210         tcg_gen_movi_i32(var, read_pc(s));
 211     } else {
 212         tcg_gen_mov_i32(var, cpu_R[reg]);
 213     }
 214 }
 215
 216 /* Create a new temporary and set it to the value of a CPU register.  */
 217 static inline TCGv_i32 load_reg(DisasContext *s, int reg)
 218 {
 219     TCGv_i32 tmp = tcg_temp_new_i32();
 220     load_reg_var(s, tmp, reg);
 221     return tmp;
 222 }
 223
 224 /*
 225  * Create a new temp, REG + OFS, except PC is ALIGN(PC, 4).
 226  * This is used for load/store for which use of PC implies (literal),
 227  * or ADD that implies ADR.
 228  */
 229 static TCGv_i32 add_reg_for_lit(DisasContext *s, int reg, int ofs)
 230 {
 231     TCGv_i32 tmp = tcg_temp_new_i32();
 232
 233     if (reg == 15) {
 234         tcg_gen_movi_i32(tmp, (read_pc(s) & ~3) + ofs);
 235     } else {
 236         tcg_gen_addi_i32(tmp, cpu_R[reg], ofs);
 237     }
 238     return tmp;
 239 }
 240
 241 /* Set a CPU register.  The source must be a temporary and will be
 242    marked as dead.  */
 243 static void store_reg(DisasContext *s, int reg, TCGv_i32 var)
 244 {
 245     if (reg == 15) {
 246         /* In Thumb mode, we must ignore bit 0.
 247          * In ARM mode, for ARMv4 and ARMv5, it is UNPREDICTABLE if bits [1:0]
 248          * are not 0b00, but for ARMv6 and above, we must ignore bits [1:0].
 249          * We choose to ignore [1:0] in ARM mode for all architecture versions.
 250          */
 251         tcg_gen_andi_i32(var, var, s->thumb ? ~1 : ~3);
 252         s->base.is_jmp = DISAS_JUMP;
 253     }
 254     tcg_gen_mov_i32(cpu_R[reg], var);
 255     tcg_temp_free_i32(var);
 256 }
 257
 258 /*
 259  * Variant of store_reg which applies v8M stack-limit checks before updating
 260  * SP. If the check fails this will result in an exception being taken.
 261  * We disable the stack checks for CONFIG_USER_ONLY because we have
 262  * no idea what the stack limits should be in that case.
 263  * If stack checking is not being done this just acts like store_reg().
 264  */
 265 static void store_sp_checked(DisasContext *s, TCGv_i32 var)
 266 {
 267 #ifndef CONFIG_USER_ONLY
 268     if (s->v8m_stackcheck) {
 269         gen_helper_v8m_stackcheck(cpu_env, var);
 270     }
 271 #endif
 272     store_reg(s, 13, var);
 273 }
 274
 275 /* Value extensions.  */
 276 #define gen_uxtb(var) tcg_gen_ext8u_i32(var, var)
 277 #define gen_uxth(var) tcg_gen_ext16u_i32(var, var)
 278 #define gen_sxtb(var) tcg_gen_ext8s_i32(var, var)
 279 #define gen_sxth(var) tcg_gen_ext16s_i32(var, var)
 280
 281 #define gen_sxtb16(var) gen_helper_sxtb16(var, var)
 282 #define gen_uxtb16(var) gen_helper_uxtb16(var, var)
 283
 284
 285 static inline void gen_set_cpsr(TCGv_i32 var, uint32_t mask)
 286 {
 287     TCGv_i32 tmp_mask = tcg_const_i32(mask);
 288     gen_helper_cpsr_write(cpu_env, var, tmp_mask);
 289     tcg_temp_free_i32(tmp_mask);
 290 }
 291 /* Set NZCV flags from the high 4 bits of var.  */
 292 #define gen_set_nzcv(var) gen_set_cpsr(var, CPSR_NZCV)
 293
 294 static void gen_exception_internal(int excp)
 295 {
 296     TCGv_i32 tcg_excp = tcg_const_i32(excp);
 297
 298     assert(excp_is_internal(excp));
 299     gen_helper_exception_internal(cpu_env, tcg_excp);
 300     tcg_temp_free_i32(tcg_excp);
 301 }
 302
 303 static void gen_step_complete_exception(DisasContext *s)
 304 {
 305     /* We just completed step of an insn. Move from Active-not-pending
 306      * to Active-pending, and then also take the swstep exception.
 307      * This corresponds to making the (IMPDEF) choice to prioritize
 308      * swstep exceptions over asynchronous exceptions taken to an exception
 309      * level where debug is disabled. This choice has the advantage that
 310      * we do not need to maintain internal state corresponding to the
 311      * ISV/EX syndrome bits between completion of the step and generation
 312      * of the exception, and our syndrome information is always correct.
 313      */
 314     gen_ss_advance(s);
 315     gen_swstep_exception(s, 1, s->is_ldex);
 316     s->base.is_jmp = DISAS_NORETURN;
 317 }
 318
 319 static void gen_singlestep_exception(DisasContext *s)
 320 {
 321     /* Generate the right kind of exception for singlestep, which is
 322      * either the architectural singlestep or EXCP_DEBUG for QEMU's
 323      * gdb singlestepping.
 324      */
 325     if (s->ss_active) {
 326         gen_step_complete_exception(s);
 327     } else {
 328         gen_exception_internal(EXCP_DEBUG);
 329     }
 330 }
 331
 332 static inline bool is_singlestepping(DisasContext *s)
 333 {
 334     /* Return true if we are singlestepping either because of
 335      * architectural singlestep or QEMU gdbstub singlestep. This does
 336      * not include the command line '-singlestep' mode which is rather
 337      * misnamed as it only means "one instruction per TB" and doesn't
 338      * affect the code we generate.
 339      */
 340     return s->base.singlestep_enabled || s->ss_active;
 341 }
 342
 343 static void gen_smul_dual(TCGv_i32 a, TCGv_i32 b)
 344 {
 345     TCGv_i32 tmp1 = tcg_temp_new_i32();
 346     TCGv_i32 tmp2 = tcg_temp_new_i32();
 347     tcg_gen_ext16s_i32(tmp1, a);
 348     tcg_gen_ext16s_i32(tmp2, b);
 349     tcg_gen_mul_i32(tmp1, tmp1, tmp2);
 350     tcg_temp_free_i32(tmp2);
 351     tcg_gen_sari_i32(a, a, 16);
 352     tcg_gen_sari_i32(b, b, 16);
 353     tcg_gen_mul_i32(b, b, a);
 354     tcg_gen_mov_i32(a, tmp1);
 355     tcg_temp_free_i32(tmp1);
 356 }
 357
 358 /* Byteswap each halfword.  */
 359 static void gen_rev16(TCGv_i32 dest, TCGv_i32 var)
 360 {
 361     TCGv_i32 tmp = tcg_temp_new_i32();
 362     TCGv_i32 mask = tcg_const_i32(0x00ff00ff);
 363     tcg_gen_shri_i32(tmp, var, 8);
 364     tcg_gen_and_i32(tmp, tmp, mask);
 365     tcg_gen_and_i32(var, var, mask);
 366     tcg_gen_shli_i32(var, var, 8);
 367     tcg_gen_or_i32(dest, var, tmp);
 368     tcg_temp_free_i32(mask);
 369     tcg_temp_free_i32(tmp);
 370 }
 371
 372 /* Byteswap low halfword and sign extend.  */
 373 static void gen_revsh(TCGv_i32 dest, TCGv_i32 var)
 374 {
 375     tcg_gen_ext16u_i32(var, var);
 376     tcg_gen_bswap16_i32(var, var);
 377     tcg_gen_ext16s_i32(dest, var);
 378 }
 379
 380 /* 32x32->64 multiply.  Marks inputs as dead.  */
 381 static TCGv_i64 gen_mulu_i64_i32(TCGv_i32 a, TCGv_i32 b)
 382 {
 383     TCGv_i32 lo = tcg_temp_new_i32();
 384     TCGv_i32 hi = tcg_temp_new_i32();
 385     TCGv_i64 ret;
 386
 387     tcg_gen_mulu2_i32(lo, hi, a, b);
 388     tcg_temp_free_i32(a);
 389     tcg_temp_free_i32(b);
 390
 391     ret = tcg_temp_new_i64();
 392     tcg_gen_concat_i32_i64(ret, lo, hi);
 393     tcg_temp_free_i32(lo);
 394     tcg_temp_free_i32(hi);
 395
 396     return ret;
 397 }
 398
 399 static TCGv_i64 gen_muls_i64_i32(TCGv_i32 a, TCGv_i32 b)
 400 {
 401     TCGv_i32 lo = tcg_temp_new_i32();
 402     TCGv_i32 hi = tcg_temp_new_i32();
 403     TCGv_i64 ret;
 404
 405     tcg_gen_muls2_i32(lo, hi, a, b);
 406     tcg_temp_free_i32(a);
 407     tcg_temp_free_i32(b);
 408
 409     ret = tcg_temp_new_i64();
 410     tcg_gen_concat_i32_i64(ret, lo, hi);
 411     tcg_temp_free_i32(lo);
 412     tcg_temp_free_i32(hi);
 413
 414     return ret;
 415 }
 416
 417 /* Swap low and high halfwords.  */
 418 static void gen_swap_half(TCGv_i32 var)
 419 {
 420     tcg_gen_rotri_i32(var, var, 16);
 421 }
 422
 423 /* Dual 16-bit add.  Result placed in t0 and t1 is marked as dead.
 424     tmp = (t0 ^ t1) & 0x8000;
 425     t0 &= ~0x8000;
 426     t1 &= ~0x8000;
 427     t0 = (t0 + t1) ^ tmp;
 428  */
 429
 430 static void gen_add16(TCGv_i32 dest, TCGv_i32 t0, TCGv_i32 t1)
 431 {
 432     TCGv_i32 tmp = tcg_temp_new_i32();
 433     tcg_gen_xor_i32(tmp, t0, t1);
 434     tcg_gen_andi_i32(tmp, tmp, 0x8000);
 435     tcg_gen_andi_i32(t0, t0, ~0x8000);
 436     tcg_gen_andi_i32(t1, t1, ~0x8000);
 437     tcg_gen_add_i32(t0, t0, t1);
 438     tcg_gen_xor_i32(dest, t0, tmp);
 439     tcg_temp_free_i32(tmp);
 440 }
 441
 442 /* Set N and Z flags from var.  */
 443 static inline void gen_logic_CC(TCGv_i32 var)
 444 {
 445     tcg_gen_mov_i32(cpu_NF, var);
 446     tcg_gen_mov_i32(cpu_ZF, var);
 447 }
 448
 449 /* dest = T0 + T1 + CF. */
 450 static void gen_add_carry(TCGv_i32 dest, TCGv_i32 t0, TCGv_i32 t1)
 451 {
 452     tcg_gen_add_i32(dest, t0, t1);
 453     tcg_gen_add_i32(dest, dest, cpu_CF);
 454 }
 455
 456 /* dest = T0 - T1 + CF - 1.  */
 457 static void gen_sub_carry(TCGv_i32 dest, TCGv_i32 t0, TCGv_i32 t1)
 458 {
 459     tcg_gen_sub_i32(dest, t0, t1);
 460     tcg_gen_add_i32(dest, dest, cpu_CF);
 461     tcg_gen_subi_i32(dest, dest, 1);
 462 }
 463
 464 /* dest = T0 + T1. Compute C, N, V and Z flags */
 465 static void gen_add_CC(TCGv_i32 dest, TCGv_i32 t0, TCGv_i32 t1)
 466 {
 467     TCGv_i32 tmp = tcg_temp_new_i32();
 468     tcg_gen_movi_i32(tmp, 0);
 469     tcg_gen_add2_i32(cpu_NF, cpu_CF, t0, tmp, t1, tmp);
 470     tcg_gen_mov_i32(cpu_ZF, cpu_NF);
 471     tcg_gen_xor_i32(cpu_VF, cpu_NF, t0);
 472     tcg_gen_xor_i32(tmp, t0, t1);
 473     tcg_gen_andc_i32(cpu_VF, cpu_VF, tmp);
 474     tcg_temp_free_i32(tmp);
 475     tcg_gen_mov_i32(dest, cpu_NF);
 476 }
 477
 478 /* dest = T0 + T1 + CF.  Compute C, N, V and Z flags */
 479 static void gen_adc_CC(TCGv_i32 dest, TCGv_i32 t0, TCGv_i32 t1)
 480 {
 481     TCGv_i32 tmp = tcg_temp_new_i32();
 482     if (TCG_TARGET_HAS_add2_i32) {
 483         tcg_gen_movi_i32(tmp, 0);
 484         tcg_gen_add2_i32(cpu_NF, cpu_CF, t0, tmp, cpu_CF, tmp);
 485         tcg_gen_add2_i32(cpu_NF, cpu_CF, cpu_NF, cpu_CF, t1, tmp);
 486     } else {
 487         TCGv_i64 q0 = tcg_temp_new_i64();
 488         TCGv_i64 q1 = tcg_temp_new_i64();
 489         tcg_gen_extu_i32_i64(q0, t0);
 490         tcg_gen_extu_i32_i64(q1, t1);
 491         tcg_gen_add_i64(q0, q0, q1);
 492         tcg_gen_extu_i32_i64(q1, cpu_CF);
 493         tcg_gen_add_i64(q0, q0, q1);
 494         tcg_gen_extr_i64_i32(cpu_NF, cpu_CF, q0);
 495         tcg_temp_free_i64(q0);
 496         tcg_temp_free_i64(q1);
 497     }
 498     tcg_gen_mov_i32(cpu_ZF, cpu_NF);
 499     tcg_gen_xor_i32(cpu_VF, cpu_NF, t0);
 500     tcg_gen_xor_i32(tmp, t0, t1);
 501     tcg_gen_andc_i32(cpu_VF, cpu_VF, tmp);
 502     tcg_temp_free_i32(tmp);
 503     tcg_gen_mov_i32(dest, cpu_NF);
 504 }
 505
 506 /* dest = T0 - T1. Compute C, N, V and Z flags */
 507 static void gen_sub_CC(TCGv_i32 dest, TCGv_i32 t0, TCGv_i32 t1)
 508 {
 509     TCGv_i32 tmp;
 510     tcg_gen_sub_i32(cpu_NF, t0, t1);
 511     tcg_gen_mov_i32(cpu_ZF, cpu_NF);
 512     tcg_gen_setcond_i32(TCG_COND_GEU, cpu_CF, t0, t1);
 513     tcg_gen_xor_i32(cpu_VF, cpu_NF, t0);
 514     tmp = tcg_temp_new_i32();
 515     tcg_gen_xor_i32(tmp, t0, t1);
 516     tcg_gen_and_i32(cpu_VF, cpu_VF, tmp);
 517     tcg_temp_free_i32(tmp);
 518     tcg_gen_mov_i32(dest, cpu_NF);
 519 }
 520
 521 /* dest = T0 + ~T1 + CF.  Compute C, N, V and Z flags */
 522 static void gen_sbc_CC(TCGv_i32 dest, TCGv_i32 t0, TCGv_i32 t1)
 523 {
 524     TCGv_i32 tmp = tcg_temp_new_i32();
 525     tcg_gen_not_i32(tmp, t1);
 526     gen_adc_CC(dest, t0, tmp);
 527     tcg_temp_free_i32(tmp);
 528 }
 529
 530 #define GEN_SHIFT(name)                                               \
 531 static void gen_##name(TCGv_i32 dest, TCGv_i32 t0, TCGv_i32 t1)       \
 532 {                                                                     \
 533     TCGv_i32 tmp1, tmp2, tmp3;                                        \
 534     tmp1 = tcg_temp_new_i32();                                        \
 535     tcg_gen_andi_i32(tmp1, t1, 0xff);                                 \
 536     tmp2 = tcg_const_i32(0);                                          \
 537     tmp3 = tcg_const_i32(0x1f);                                       \
 538     tcg_gen_movcond_i32(TCG_COND_GTU, tmp2, tmp1, tmp3, tmp2, t0);    \
 539     tcg_temp_free_i32(tmp3);                                          \
 540     tcg_gen_andi_i32(tmp1, tmp1, 0x1f);                               \
 541     tcg_gen_##name##_i32(dest, tmp2, tmp1);                           \
 542     tcg_temp_free_i32(tmp2);                                          \
 543     tcg_temp_free_i32(tmp1);                                          \
 544 }
 545 GEN_SHIFT(shl)
 546 GEN_SHIFT(shr)
 547 #undef GEN_SHIFT
 548
 549 static void gen_sar(TCGv_i32 dest, TCGv_i32 t0, TCGv_i32 t1)
 550 {
 551     TCGv_i32 tmp1, tmp2;
 552     tmp1 = tcg_temp_new_i32();
 553     tcg_gen_andi_i32(tmp1, t1, 0xff);
 554     tmp2 = tcg_const_i32(0x1f);
 555     tcg_gen_movcond_i32(TCG_COND_GTU, tmp1, tmp1, tmp2, tmp2, tmp1);
 556     tcg_temp_free_i32(tmp2);
 557     tcg_gen_sar_i32(dest, t0, tmp1);
 558     tcg_temp_free_i32(tmp1);
 559 }
 560
 561 static void shifter_out_im(TCGv_i32 var, int shift)
 562 {
 563     tcg_gen_extract_i32(cpu_CF, var, shift, 1);
 564 }
 565
 566 /* Shift by immediate.  Includes special handling for shift == 0.  */
 567 static inline void gen_arm_shift_im(TCGv_i32 var, int shiftop,
 568                                     int shift, int flags)
 569 {
 570     switch (shiftop) {
 571     case 0: /* LSL */
 572         if (shift != 0) {
 573             if (flags)
 574                 shifter_out_im(var, 32 - shift);
 575             tcg_gen_shli_i32(var, var, shift);
 576         }
 577         break;
 578     case 1: /* LSR */
 579         if (shift == 0) {
 580             if (flags) {
 581                 tcg_gen_shri_i32(cpu_CF, var, 31);
 582             }
 583             tcg_gen_movi_i32(var, 0);
 584         } else {
 585             if (flags)
 586                 shifter_out_im(var, shift - 1);
 587             tcg_gen_shri_i32(var, var, shift);
 588         }
 589         break;
 590     case 2: /* ASR */
 591         if (shift == 0)
 592             shift = 32;
 593         if (flags)
 594             shifter_out_im(var, shift - 1);
 595         if (shift == 32)
 596           shift = 31;
 597         tcg_gen_sari_i32(var, var, shift);
 598         break;
 599     case 3: /* ROR/RRX */
 600         if (shift != 0) {
 601             if (flags)
 602                 shifter_out_im(var, shift - 1);
 603             tcg_gen_rotri_i32(var, var, shift); break;
 604         } else {
 605             TCGv_i32 tmp = tcg_temp_new_i32();
 606             tcg_gen_shli_i32(tmp, cpu_CF, 31);
 607             if (flags)
 608                 shifter_out_im(var, 0);
 609             tcg_gen_shri_i32(var, var, 1);
 610             tcg_gen_or_i32(var, var, tmp);
 611             tcg_temp_free_i32(tmp);
 612         }
 613     }
 614 };
 615
 616 static inline void gen_arm_shift_reg(TCGv_i32 var, int shiftop,
 617                                      TCGv_i32 shift, int flags)
 618 {
 619     if (flags) {
 620         switch (shiftop) {
 621         case 0: gen_helper_shl_cc(var, cpu_env, var, shift); break;
 622         case 1: gen_helper_shr_cc(var, cpu_env, var, shift); break;
 623         case 2: gen_helper_sar_cc(var, cpu_env, var, shift); break;
 624         case 3: gen_helper_ror_cc(var, cpu_env, var, shift); break;
 625         }
 626     } else {
 627         switch (shiftop) {
 628         case 0:
 629             gen_shl(var, var, shift);
 630             break;
 631         case 1:
 632             gen_shr(var, var, shift);
 633             break;
 634         case 2:
 635             gen_sar(var, var, shift);
 636             break;
 637         case 3: tcg_gen_andi_i32(shift, shift, 0x1f);
 638                 tcg_gen_rotr_i32(var, var, shift); break;
 639         }
 640     }
 641     tcg_temp_free_i32(shift);
 642 }
 643
 644 /*
 645  * Generate a conditional based on ARM condition code cc.
 646  * This is common between ARM and Aarch64 targets.
 647  */
 648 void arm_test_cc(DisasCompare *cmp, int cc)
 649 {
 650     TCGv_i32 value;
 651     TCGCond cond;
 652     bool global = true;
 653
 654     switch (cc) {
 655     case 0: /* eq: Z */
 656     case 1: /* ne: !Z */
 657         cond = TCG_COND_EQ;
 658         value = cpu_ZF;
 659         break;
 660
 661     case 2: /* cs: C */
 662     case 3: /* cc: !C */
 663         cond = TCG_COND_NE;
 664         value = cpu_CF;
 665         break;
 666
 667     case 4: /* mi: N */
 668     case 5: /* pl: !N */
 669         cond = TCG_COND_LT;
 670         value = cpu_NF;
 671         break;
 672
 673     case 6: /* vs: V */
 674     case 7: /* vc: !V */
 675         cond = TCG_COND_LT;
 676         value = cpu_VF;
 677         break;
 678
 679     case 8: /* hi: C && !Z */
 680     case 9: /* ls: !C || Z -> !(C && !Z) */
 681         cond = TCG_COND_NE;
 682         value = tcg_temp_new_i32();
 683         global = false;
 684         /* CF is 1 for C, so -CF is an all-bits-set mask for C;
 685            ZF is non-zero for !Z; so AND the two subexpressions.  */
 686         tcg_gen_neg_i32(value, cpu_CF);
 687         tcg_gen_and_i32(value, value, cpu_ZF);
 688         break;
 689
 690     case 10: /* ge: N == V -> N ^ V == 0 */
 691     case 11: /* lt: N != V -> N ^ V != 0 */
 692         /* Since we're only interested in the sign bit, == 0 is >= 0.  */
 693         cond = TCG_COND_GE;
 694         value = tcg_temp_new_i32();
 695         global = false;
 696         tcg_gen_xor_i32(value, cpu_VF, cpu_NF);
 697         break;
 698
 699     case 12: /* gt: !Z && N == V */
 700     case 13: /* le: Z || N != V */
 701         cond = TCG_COND_NE;
 702         value = tcg_temp_new_i32();
 703         global = false;
 704         /* (N == V) is equal to the sign bit of ~(NF ^ VF).  Propagate
 705          * the sign bit then AND with ZF to yield the result.  */
 706         tcg_gen_xor_i32(value, cpu_VF, cpu_NF);
 707         tcg_gen_sari_i32(value, value, 31);
 708         tcg_gen_andc_i32(value, cpu_ZF, value);
 709         break;
 710
 711     case 14: /* always */
 712     case 15: /* always */
 713         /* Use the ALWAYS condition, which will fold early.
 714          * It doesn't matter what we use for the value.  */
 715         cond = TCG_COND_ALWAYS;
 716         value = cpu_ZF;
 717         goto no_invert;
 718
 719     default:
 720         fprintf(stderr, "Bad condition code 0x%x\n", cc);
 721         abort();
 722     }
 723
 724     if (cc & 1) {
 725         cond = tcg_invert_cond(cond);
 726     }
 727
 728  no_invert:
 729     cmp->cond = cond;
 730     cmp->value = value;
 731     cmp->value_global = global;
 732 }
 733
 734 void arm_free_cc(DisasCompare *cmp)
 735 {
 736     if (!cmp->value_global) {
 737         tcg_temp_free_i32(cmp->value);
 738     }
 739 }
 740
 741 void arm_jump_cc(DisasCompare *cmp, TCGLabel *label)
 742 {
 743     tcg_gen_brcondi_i32(cmp->cond, cmp->value, 0, label);
 744 }
 745
 746 void arm_gen_test_cc(int cc, TCGLabel *label)
 747 {
 748     DisasCompare cmp;
 749     arm_test_cc(&cmp, cc);
 750     arm_jump_cc(&cmp, label);
 751     arm_free_cc(&cmp);
 752 }
 753
 754 static inline void gen_set_condexec(DisasContext *s)
 755 {
 756     if (s->condexec_mask) {
 757         uint32_t val = (s->condexec_cond << 4) | (s->condexec_mask >> 1);
 758         TCGv_i32 tmp = tcg_temp_new_i32();
 759         tcg_gen_movi_i32(tmp, val);
 760         store_cpu_field(tmp, condexec_bits);
 761     }
 762 }
 763
 764 static inline void gen_set_pc_im(DisasContext *s, target_ulong val)
 765 {
 766     tcg_gen_movi_i32(cpu_R[15], val);
 767 }
 768
 769 /* Set PC and Thumb state from var.  var is marked as dead.  */
 770 static inline void gen_bx(DisasContext *s, TCGv_i32 var)
 771 {
 772     s->base.is_jmp = DISAS_JUMP;
 773     tcg_gen_andi_i32(cpu_R[15], var, ~1);
 774     tcg_gen_andi_i32(var, var, 1);
 775     store_cpu_field(var, thumb);
 776 }
 777
 778 /*
 779  * Set PC and Thumb state from var. var is marked as dead.
 780  * For M-profile CPUs, include logic to detect exception-return
 781  * branches and handle them. This is needed for Thumb POP/LDM to PC, LDR to PC,
 782  * and BX reg, and no others, and happens only for code in Handler mode.
 783  * The Security Extension also requires us to check for the FNC_RETURN
 784  * which signals a function return from non-secure state; this can happen
 785  * in both Handler and Thread mode.
 786  * To avoid having to do multiple comparisons in inline generated code,
 787  * we make the check we do here loose, so it will match for EXC_RETURN
 788  * in Thread mode. For system emulation do_v7m_exception_exit() checks
 789  * for these spurious cases and returns without doing anything (giving
 790  * the same behaviour as for a branch to a non-magic address).
 791  *
 792  * In linux-user mode it is unclear what the right behaviour for an
 793  * attempted FNC_RETURN should be, because in real hardware this will go
 794  * directly to Secure code (ie not the Linux kernel) which will then treat
 795  * the error in any way it chooses. For QEMU we opt to make the FNC_RETURN
 796  * attempt behave the way it would on a CPU without the security extension,
 797  * which is to say "like a normal branch". That means we can simply treat
 798  * all branches as normal with no magic address behaviour.
 799  */
 800 static inline void gen_bx_excret(DisasContext *s, TCGv_i32 var)
 801 {
 802     /* Generate the same code here as for a simple bx, but flag via
 803      * s->base.is_jmp that we need to do the rest of the work later.
 804      */
 805     gen_bx(s, var);
 806 #ifndef CONFIG_USER_ONLY
 807     if (arm_dc_feature(s, ARM_FEATURE_M_SECURITY) ||
 808         (s->v7m_handler_mode && arm_dc_feature(s, ARM_FEATURE_M))) {
 809         s->base.is_jmp = DISAS_BX_EXCRET;
 810     }
 811 #endif
 812 }
 813
 814 static inline void gen_bx_excret_final_code(DisasContext *s)
 815 {
 816     /* Generate the code to finish possible exception return and end the TB */
 817     TCGLabel *excret_label = gen_new_label();
 818     uint32_t min_magic;
 819
 820     if (arm_dc_feature(s, ARM_FEATURE_M_SECURITY)) {
 821         /* Covers FNC_RETURN and EXC_RETURN magic */
 822         min_magic = FNC_RETURN_MIN_MAGIC;
 823     } else {
 824         /* EXC_RETURN magic only */
 825         min_magic = EXC_RETURN_MIN_MAGIC;
 826     }
 827
 828     /* Is the new PC value in the magic range indicating exception return? */
 829     tcg_gen_brcondi_i32(TCG_COND_GEU, cpu_R[15], min_magic, excret_label);
 830     /* No: end the TB as we would for a DISAS_JMP */
 831     if (is_singlestepping(s)) {
 832         gen_singlestep_exception(s);
 833     } else {
 834         tcg_gen_exit_tb(NULL, 0);
 835     }
 836     gen_set_label(excret_label);
 837     /* Yes: this is an exception return.
 838      * At this point in runtime env->regs[15] and env->thumb will hold
 839      * the exception-return magic number, which do_v7m_exception_exit()
 840      * will read. Nothing else will be able to see those values because
 841      * the cpu-exec main loop guarantees that we will always go straight
 842      * from raising the exception to the exception-handling code.
 843      *
 844      * gen_ss_advance(s) does nothing on M profile currently but
 845      * calling it is conceptually the right thing as we have executed
 846      * this instruction (compare SWI, HVC, SMC handling).
 847      */
 848     gen_ss_advance(s);
 849     gen_exception_internal(EXCP_EXCEPTION_EXIT);
 850 }
 851
 852 static inline void gen_bxns(DisasContext *s, int rm)
 853 {
 854     TCGv_i32 var = load_reg(s, rm);
 855
 856     /* The bxns helper may raise an EXCEPTION_EXIT exception, so in theory
 857      * we need to sync state before calling it, but:
 858      *  - we don't need to do gen_set_pc_im() because the bxns helper will
 859      *    always set the PC itself
 860      *  - we don't need to do gen_set_condexec() because BXNS is UNPREDICTABLE
 861      *    unless it's outside an IT block or the last insn in an IT block,
 862      *    so we know that condexec == 0 (already set at the top of the TB)
 863      *    is correct in the non-UNPREDICTABLE cases, and we can choose
 864      *    "zeroes the IT bits" as our UNPREDICTABLE behaviour otherwise.
 865      */
 866     gen_helper_v7m_bxns(cpu_env, var);
 867     tcg_temp_free_i32(var);
 868     s->base.is_jmp = DISAS_EXIT;
 869 }
 870
 871 static inline void gen_blxns(DisasContext *s, int rm)
 872 {
 873     TCGv_i32 var = load_reg(s, rm);
 874
 875     /* We don't need to sync condexec state, for the same reason as bxns.
 876      * We do however need to set the PC, because the blxns helper reads it.
 877      * The blxns helper may throw an exception.
 878      */
 879     gen_set_pc_im(s, s->base.pc_next);
 880     gen_helper_v7m_blxns(cpu_env, var);
 881     tcg_temp_free_i32(var);
 882     s->base.is_jmp = DISAS_EXIT;
 883 }
 884
 885 /* Variant of store_reg which uses branch&exchange logic when storing
 886    to r15 in ARM architecture v7 and above. The source must be a temporary
 887    and will be marked as dead. */
 888 static inline void store_reg_bx(DisasContext *s, int reg, TCGv_i32 var)
 889 {
 890     if (reg == 15 && ENABLE_ARCH_7) {
 891         gen_bx(s, var);
 892     } else {
 893         store_reg(s, reg, var);
 894     }
 895 }
 896
 897 /* Variant of store_reg which uses branch&exchange logic when storing
 898  * to r15 in ARM architecture v5T and above. This is used for storing
 899  * the results of a LDR/LDM/POP into r15, and corresponds to the cases
 900  * in the ARM ARM which use the LoadWritePC() pseudocode function. */
 901 static inline void store_reg_from_load(DisasContext *s, int reg, TCGv_i32 var)
 902 {
 903     if (reg == 15 && ENABLE_ARCH_5) {
 904         gen_bx_excret(s, var);
 905     } else {
 906         store_reg(s, reg, var);
 907     }
 908 }
 909
 910 #ifdef CONFIG_USER_ONLY
 911 #define IS_USER_ONLY 1
 912 #else
 913 #define IS_USER_ONLY 0
 914 #endif
 915
 916 /* Abstractions of "generate code to do a guest load/store for
 917  * AArch32", where a vaddr is always 32 bits (and is zero
 918  * extended if we're a 64 bit core) and  data is also
 919  * 32 bits unless specifically doing a 64 bit access.
 920  * These functions work like tcg_gen_qemu_{ld,st}* except
 921  * that the address argument is TCGv_i32 rather than TCGv.
 922  */
 923
 924 static inline TCGv gen_aa32_addr(DisasContext *s, TCGv_i32 a32, MemOp op)
 925 {
 926     TCGv addr = tcg_temp_new();
 927     tcg_gen_extu_i32_tl(addr, a32);
 928
 929     /* Not needed for user-mode BE32, where we use MO_BE instead.  */
 930     if (!IS_USER_ONLY && s->sctlr_b && (op & MO_SIZE) < MO_32) {
 931         tcg_gen_xori_tl(addr, addr, 4 - (1 << (op & MO_SIZE)));
 932     }
 933     return addr;
 934 }
 935
 936 static void gen_aa32_ld_i32(DisasContext *s, TCGv_i32 val, TCGv_i32 a32,
 937                             int index, MemOp opc)
 938 {
 939     TCGv addr;
 940
 941     if (arm_dc_feature(s, ARM_FEATURE_M) &&
 942         !arm_dc_feature(s, ARM_FEATURE_M_MAIN)) {
 943         opc |= MO_ALIGN;
 944     }
 945
 946     addr = gen_aa32_addr(s, a32, opc);
 947     tcg_gen_qemu_ld_i32(val, addr, index, opc);
 948     tcg_temp_free(addr);
 949 }
 950
 951 static void gen_aa32_st_i32(DisasContext *s, TCGv_i32 val, TCGv_i32 a32,
 952                             int index, MemOp opc)
 953 {
 954     TCGv addr;
 955
 956     if (arm_dc_feature(s, ARM_FEATURE_M) &&
 957         !arm_dc_feature(s, ARM_FEATURE_M_MAIN)) {
 958         opc |= MO_ALIGN;
 959     }
 960
 961     addr = gen_aa32_addr(s, a32, opc);
 962     tcg_gen_qemu_st_i32(val, addr, index, opc);
 963     tcg_temp_free(addr);
 964 }
 965
 966 #define DO_GEN_LD(SUFF, OPC)                                             \
 967 static inline void gen_aa32_ld##SUFF(DisasContext *s, TCGv_i32 val,      \
 968                                      TCGv_i32 a32, int index)            \
 969 {                                                                        \
 970     gen_aa32_ld_i32(s, val, a32, index, OPC | s->be_data);               \
 971 }
 972
 973 #define DO_GEN_ST(SUFF, OPC)                                             \
 974 static inline void gen_aa32_st##SUFF(DisasContext *s, TCGv_i32 val,      \
 975                                      TCGv_i32 a32, int index)            \
 976 {                                                                        \
 977     gen_aa32_st_i32(s, val, a32, index, OPC | s->be_data);               \
 978 }
 979
 980 static inline void gen_aa32_frob64(DisasContext *s, TCGv_i64 val)
 981 {
 982     /* Not needed for user-mode BE32, where we use MO_BE instead.  */
 983     if (!IS_USER_ONLY && s->sctlr_b) {
 984         tcg_gen_rotri_i64(val, val, 32);
 985     }
 986 }
 987
 988 static void gen_aa32_ld_i64(DisasContext *s, TCGv_i64 val, TCGv_i32 a32,
 989                             int index, MemOp opc)
 990 {
 991     TCGv addr = gen_aa32_addr(s, a32, opc);
 992     tcg_gen_qemu_ld_i64(val, addr, index, opc);
 993     gen_aa32_frob64(s, val);
 994     tcg_temp_free(addr);
 995 }
 996
 997 static inline void gen_aa32_ld64(DisasContext *s, TCGv_i64 val,
 998                                  TCGv_i32 a32, int index)
 999 {
1000     gen_aa32_ld_i64(s, val, a32, index, MO_Q | s->be_data);
1001 }
1002
1003 static void gen_aa32_st_i64(DisasContext *s, TCGv_i64 val, TCGv_i32 a32,
1004                             int index, MemOp opc)
1005 {
1006     TCGv addr = gen_aa32_addr(s, a32, opc);
1007
1008     /* Not needed for user-mode BE32, where we use MO_BE instead.  */
1009     if (!IS_USER_ONLY && s->sctlr_b) {
1010         TCGv_i64 tmp = tcg_temp_new_i64();
1011         tcg_gen_rotri_i64(tmp, val, 32);
1012         tcg_gen_qemu_st_i64(tmp, addr, index, opc);
1013         tcg_temp_free_i64(tmp);
1014     } else {
1015         tcg_gen_qemu_st_i64(val, addr, index, opc);
1016     }
1017     tcg_temp_free(addr);
1018 }
1019
1020 static inline void gen_aa32_st64(DisasContext *s, TCGv_i64 val,
1021                                  TCGv_i32 a32, int index)
1022 {
1023     gen_aa32_st_i64(s, val, a32, index, MO_Q | s->be_data);
1024 }
1025
1026 DO_GEN_LD(8u, MO_UB)
1027 DO_GEN_LD(16u, MO_UW)
1028 DO_GEN_LD(32u, MO_UL)
1029 DO_GEN_ST(8, MO_UB)
1030 DO_GEN_ST(16, MO_UW)
1031 DO_GEN_ST(32, MO_UL)
1032
1033 static inline void gen_hvc(DisasContext *s, int imm16)
1034 {
1035     /* The pre HVC helper handles cases when HVC gets trapped
1036      * as an undefined insn by runtime configuration (ie before
1037      * the insn really executes).
1038      */
1039     gen_set_pc_im(s, s->pc_curr);
1040     gen_helper_pre_hvc(cpu_env);
1041     /* Otherwise we will treat this as a real exception which
1042      * happens after execution of the insn. (The distinction matters
1043      * for the PC value reported to the exception handler and also
1044      * for single stepping.)
1045      */
1046     s->svc_imm = imm16;
1047     gen_set_pc_im(s, s->base.pc_next);
1048     s->base.is_jmp = DISAS_HVC;
1049 }
1050
1051 static inline void gen_smc(DisasContext *s)
1052 {
1053     /* As with HVC, we may take an exception either before or after
1054      * the insn executes.
1055      */
1056     TCGv_i32 tmp;
1057
1058     gen_set_pc_im(s, s->pc_curr);
1059     tmp = tcg_const_i32(syn_aa32_smc());
1060     gen_helper_pre_smc(cpu_env, tmp);
1061     tcg_temp_free_i32(tmp);
1062     gen_set_pc_im(s, s->base.pc_next);
1063     s->base.is_jmp = DISAS_SMC;
1064 }
1065
1066 static void gen_exception_internal_insn(DisasContext *s, uint32_t pc, int excp)
1067 {
1068     gen_set_condexec(s);
1069     gen_set_pc_im(s, pc);
1070     gen_exception_internal(excp);
1071     s->base.is_jmp = DISAS_NORETURN;
1072 }
1073
1074 static void gen_exception_insn(DisasContext *s, uint32_t pc, int excp,
1075                                int syn, uint32_t target_el)
1076 {
1077     gen_set_condexec(s);
1078     gen_set_pc_im(s, pc);
1079     gen_exception(excp, syn, target_el);
1080     s->base.is_jmp = DISAS_NORETURN;
1081 }
1082
1083 static void gen_exception_bkpt_insn(DisasContext *s, uint32_t syn)
1084 {
1085     TCGv_i32 tcg_syn;
1086
1087     gen_set_condexec(s);
1088     gen_set_pc_im(s, s->pc_curr);
1089     tcg_syn = tcg_const_i32(syn);
1090     gen_helper_exception_bkpt_insn(cpu_env, tcg_syn);
1091     tcg_temp_free_i32(tcg_syn);
1092     s->base.is_jmp = DISAS_NORETURN;
1093 }
1094
1095 static void unallocated_encoding(DisasContext *s)
1096 {
1097     /* Unallocated and reserved encodings are uncategorized */
1098     gen_exception_insn(s, s->pc_curr, EXCP_UDEF, syn_uncategorized(),
1099                        default_exception_el(s));
1100 }
1101
1102 /* Force a TB lookup after an instruction that changes the CPU state.  */
1103 static inline void gen_lookup_tb(DisasContext *s)
1104 {
1105     tcg_gen_movi_i32(cpu_R[15], s->base.pc_next);
1106     s->base.is_jmp = DISAS_EXIT;
1107 }
1108
1109 static inline void gen_hlt(DisasContext *s, int imm)
1110 {
1111     /* HLT. This has two purposes.
1112      * Architecturally, it is an external halting debug instruction.
1113      * Since QEMU doesn't implement external debug, we treat this as
1114      * it is required for halting debug disabled: it will UNDEF.
1115      * Secondly, "HLT 0x3C" is a T32 semihosting trap instruction,
1116      * and "HLT 0xF000" is an A32 semihosting syscall. These traps
1117      * must trigger semihosting even for ARMv7 and earlier, where
1118      * HLT was an undefined encoding.
1119      * In system mode, we don't allow userspace access to
1120      * semihosting, to provide some semblance of security
1121      * (and for consistency with our 32-bit semihosting).
1122      */
1123     if (semihosting_enabled() &&
1124 #ifndef CONFIG_USER_ONLY
1125         s->current_el != 0 &&
1126 #endif
1127         (imm == (s->thumb ? 0x3c : 0xf000))) {
1128         gen_exception_internal_insn(s, s->pc_curr, EXCP_SEMIHOST);
1129         return;
1130     }
1131
1132     unallocated_encoding(s);
1133 }
1134
1135 static TCGv_ptr get_fpstatus_ptr(int neon)
1136 {
1137     TCGv_ptr statusptr = tcg_temp_new_ptr();
1138     int offset;
1139     if (neon) {
1140         offset = offsetof(CPUARMState, vfp.standard_fp_status);
1141     } else {
1142         offset = offsetof(CPUARMState, vfp.fp_status);
1143     }
1144     tcg_gen_addi_ptr(statusptr, cpu_env, offset);
1145     return statusptr;
1146 }
1147
1148 static inline long vfp_reg_offset(bool dp, unsigned reg)
1149 {
1150     if (dp) {
1151         return offsetof(CPUARMState, vfp.zregs[reg >> 1].d[reg & 1]);
1152     } else {
1153         long ofs = offsetof(CPUARMState, vfp.zregs[reg >> 2].d[(reg >> 1) & 1]);
1154         if (reg & 1) {
1155             ofs += offsetof(CPU_DoubleU, l.upper);
1156         } else {
1157             ofs += offsetof(CPU_DoubleU, l.lower);
1158         }
1159         return ofs;
1160     }
1161 }
1162
1163 /* Return the offset of a 32-bit piece of a NEON register.
1164    zero is the least significant end of the register.  */
1165 static inline long
1166 neon_reg_offset (int reg, int n)
1167 {
1168     int sreg;
1169     sreg = reg * 2 + n;
1170     return vfp_reg_offset(0, sreg);
1171 }
1172
1173 /* Return the offset of a 2**SIZE piece of a NEON register, at index ELE,
1174  * where 0 is the least significant end of the register.
1175  */
1176 static inline long
1177 neon_element_offset(int reg, int element, MemOp size)
1178 {
1179     int element_size = 1 << size;
1180     int ofs = element * element_size;
1181 #ifdef HOST_WORDS_BIGENDIAN
1182     /* Calculate the offset assuming fully little-endian,
1183      * then XOR to account for the order of the 8-byte units.
1184      */
1185     if (element_size < 8) {
1186         ofs ^= 8 - element_size;
1187     }
1188 #endif
1189     return neon_reg_offset(reg, 0) + ofs;
1190 }
1191
1192 static TCGv_i32 neon_load_reg(int reg, int pass)
1193 {
1194     TCGv_i32 tmp = tcg_temp_new_i32();
1195     tcg_gen_ld_i32(tmp, cpu_env, neon_reg_offset(reg, pass));
1196     return tmp;
1197 }
1198
1199 static void neon_load_element(TCGv_i32 var, int reg, int ele, MemOp mop)
1200 {
1201     long offset = neon_element_offset(reg, ele, mop & MO_SIZE);
1202
1203     switch (mop) {
1204     case MO_UB:
1205         tcg_gen_ld8u_i32(var, cpu_env, offset);
1206         break;
1207     case MO_UW:
1208         tcg_gen_ld16u_i32(var, cpu_env, offset);
1209         break;
1210     case MO_UL:
1211         tcg_gen_ld_i32(var, cpu_env, offset);
1212         break;
1213     default:
1214         g_assert_not_reached();
1215     }
1216 }
1217
1218 static void neon_load_element64(TCGv_i64 var, int reg, int ele, MemOp mop)
1219 {
1220     long offset = neon_element_offset(reg, ele, mop & MO_SIZE);
1221
1222     switch (mop) {
1223     case MO_UB:
1224         tcg_gen_ld8u_i64(var, cpu_env, offset);
1225         break;
1226     case MO_UW:
1227         tcg_gen_ld16u_i64(var, cpu_env, offset);
1228         break;
1229     case MO_UL:
1230         tcg_gen_ld32u_i64(var, cpu_env, offset);
1231         break;
1232     case MO_Q:
1233         tcg_gen_ld_i64(var, cpu_env, offset);
1234         break;
1235     default:
1236         g_assert_not_reached();
1237     }
1238 }
1239
1240 static void neon_store_reg(int reg, int pass, TCGv_i32 var)
1241 {
1242     tcg_gen_st_i32(var, cpu_env, neon_reg_offset(reg, pass));
1243     tcg_temp_free_i32(var);
1244 }
1245
1246 static void neon_store_element(int reg, int ele, MemOp size, TCGv_i32 var)
1247 {
1248     long offset = neon_element_offset(reg, ele, size);
1249
1250     switch (size) {
1251     case MO_8:
1252         tcg_gen_st8_i32(var, cpu_env, offset);
1253         break;
1254     case MO_16:
1255         tcg_gen_st16_i32(var, cpu_env, offset);
1256         break;
1257     case MO_32:
1258         tcg_gen_st_i32(var, cpu_env, offset);
1259         break;
1260     default:
1261         g_assert_not_reached();
1262     }
1263 }
1264
1265 static void neon_store_element64(int reg, int ele, MemOp size, TCGv_i64 var)
1266 {
1267     long offset = neon_element_offset(reg, ele, size);
1268
1269     switch (size) {
1270     case MO_8:
1271         tcg_gen_st8_i64(var, cpu_env, offset);
1272         break;
1273     case MO_16:
1274         tcg_gen_st16_i64(var, cpu_env, offset);
1275         break;
1276     case MO_32:
1277         tcg_gen_st32_i64(var, cpu_env, offset);
1278         break;
1279     case MO_64:
1280         tcg_gen_st_i64(var, cpu_env, offset);
1281         break;
1282     default:
1283         g_assert_not_reached();
1284     }
1285 }
1286
1287 static inline void neon_load_reg64(TCGv_i64 var, int reg)
1288 {
1289     tcg_gen_ld_i64(var, cpu_env, vfp_reg_offset(1, reg));
1290 }
1291
1292 static inline void neon_store_reg64(TCGv_i64 var, int reg)
1293 {
1294     tcg_gen_st_i64(var, cpu_env, vfp_reg_offset(1, reg));
1295 }
1296
1297 static inline void neon_load_reg32(TCGv_i32 var, int reg)
1298 {
1299     tcg_gen_ld_i32(var, cpu_env, vfp_reg_offset(false, reg));
1300 }
1301
1302 static inline void neon_store_reg32(TCGv_i32 var, int reg)
1303 {
1304     tcg_gen_st_i32(var, cpu_env, vfp_reg_offset(false, reg));
1305 }
1306
1307 static TCGv_ptr vfp_reg_ptr(bool dp, int reg)
1308 {
1309     TCGv_ptr ret = tcg_temp_new_ptr();
1310     tcg_gen_addi_ptr(ret, cpu_env, vfp_reg_offset(dp, reg));
1311     return ret;
1312 }
1313
1314 #define ARM_CP_RW_BIT   (1 << 20)
1315
1316 /* Include the VFP and Neon decoders */
1317 #include "translate-vfp.inc.c"
1318 #include "translate-neon.inc.c"
1319
1320 static inline void iwmmxt_load_reg(TCGv_i64 var, int reg)
1321 {
1322     tcg_gen_ld_i64(var, cpu_env, offsetof(CPUARMState, iwmmxt.regs[reg]));
1323 }
1324
1325 static inline void iwmmxt_store_reg(TCGv_i64 var, int reg)
1326 {
1327     tcg_gen_st_i64(var, cpu_env, offsetof(CPUARMState, iwmmxt.regs[reg]));
1328 }
1329
1330 static inline TCGv_i32 iwmmxt_load_creg(int reg)
1331 {
1332     TCGv_i32 var = tcg_temp_new_i32();
1333     tcg_gen_ld_i32(var, cpu_env, offsetof(CPUARMState, iwmmxt.cregs[reg]));
1334     return var;
1335 }
1336
1337 static inline void iwmmxt_store_creg(int reg, TCGv_i32 var)
1338 {
1339     tcg_gen_st_i32(var, cpu_env, offsetof(CPUARMState, iwmmxt.cregs[reg]));
1340     tcg_temp_free_i32(var);
1341 }
1342
1343 static inline void gen_op_iwmmxt_movq_wRn_M0(int rn)
1344 {
1345     iwmmxt_store_reg(cpu_M0, rn);
1346 }
1347
1348 static inline void gen_op_iwmmxt_movq_M0_wRn(int rn)
1349 {
1350     iwmmxt_load_reg(cpu_M0, rn);
1351 }
1352
1353 static inline void gen_op_iwmmxt_orq_M0_wRn(int rn)
1354 {
1355     iwmmxt_load_reg(cpu_V1, rn);
1356     tcg_gen_or_i64(cpu_M0, cpu_M0, cpu_V1);
1357 }
1358
1359 static inline void gen_op_iwmmxt_andq_M0_wRn(int rn)
1360 {
1361     iwmmxt_load_reg(cpu_V1, rn);
1362     tcg_gen_and_i64(cpu_M0, cpu_M0, cpu_V1);
1363 }
1364
1365 static inline void gen_op_iwmmxt_xorq_M0_wRn(int rn)
1366 {
1367     iwmmxt_load_reg(cpu_V1, rn);
1368     tcg_gen_xor_i64(cpu_M0, cpu_M0, cpu_V1);
1369 }
1370
1371 #define IWMMXT_OP(name) \
1372 static inline void gen_op_iwmmxt_##name##_M0_wRn(int rn) \
1373 { \
1374     iwmmxt_load_reg(cpu_V1, rn); \
1375     gen_helper_iwmmxt_##name(cpu_M0, cpu_M0, cpu_V1); \
1376 }
1377
1378 #define IWMMXT_OP_ENV(name) \
1379 static inline void gen_op_iwmmxt_##name##_M0_wRn(int rn) \
1380 { \
1381     iwmmxt_load_reg(cpu_V1, rn); \
1382     gen_helper_iwmmxt_##name(cpu_M0, cpu_env, cpu_M0, cpu_V1); \
1383 }
1384
1385 #define IWMMXT_OP_ENV_SIZE(name) \
1386 IWMMXT_OP_ENV(name##b) \
1387 IWMMXT_OP_ENV(name##w) \
1388 IWMMXT_OP_ENV(name##l)
1389
1390 #define IWMMXT_OP_ENV1(name) \
1391 static inline void gen_op_iwmmxt_##name##_M0(void) \
1392 { \
1393     gen_helper_iwmmxt_##name(cpu_M0, cpu_env, cpu_M0); \
1394 }
1395
1396 IWMMXT_OP(maddsq)
1397 IWMMXT_OP(madduq)
1398 IWMMXT_OP(sadb)
1399 IWMMXT_OP(sadw)
1400 IWMMXT_OP(mulslw)
1401 IWMMXT_OP(mulshw)
1402 IWMMXT_OP(mululw)
1403 IWMMXT_OP(muluhw)
1404 IWMMXT_OP(macsw)
1405 IWMMXT_OP(macuw)
1406
1407 IWMMXT_OP_ENV_SIZE(unpackl)
1408 IWMMXT_OP_ENV_SIZE(unpackh)
1409
1410 IWMMXT_OP_ENV1(unpacklub)
1411 IWMMXT_OP_ENV1(unpackluw)
1412 IWMMXT_OP_ENV1(unpacklul)
1413 IWMMXT_OP_ENV1(unpackhub)
1414 IWMMXT_OP_ENV1(unpackhuw)
1415 IWMMXT_OP_ENV1(unpackhul)
1416 IWMMXT_OP_ENV1(unpacklsb)
1417 IWMMXT_OP_ENV1(unpacklsw)
1418 IWMMXT_OP_ENV1(unpacklsl)
1419 IWMMXT_OP_ENV1(unpackhsb)
1420 IWMMXT_OP_ENV1(unpackhsw)
1421 IWMMXT_OP_ENV1(unpackhsl)
1422
1423 IWMMXT_OP_ENV_SIZE(cmpeq)
1424 IWMMXT_OP_ENV_SIZE(cmpgtu)
1425 IWMMXT_OP_ENV_SIZE(cmpgts)
1426
1427 IWMMXT_OP_ENV_SIZE(mins)
1428 IWMMXT_OP_ENV_SIZE(minu)
1429 IWMMXT_OP_ENV_SIZE(maxs)
1430 IWMMXT_OP_ENV_SIZE(maxu)
1431
1432 IWMMXT_OP_ENV_SIZE(subn)
1433 IWMMXT_OP_ENV_SIZE(addn)
1434 IWMMXT_OP_ENV_SIZE(subu)
1435 IWMMXT_OP_ENV_SIZE(addu)
1436 IWMMXT_OP_ENV_SIZE(subs)
1437 IWMMXT_OP_ENV_SIZE(adds)
1438
1439 IWMMXT_OP_ENV(avgb0)
1440 IWMMXT_OP_ENV(avgb1)
1441 IWMMXT_OP_ENV(avgw0)
1442 IWMMXT_OP_ENV(avgw1)
1443
1444 IWMMXT_OP_ENV(packuw)
1445 IWMMXT_OP_ENV(packul)
1446 IWMMXT_OP_ENV(packuq)
1447 IWMMXT_OP_ENV(packsw)
1448 IWMMXT_OP_ENV(packsl)
1449 IWMMXT_OP_ENV(packsq)
1450
1451 static void gen_op_iwmmxt_set_mup(void)
1452 {
1453     TCGv_i32 tmp;
1454     tmp = load_cpu_field(iwmmxt.cregs[ARM_IWMMXT_wCon]);
1455     tcg_gen_ori_i32(tmp, tmp, 2);
1456     store_cpu_field(tmp, iwmmxt.cregs[ARM_IWMMXT_wCon]);
1457 }
1458
1459 static void gen_op_iwmmxt_set_cup(void)
1460 {
1461     TCGv_i32 tmp;
1462     tmp = load_cpu_field(iwmmxt.cregs[ARM_IWMMXT_wCon]);
1463     tcg_gen_ori_i32(tmp, tmp, 1);
1464     store_cpu_field(tmp, iwmmxt.cregs[ARM_IWMMXT_wCon]);
1465 }
1466
1467 static void gen_op_iwmmxt_setpsr_nz(void)
1468 {
1469     TCGv_i32 tmp = tcg_temp_new_i32();
1470     gen_helper_iwmmxt_setpsr_nz(tmp, cpu_M0);
1471     store_cpu_field(tmp, iwmmxt.cregs[ARM_IWMMXT_wCASF]);
1472 }
1473
1474 static inline void gen_op_iwmmxt_addl_M0_wRn(int rn)
1475 {
1476     iwmmxt_load_reg(cpu_V1, rn);
1477     tcg_gen_ext32u_i64(cpu_V1, cpu_V1);
1478     tcg_gen_add_i64(cpu_M0, cpu_M0, cpu_V1);
1479 }
1480
1481 static inline int gen_iwmmxt_address(DisasContext *s, uint32_t insn,
1482                                      TCGv_i32 dest)
1483 {
1484     int rd;
1485     uint32_t offset;
1486     TCGv_i32 tmp;
1487
1488     rd = (insn >> 16) & 0xf;
1489     tmp = load_reg(s, rd);
1490
1491     offset = (insn & 0xff) << ((insn >> 7) & 2);
1492     if (insn & (1 << 24)) {
1493         /* Pre indexed */
1494         if (insn & (1 << 23))
1495             tcg_gen_addi_i32(tmp, tmp, offset);
1496         else
1497             tcg_gen_addi_i32(tmp, tmp, -offset);
1498         tcg_gen_mov_i32(dest, tmp);
1499         if (insn & (1 << 21))
1500             store_reg(s, rd, tmp);
1501         else
1502             tcg_temp_free_i32(tmp);
1503     } else if (insn & (1 << 21)) {
1504         /* Post indexed */
1505         tcg_gen_mov_i32(dest, tmp);
1506         if (insn & (1 << 23))
1507             tcg_gen_addi_i32(tmp, tmp, offset);
1508         else
1509             tcg_gen_addi_i32(tmp, tmp, -offset);
1510         store_reg(s, rd, tmp);
1511     } else if (!(insn & (1 << 23)))
1512         return 1;
1513     return 0;
1514 }
1515
1516 static inline int gen_iwmmxt_shift(uint32_t insn, uint32_t mask, TCGv_i32 dest)
1517 {
1518     int rd = (insn >> 0) & 0xf;
1519     TCGv_i32 tmp;
1520
1521     if (insn & (1 << 8)) {
1522         if (rd < ARM_IWMMXT_wCGR0 || rd > ARM_IWMMXT_wCGR3) {
1523             return 1;
1524         } else {
1525             tmp = iwmmxt_load_creg(rd);
1526         }
1527     } else {
1528         tmp = tcg_temp_new_i32();
1529         iwmmxt_load_reg(cpu_V0, rd);
1530         tcg_gen_extrl_i64_i32(tmp, cpu_V0);
1531     }
1532     tcg_gen_andi_i32(tmp, tmp, mask);
1533     tcg_gen_mov_i32(dest, tmp);
1534     tcg_temp_free_i32(tmp);
1535     return 0;
1536 }
1537
1538 /* Disassemble an iwMMXt instruction.  Returns nonzero if an error occurred
1539    (ie. an undefined instruction).  */
1540 static int disas_iwmmxt_insn(DisasContext *s, uint32_t insn)
1541 {
1542     int rd, wrd;
1543     int rdhi, rdlo, rd0, rd1, i;
1544     TCGv_i32 addr;
1545     TCGv_i32 tmp, tmp2, tmp3;
1546
1547     if ((insn & 0x0e000e00) == 0x0c000000) {
1548         if ((insn & 0x0fe00ff0) == 0x0c400000) {
1549             wrd = insn & 0xf;
1550             rdlo = (insn >> 12) & 0xf;
1551             rdhi = (insn >> 16) & 0xf;
1552             if (insn & ARM_CP_RW_BIT) {                         /* TMRRC */
1553                 iwmmxt_load_reg(cpu_V0, wrd);
1554                 tcg_gen_extrl_i64_i32(cpu_R[rdlo], cpu_V0);
1555                 tcg_gen_extrh_i64_i32(cpu_R[rdhi], cpu_V0);
1556             } else {                                    /* TMCRR */
1557                 tcg_gen_concat_i32_i64(cpu_V0, cpu_R[rdlo], cpu_R[rdhi]);
1558                 iwmmxt_store_reg(cpu_V0, wrd);
1559                 gen_op_iwmmxt_set_mup();
1560             }
1561             return 0;
1562         }
1563
1564         wrd = (insn >> 12) & 0xf;
1565         addr = tcg_temp_new_i32();
1566         if (gen_iwmmxt_address(s, insn, addr)) {
1567             tcg_temp_free_i32(addr);
1568             return 1;
1569         }
1570         if (insn & ARM_CP_RW_BIT) {
1571             if ((insn >> 28) == 0xf) {                  /* WLDRW wCx */
1572                 tmp = tcg_temp_new_i32();
1573                 gen_aa32_ld32u(s, tmp, addr, get_mem_index(s));
1574                 iwmmxt_store_creg(wrd, tmp);
1575             } else {
1576                 i = 1;
1577                 if (insn & (1 << 8)) {
1578                     if (insn & (1 << 22)) {             /* WLDRD */
1579                         gen_aa32_ld64(s, cpu_M0, addr, get_mem_index(s));
1580                         i = 0;
1581                     } else {                            /* WLDRW wRd */
1582                         tmp = tcg_temp_new_i32();
1583                         gen_aa32_ld32u(s, tmp, addr, get_mem_index(s));
1584                     }
1585                 } else {
1586                     tmp = tcg_temp_new_i32();
1587                     if (insn & (1 << 22)) {             /* WLDRH */
1588                         gen_aa32_ld16u(s, tmp, addr, get_mem_index(s));
1589                     } else {                            /* WLDRB */
1590                         gen_aa32_ld8u(s, tmp, addr, get_mem_index(s));
1591                     }
1592                 }
1593                 if (i) {
1594                     tcg_gen_extu_i32_i64(cpu_M0, tmp);
1595                     tcg_temp_free_i32(tmp);
1596                 }
1597                 gen_op_iwmmxt_movq_wRn_M0(wrd);
1598             }
1599         } else {
1600             if ((insn >> 28) == 0xf) {                  /* WSTRW wCx */
1601                 tmp = iwmmxt_load_creg(wrd);
1602                 gen_aa32_st32(s, tmp, addr, get_mem_index(s));
1603             } else {
1604                 gen_op_iwmmxt_movq_M0_wRn(wrd);
1605                 tmp = tcg_temp_new_i32();
1606                 if (insn & (1 << 8)) {
1607                     if (insn & (1 << 22)) {             /* WSTRD */
1608                         gen_aa32_st64(s, cpu_M0, addr, get_mem_index(s));
1609                     } else {                            /* WSTRW wRd */
1610                         tcg_gen_extrl_i64_i32(tmp, cpu_M0);
1611                         gen_aa32_st32(s, tmp, addr, get_mem_index(s));
1612                     }
1613                 } else {
1614                     if (insn & (1 << 22)) {             /* WSTRH */
1615                         tcg_gen_extrl_i64_i32(tmp, cpu_M0);
1616                         gen_aa32_st16(s, tmp, addr, get_mem_index(s));
1617                     } else {                            /* WSTRB */
1618                         tcg_gen_extrl_i64_i32(tmp, cpu_M0);
1619                         gen_aa32_st8(s, tmp, addr, get_mem_index(s));
1620                     }
1621                 }
1622             }
1623             tcg_temp_free_i32(tmp);
1624         }
1625         tcg_temp_free_i32(addr);
1626         return 0;
1627     }
1628
1629     if ((insn & 0x0f000000) != 0x0e000000)
1630         return 1;
1631
1632     switch (((insn >> 12) & 0xf00) | ((insn >> 4) & 0xff)) {
1633     case 0x000:                                                 /* WOR */
1634         wrd = (insn >> 12) & 0xf;
1635         rd0 = (insn >> 0) & 0xf;
1636         rd1 = (insn >> 16) & 0xf;
1637         gen_op_iwmmxt_movq_M0_wRn(rd0);
1638         gen_op_iwmmxt_orq_M0_wRn(rd1);
1639         gen_op_iwmmxt_setpsr_nz();
1640         gen_op_iwmmxt_movq_wRn_M0(wrd);
1641         gen_op_iwmmxt_set_mup();
1642         gen_op_iwmmxt_set_cup();
1643         break;
1644     case 0x011:                                                 /* TMCR */
1645         if (insn & 0xf)
1646             return 1;
1647         rd = (insn >> 12) & 0xf;
1648         wrd = (insn >> 16) & 0xf;
1649         switch (wrd) {
1650         case ARM_IWMMXT_wCID:
1651         case ARM_IWMMXT_wCASF:
1652             break;
1653         case ARM_IWMMXT_wCon:
1654             gen_op_iwmmxt_set_cup();
1655             /* Fall through.  */
1656         case ARM_IWMMXT_wCSSF:
1657             tmp = iwmmxt_load_creg(wrd);
1658             tmp2 = load_reg(s, rd);
1659             tcg_gen_andc_i32(tmp, tmp, tmp2);
1660             tcg_temp_free_i32(tmp2);
1661             iwmmxt_store_creg(wrd, tmp);
1662             break;
1663         case ARM_IWMMXT_wCGR0:
1664         case ARM_IWMMXT_wCGR1:
1665         case ARM_IWMMXT_wCGR2:
1666         case ARM_IWMMXT_wCGR3:
1667             gen_op_iwmmxt_set_cup();
1668             tmp = load_reg(s, rd);
1669             iwmmxt_store_creg(wrd, tmp);
1670             break;
1671         default:
1672             return 1;
1673         }
1674         break;
1675     case 0x100:                                                 /* WXOR */
1676         wrd = (insn >> 12) & 0xf;
1677         rd0 = (insn >> 0) & 0xf;
1678         rd1 = (insn >> 16) & 0xf;
1679         gen_op_iwmmxt_movq_M0_wRn(rd0);
1680         gen_op_iwmmxt_xorq_M0_wRn(rd1);
1681         gen_op_iwmmxt_setpsr_nz();
1682         gen_op_iwmmxt_movq_wRn_M0(wrd);
1683         gen_op_iwmmxt_set_mup();
1684         gen_op_iwmmxt_set_cup();
1685         break;
1686     case 0x111:                                                 /* TMRC */
1687         if (insn & 0xf)
1688             return 1;
1689         rd = (insn >> 12) & 0xf;
1690         wrd = (insn >> 16) & 0xf;
1691         tmp = iwmmxt_load_creg(wrd);
1692         store_reg(s, rd, tmp);
1693         break;
1694     case 0x300:                                                 /* WANDN */
1695         wrd = (insn >> 12) & 0xf;
1696         rd0 = (insn >> 0) & 0xf;
1697         rd1 = (insn >> 16) & 0xf;
1698         gen_op_iwmmxt_movq_M0_wRn(rd0);
1699         tcg_gen_neg_i64(cpu_M0, cpu_M0);
1700         gen_op_iwmmxt_andq_M0_wRn(rd1);
1701         gen_op_iwmmxt_setpsr_nz();
1702         gen_op_iwmmxt_movq_wRn_M0(wrd);
1703         gen_op_iwmmxt_set_mup();
1704         gen_op_iwmmxt_set_cup();
1705         break;
1706     case 0x200:                                                 /* WAND */
1707         wrd = (insn >> 12) & 0xf;
1708         rd0 = (insn >> 0) & 0xf;
1709         rd1 = (insn >> 16) & 0xf;
1710         gen_op_iwmmxt_movq_M0_wRn(rd0);
1711         gen_op_iwmmxt_andq_M0_wRn(rd1);
1712         gen_op_iwmmxt_setpsr_nz();
1713         gen_op_iwmmxt_movq_wRn_M0(wrd);
1714         gen_op_iwmmxt_set_mup();
1715         gen_op_iwmmxt_set_cup();
1716         break;
1717     case 0x810: case 0xa10:                             /* WMADD */
1718         wrd = (insn >> 12) & 0xf;
1719         rd0 = (insn >> 0) & 0xf;
1720         rd1 = (insn >> 16) & 0xf;
1721         gen_op_iwmmxt_movq_M0_wRn(rd0);
1722         if (insn & (1 << 21))
1723             gen_op_iwmmxt_maddsq_M0_wRn(rd1);
1724         else
1725             gen_op_iwmmxt_madduq_M0_wRn(rd1);
1726         gen_op_iwmmxt_movq_wRn_M0(wrd);
1727         gen_op_iwmmxt_set_mup();
1728         break;
1729     case 0x10e: case 0x50e: case 0x90e: case 0xd0e:     /* WUNPCKIL */
1730         wrd = (insn >> 12) & 0xf;
1731         rd0 = (insn >> 16) & 0xf;
1732         rd1 = (insn >> 0) & 0xf;
1733         gen_op_iwmmxt_movq_M0_wRn(rd0);
1734         switch ((insn >> 22) & 3) {
1735         case 0:
1736             gen_op_iwmmxt_unpacklb_M0_wRn(rd1);
1737             break;
1738         case 1:
1739             gen_op_iwmmxt_unpacklw_M0_wRn(rd1);
1740             break;
1741         case 2:
1742             gen_op_iwmmxt_unpackll_M0_wRn(rd1);
1743             break;
1744         case 3:
1745             return 1;
1746         }
1747         gen_op_iwmmxt_movq_wRn_M0(wrd);
1748         gen_op_iwmmxt_set_mup();
1749         gen_op_iwmmxt_set_cup();
1750         break;
1751     case 0x10c: case 0x50c: case 0x90c: case 0xd0c:     /* WUNPCKIH */
1752         wrd = (insn >> 12) & 0xf;
1753         rd0 = (insn >> 16) & 0xf;
1754         rd1 = (insn >> 0) & 0xf;
1755         gen_op_iwmmxt_movq_M0_wRn(rd0);
1756         switch ((insn >> 22) & 3) {
1757         case 0:
1758             gen_op_iwmmxt_unpackhb_M0_wRn(rd1);
1759             break;
1760         case 1:
1761             gen_op_iwmmxt_unpackhw_M0_wRn(rd1);
1762             break;
1763         case 2:
1764             gen_op_iwmmxt_unpackhl_M0_wRn(rd1);
1765             break;
1766         case 3:
1767             return 1;
1768         }
1769         gen_op_iwmmxt_movq_wRn_M0(wrd);
1770         gen_op_iwmmxt_set_mup();
1771         gen_op_iwmmxt_set_cup();
1772         break;
1773     case 0x012: case 0x112: case 0x412: case 0x512:     /* WSAD */
1774         wrd = (insn >> 12) & 0xf;
1775         rd0 = (insn >> 16) & 0xf;
1776         rd1 = (insn >> 0) & 0xf;
1777         gen_op_iwmmxt_movq_M0_wRn(rd0);
1778         if (insn & (1 << 22))
1779             gen_op_iwmmxt_sadw_M0_wRn(rd1);
1780         else
1781             gen_op_iwmmxt_sadb_M0_wRn(rd1);
1782         if (!(insn & (1 << 20)))
1783             gen_op_iwmmxt_addl_M0_wRn(wrd);
1784         gen_op_iwmmxt_movq_wRn_M0(wrd);
1785         gen_op_iwmmxt_set_mup();
1786         break;
1787     case 0x010: case 0x110: case 0x210: case 0x310:     /* WMUL */
1788         wrd = (insn >> 12) & 0xf;
1789         rd0 = (insn >> 16) & 0xf;
1790         rd1 = (insn >> 0) & 0xf;
1791         gen_op_iwmmxt_movq_M0_wRn(rd0);
1792         if (insn & (1 << 21)) {
1793             if (insn & (1 << 20))
1794                 gen_op_iwmmxt_mulshw_M0_wRn(rd1);
1795             else
1796                 gen_op_iwmmxt_mulslw_M0_wRn(rd1);
1797         } else {
1798             if (insn & (1 << 20))
1799                 gen_op_iwmmxt_muluhw_M0_wRn(rd1);
1800             else
1801                 gen_op_iwmmxt_mululw_M0_wRn(rd1);
1802         }
1803         gen_op_iwmmxt_movq_wRn_M0(wrd);
1804         gen_op_iwmmxt_set_mup();
1805         break;
1806     case 0x410: case 0x510: case 0x610: case 0x710:     /* WMAC */
1807         wrd = (insn >> 12) & 0xf;
1808         rd0 = (insn >> 16) & 0xf;
1809         rd1 = (insn >> 0) & 0xf;
1810         gen_op_iwmmxt_movq_M0_wRn(rd0);
1811         if (insn & (1 << 21))
1812             gen_op_iwmmxt_macsw_M0_wRn(rd1);
1813         else
1814             gen_op_iwmmxt_macuw_M0_wRn(rd1);
1815         if (!(insn & (1 << 20))) {
1816             iwmmxt_load_reg(cpu_V1, wrd);
1817             tcg_gen_add_i64(cpu_M0, cpu_M0, cpu_V1);
1818         }
1819         gen_op_iwmmxt_movq_wRn_M0(wrd);
1820         gen_op_iwmmxt_set_mup();
1821         break;
1822     case 0x006: case 0x406: case 0x806: case 0xc06:     /* WCMPEQ */
1823         wrd = (insn >> 12) & 0xf;
1824         rd0 = (insn >> 16) & 0xf;
1825         rd1 = (insn >> 0) & 0xf;
1826         gen_op_iwmmxt_movq_M0_wRn(rd0);
1827         switch ((insn >> 22) & 3) {
1828         case 0:
1829             gen_op_iwmmxt_cmpeqb_M0_wRn(rd1);
1830             break;
1831         case 1:
1832             gen_op_iwmmxt_cmpeqw_M0_wRn(rd1);
1833             break;
1834         case 2:
1835             gen_op_iwmmxt_cmpeql_M0_wRn(rd1);
1836             break;
1837         case 3:
1838             return 1;
1839         }
1840         gen_op_iwmmxt_movq_wRn_M0(wrd);
1841         gen_op_iwmmxt_set_mup();
1842         gen_op_iwmmxt_set_cup();
1843         break;
1844     case 0x800: case 0x900: case 0xc00: case 0xd00:     /* WAVG2 */
1845         wrd = (insn >> 12) & 0xf;
1846         rd0 = (insn >> 16) & 0xf;
1847         rd1 = (insn >> 0) & 0xf;
1848         gen_op_iwmmxt_movq_M0_wRn(rd0);
1849         if (insn & (1 << 22)) {
1850             if (insn & (1 << 20))
1851                 gen_op_iwmmxt_avgw1_M0_wRn(rd1);
1852             else
1853                 gen_op_iwmmxt_avgw0_M0_wRn(rd1);
1854         } else {
1855             if (insn & (1 << 20))
1856                 gen_op_iwmmxt_avgb1_M0_wRn(rd1);
1857             else
1858                 gen_op_iwmmxt_avgb0_M0_wRn(rd1);
1859         }
1860         gen_op_iwmmxt_movq_wRn_M0(wrd);
1861         gen_op_iwmmxt_set_mup();
1862         gen_op_iwmmxt_set_cup();
1863         break;
1864     case 0x802: case 0x902: case 0xa02: case 0xb02:     /* WALIGNR */
1865         wrd = (insn >> 12) & 0xf;
1866         rd0 = (insn >> 16) & 0xf;
1867         rd1 = (insn >> 0) & 0xf;
1868         gen_op_iwmmxt_movq_M0_wRn(rd0);
1869         tmp = iwmmxt_load_creg(ARM_IWMMXT_wCGR0 + ((insn >> 20) & 3));
1870         tcg_gen_andi_i32(tmp, tmp, 7);
1871         iwmmxt_load_reg(cpu_V1, rd1);
1872         gen_helper_iwmmxt_align(cpu_M0, cpu_M0, cpu_V1, tmp);
1873         tcg_temp_free_i32(tmp);
1874         gen_op_iwmmxt_movq_wRn_M0(wrd);
1875         gen_op_iwmmxt_set_mup();
1876         break;
1877     case 0x601: case 0x605: case 0x609: case 0x60d:     /* TINSR */
1878         if (((insn >> 6) & 3) == 3)
1879             return 1;
1880         rd = (insn >> 12) & 0xf;
1881         wrd = (insn >> 16) & 0xf;
1882         tmp = load_reg(s, rd);
1883         gen_op_iwmmxt_movq_M0_wRn(wrd);
1884         switch ((insn >> 6) & 3) {
1885         case 0:
1886             tmp2 = tcg_const_i32(0xff);
1887             tmp3 = tcg_const_i32((insn & 7) << 3);
1888             break;
1889         case 1:
1890             tmp2 = tcg_const_i32(0xffff);
1891             tmp3 = tcg_const_i32((insn & 3) << 4);
1892             break;
1893         case 2:
1894             tmp2 = tcg_const_i32(0xffffffff);
1895             tmp3 = tcg_const_i32((insn & 1) << 5);
1896             break;
1897         default:
1898             tmp2 = NULL;
1899             tmp3 = NULL;
1900         }
1901         gen_helper_iwmmxt_insr(cpu_M0, cpu_M0, tmp, tmp2, tmp3);
1902         tcg_temp_free_i32(tmp3);
1903         tcg_temp_free_i32(tmp2);
1904         tcg_temp_free_i32(tmp);
1905         gen_op_iwmmxt_movq_wRn_M0(wrd);
1906         gen_op_iwmmxt_set_mup();
1907         break;
1908     case 0x107: case 0x507: case 0x907: case 0xd07:     /* TEXTRM */
1909         rd = (insn >> 12) & 0xf;
1910         wrd = (insn >> 16) & 0xf;
1911         if (rd == 15 || ((insn >> 22) & 3) == 3)
1912             return 1;
1913         gen_op_iwmmxt_movq_M0_wRn(wrd);
1914         tmp = tcg_temp_new_i32();
1915         switch ((insn >> 22) & 3) {
1916         case 0:
1917             tcg_gen_shri_i64(cpu_M0, cpu_M0, (insn & 7) << 3);
1918             tcg_gen_extrl_i64_i32(tmp, cpu_M0);
1919             if (insn & 8) {
1920                 tcg_gen_ext8s_i32(tmp, tmp);
1921             } else {
1922                 tcg_gen_andi_i32(tmp, tmp, 0xff);
1923             }
1924             break;
1925         case 1:
1926             tcg_gen_shri_i64(cpu_M0, cpu_M0, (insn & 3) << 4);
1927             tcg_gen_extrl_i64_i32(tmp, cpu_M0);
1928             if (insn & 8) {
1929                 tcg_gen_ext16s_i32(tmp, tmp);
1930             } else {
1931                 tcg_gen_andi_i32(tmp, tmp, 0xffff);
1932             }
1933             break;
1934         case 2:
1935             tcg_gen_shri_i64(cpu_M0, cpu_M0, (insn & 1) << 5);
1936             tcg_gen_extrl_i64_i32(tmp, cpu_M0);
1937             break;
1938         }
1939         store_reg(s, rd, tmp);
1940         break;
1941     case 0x117: case 0x517: case 0x917: case 0xd17:     /* TEXTRC */
1942         if ((insn & 0x000ff008) != 0x0003f000 || ((insn >> 22) & 3) == 3)
1943             return 1;
1944         tmp = iwmmxt_load_creg(ARM_IWMMXT_wCASF);
1945         switch ((insn >> 22) & 3) {
1946         case 0:
1947             tcg_gen_shri_i32(tmp, tmp, ((insn & 7) << 2) + 0);
1948             break;
1949         case 1:
1950             tcg_gen_shri_i32(tmp, tmp, ((insn & 3) << 3) + 4);
1951             break;
1952         case 2:
1953             tcg_gen_shri_i32(tmp, tmp, ((insn & 1) << 4) + 12);
1954             break;
1955         }
1956         tcg_gen_shli_i32(tmp, tmp, 28);
1957         gen_set_nzcv(tmp);
1958         tcg_temp_free_i32(tmp);
1959         break;
1960     case 0x401: case 0x405: case 0x409: case 0x40d:     /* TBCST */
1961         if (((insn >> 6) & 3) == 3)
1962             return 1;
1963         rd = (insn >> 12) & 0xf;
1964         wrd = (insn >> 16) & 0xf;
1965         tmp = load_reg(s, rd);
1966         switch ((insn >> 6) & 3) {
1967         case 0:
1968             gen_helper_iwmmxt_bcstb(cpu_M0, tmp);
1969             break;
1970         case 1:
1971             gen_helper_iwmmxt_bcstw(cpu_M0, tmp);
1972             break;
1973         case 2:
1974             gen_helper_iwmmxt_bcstl(cpu_M0, tmp);
1975             break;
1976         }
1977         tcg_temp_free_i32(tmp);
1978         gen_op_iwmmxt_movq_wRn_M0(wrd);
1979         gen_op_iwmmxt_set_mup();
1980         break;
1981     case 0x113: case 0x513: case 0x913: case 0xd13:     /* TANDC */
1982         if ((insn & 0x000ff00f) != 0x0003f000 || ((insn >> 22) & 3) == 3)
1983             return 1;
1984         tmp = iwmmxt_load_creg(ARM_IWMMXT_wCASF);
1985         tmp2 = tcg_temp_new_i32();
1986         tcg_gen_mov_i32(tmp2, tmp);
1987         switch ((insn >> 22) & 3) {
1988         case 0:
1989             for (i = 0; i < 7; i ++) {
1990                 tcg_gen_shli_i32(tmp2, tmp2, 4);
1991                 tcg_gen_and_i32(tmp, tmp, tmp2);
1992             }
1993             break;
1994         case 1:
1995             for (i = 0; i < 3; i ++) {
1996                 tcg_gen_shli_i32(tmp2, tmp2, 8);
1997                 tcg_gen_and_i32(tmp, tmp, tmp2);
1998             }
1999             break;
2000         case 2:
2001             tcg_gen_shli_i32(tmp2, tmp2, 16);
2002             tcg_gen_and_i32(tmp, tmp, tmp2);
2003             break;
2004         }
2005         gen_set_nzcv(tmp);
2006         tcg_temp_free_i32(tmp2);
2007         tcg_temp_free_i32(tmp);
2008         break;
2009     case 0x01c: case 0x41c: case 0x81c: case 0xc1c:     /* WACC */
2010         wrd = (insn >> 12) & 0xf;
2011         rd0 = (insn >> 16) & 0xf;
2012         gen_op_iwmmxt_movq_M0_wRn(rd0);
2013         switch ((insn >> 22) & 3) {
2014         case 0:
2015             gen_helper_iwmmxt_addcb(cpu_M0, cpu_M0);
2016             break;
2017         case 1:
2018             gen_helper_iwmmxt_addcw(cpu_M0, cpu_M0);
2019             break;
2020         case 2:
2021             gen_helper_iwmmxt_addcl(cpu_M0, cpu_M0);
2022             break;
2023         case 3:
2024             return 1;
2025         }
2026         gen_op_iwmmxt_movq_wRn_M0(wrd);
2027         gen_op_iwmmxt_set_mup();
2028         break;
2029     case 0x115: case 0x515: case 0x915: case 0xd15:     /* TORC */
2030         if ((insn & 0x000ff00f) != 0x0003f000 || ((insn >> 22) & 3) == 3)
2031             return 1;
2032         tmp = iwmmxt_load_creg(ARM_IWMMXT_wCASF);
2033         tmp2 = tcg_temp_new_i32();
2034         tcg_gen_mov_i32(tmp2, tmp);
2035         switch ((insn >> 22) & 3) {
2036         case 0:
2037             for (i = 0; i < 7; i ++) {
2038                 tcg_gen_shli_i32(tmp2, tmp2, 4);
2039                 tcg_gen_or_i32(tmp, tmp, tmp2);
2040             }
2041             break;
2042         case 1:
2043             for (i = 0; i < 3; i ++) {
2044                 tcg_gen_shli_i32(tmp2, tmp2, 8);
2045                 tcg_gen_or_i32(tmp, tmp, tmp2);
2046             }
2047             break;
2048         case 2:
2049             tcg_gen_shli_i32(tmp2, tmp2, 16);
2050             tcg_gen_or_i32(tmp, tmp, tmp2);
2051             break;
2052         }
2053         gen_set_nzcv(tmp);
2054         tcg_temp_free_i32(tmp2);
2055         tcg_temp_free_i32(tmp);
2056         break;
2057     case 0x103: case 0x503: case 0x903: case 0xd03:     /* TMOVMSK */
2058         rd = (insn >> 12) & 0xf;
2059         rd0 = (insn >> 16) & 0xf;
2060         if ((insn & 0xf) != 0 || ((insn >> 22) & 3) == 3)
2061             return 1;
2062         gen_op_iwmmxt_movq_M0_wRn(rd0);
2063         tmp = tcg_temp_new_i32();
2064         switch ((insn >> 22) & 3) {
2065         case 0:
2066             gen_helper_iwmmxt_msbb(tmp, cpu_M0);
2067             break;
2068         case 1:
2069             gen_helper_iwmmxt_msbw(tmp, cpu_M0);
2070             break;
2071         case 2:
2072             gen_helper_iwmmxt_msbl(tmp, cpu_M0);
2073             break;
2074         }
2075         store_reg(s, rd, tmp);
2076         break;
2077     case 0x106: case 0x306: case 0x506: case 0x706:     /* WCMPGT */
2078     case 0x906: case 0xb06: case 0xd06: case 0xf06:
2079         wrd = (insn >> 12) & 0xf;
2080         rd0 = (insn >> 16) & 0xf;
2081         rd1 = (insn >> 0) & 0xf;
2082         gen_op_iwmmxt_movq_M0_wRn(rd0);
2083         switch ((insn >> 22) & 3) {
2084         case 0:
2085             if (insn & (1 << 21))
2086                 gen_op_iwmmxt_cmpgtsb_M0_wRn(rd1);
2087             else
2088                 gen_op_iwmmxt_cmpgtub_M0_wRn(rd1);
2089             break;
2090         case 1:
2091             if (insn & (1 << 21))
2092                 gen_op_iwmmxt_cmpgtsw_M0_wRn(rd1);
2093             else
2094                 gen_op_iwmmxt_cmpgtuw_M0_wRn(rd1);
2095             break;
2096         case 2:
2097             if (insn & (1 << 21))
2098                 gen_op_iwmmxt_cmpgtsl_M0_wRn(rd1);
2099             else
2100                 gen_op_iwmmxt_cmpgtul_M0_wRn(rd1);
2101             break;
2102         case 3:
2103             return 1;
2104         }
2105         gen_op_iwmmxt_movq_wRn_M0(wrd);
2106         gen_op_iwmmxt_set_mup();
2107         gen_op_iwmmxt_set_cup();
2108         break;
2109     case 0x00e: case 0x20e: case 0x40e: case 0x60e:     /* WUNPCKEL */
2110     case 0x80e: case 0xa0e: case 0xc0e: case 0xe0e:
2111         wrd = (insn >> 12) & 0xf;
2112         rd0 = (insn >> 16) & 0xf;
2113         gen_op_iwmmxt_movq_M0_wRn(rd0);
2114         switch ((insn >> 22) & 3) {
2115         case 0:
2116             if (insn & (1 << 21))
2117                 gen_op_iwmmxt_unpacklsb_M0();
2118             else
2119                 gen_op_iwmmxt_unpacklub_M0();
2120             break;
2121         case 1:
2122             if (insn & (1 << 21))
2123                 gen_op_iwmmxt_unpacklsw_M0();
2124             else
2125                 gen_op_iwmmxt_unpackluw_M0();
2126             break;
2127         case 2:
2128             if (insn & (1 << 21))
2129                 gen_op_iwmmxt_unpacklsl_M0();
2130             else
2131                 gen_op_iwmmxt_unpacklul_M0();
2132             break;
2133         case 3:
2134             return 1;
2135         }
2136         gen_op_iwmmxt_movq_wRn_M0(wrd);
2137         gen_op_iwmmxt_set_mup();
2138         gen_op_iwmmxt_set_cup();
2139         break;
2140     case 0x00c: case 0x20c: case 0x40c: case 0x60c:     /* WUNPCKEH */
2141     case 0x80c: case 0xa0c: case 0xc0c: case 0xe0c:
2142         wrd = (insn >> 12) & 0xf;
2143         rd0 = (insn >> 16) & 0xf;
2144         gen_op_iwmmxt_movq_M0_wRn(rd0);
2145         switch ((insn >> 22) & 3) {
2146         case 0:
2147             if (insn & (1 << 21))
2148                 gen_op_iwmmxt_unpackhsb_M0();
2149             else
2150                 gen_op_iwmmxt_unpackhub_M0();
2151             break;
2152         case 1:
2153             if (insn & (1 << 21))
2154                 gen_op_iwmmxt_unpackhsw_M0();
2155             else
2156                 gen_op_iwmmxt_unpackhuw_M0();
2157             break;
2158         case 2:
2159             if (insn & (1 << 21))
2160                 gen_op_iwmmxt_unpackhsl_M0();
2161             else
2162                 gen_op_iwmmxt_unpackhul_M0();
2163             break;
2164         case 3:
2165             return 1;
2166         }
2167         gen_op_iwmmxt_movq_wRn_M0(wrd);
2168         gen_op_iwmmxt_set_mup();
2169         gen_op_iwmmxt_set_cup();
2170         break;
2171     case 0x204: case 0x604: case 0xa04: case 0xe04:     /* WSRL */
2172     case 0x214: case 0x614: case 0xa14: case 0xe14:
2173         if (((insn >> 22) & 3) == 0)
2174             return 1;
2175         wrd = (insn >> 12) & 0xf;
2176         rd0 = (insn >> 16) & 0xf;
2177         gen_op_iwmmxt_movq_M0_wRn(rd0);
2178         tmp = tcg_temp_new_i32();
2179         if (gen_iwmmxt_shift(insn, 0xff, tmp)) {
2180             tcg_temp_free_i32(tmp);
2181             return 1;
2182         }
2183         switch ((insn >> 22) & 3) {
2184         case 1:
2185             gen_helper_iwmmxt_srlw(cpu_M0, cpu_env, cpu_M0, tmp);
2186             break;
2187         case 2:
2188             gen_helper_iwmmxt_srll(cpu_M0, cpu_env, cpu_M0, tmp);
2189             break;
2190         case 3:
2191             gen_helper_iwmmxt_srlq(cpu_M0, cpu_env, cpu_M0, tmp);
2192             break;
2193         }
2194         tcg_temp_free_i32(tmp);
2195         gen_op_iwmmxt_movq_wRn_M0(wrd);
2196         gen_op_iwmmxt_set_mup();
2197         gen_op_iwmmxt_set_cup();
2198         break;
2199     case 0x004: case 0x404: case 0x804: case 0xc04:     /* WSRA */
2200     case 0x014: case 0x414: case 0x814: case 0xc14:
2201         if (((insn >> 22) & 3) == 0)
2202             return 1;
2203         wrd = (insn >> 12) & 0xf;
2204         rd0 = (insn >> 16) & 0xf;
2205         gen_op_iwmmxt_movq_M0_wRn(rd0);
2206         tmp = tcg_temp_new_i32();
2207         if (gen_iwmmxt_shift(insn, 0xff, tmp)) {
2208             tcg_temp_free_i32(tmp);
2209             return 1;
2210         }
2211         switch ((insn >> 22) & 3) {
2212         case 1:
2213             gen_helper_iwmmxt_sraw(cpu_M0, cpu_env, cpu_M0, tmp);
2214             break;
2215         case 2:
2216             gen_helper_iwmmxt_sral(cpu_M0, cpu_env, cpu_M0, tmp);
2217             break;
2218         case 3:
2219             gen_helper_iwmmxt_sraq(cpu_M0, cpu_env, cpu_M0, tmp);
2220             break;
2221         }
2222         tcg_temp_free_i32(tmp);
2223         gen_op_iwmmxt_movq_wRn_M0(wrd);
2224         gen_op_iwmmxt_set_mup();
2225         gen_op_iwmmxt_set_cup();
2226         break;
2227     case 0x104: case 0x504: case 0x904: case 0xd04:     /* WSLL */
2228     case 0x114: case 0x514: case 0x914: case 0xd14:
2229         if (((insn >> 22) & 3) == 0)
2230             return 1;
2231         wrd = (insn >> 12) & 0xf;
2232         rd0 = (insn >> 16) & 0xf;
2233         gen_op_iwmmxt_movq_M0_wRn(rd0);
2234         tmp = tcg_temp_new_i32();
2235         if (gen_iwmmxt_shift(insn, 0xff, tmp)) {
2236             tcg_temp_free_i32(tmp);
2237             return 1;
2238         }
2239         switch ((insn >> 22) & 3) {
2240         case 1:
2241             gen_helper_iwmmxt_sllw(cpu_M0, cpu_env, cpu_M0, tmp);
2242             break;
2243         case 2:
2244             gen_helper_iwmmxt_slll(cpu_M0, cpu_env, cpu_M0, tmp);
2245             break;
2246         case 3:
2247             gen_helper_iwmmxt_sllq(cpu_M0, cpu_env, cpu_M0, tmp);
2248             break;
2249         }
2250         tcg_temp_free_i32(tmp);
2251         gen_op_iwmmxt_movq_wRn_M0(wrd);
2252         gen_op_iwmmxt_set_mup();
2253         gen_op_iwmmxt_set_cup();
2254         break;
2255     case 0x304: case 0x704: case 0xb04: case 0xf04:     /* WROR */
2256     case 0x314: case 0x714: case 0xb14: case 0xf14:
2257         if (((insn >> 22) & 3) == 0)
2258             return 1;
2259         wrd = (insn >> 12) & 0xf;
2260         rd0 = (insn >> 16) & 0xf;
2261         gen_op_iwmmxt_movq_M0_wRn(rd0);
2262         tmp = tcg_temp_new_i32();
2263         switch ((insn >> 22) & 3) {
2264         case 1:
2265             if (gen_iwmmxt_shift(insn, 0xf, tmp)) {
2266                 tcg_temp_free_i32(tmp);
2267                 return 1;
2268             }
2269             gen_helper_iwmmxt_rorw(cpu_M0, cpu_env, cpu_M0, tmp);
2270             break;
2271         case 2:
2272             if (gen_iwmmxt_shift(insn, 0x1f, tmp)) {
2273                 tcg_temp_free_i32(tmp);
2274                 return 1;
2275             }
2276             gen_helper_iwmmxt_rorl(cpu_M0, cpu_env, cpu_M0, tmp);
2277             break;
2278         case 3:
2279             if (gen_iwmmxt_shift(insn, 0x3f, tmp)) {
2280                 tcg_temp_free_i32(tmp);
2281                 return 1;
2282             }
2283             gen_helper_iwmmxt_rorq(cpu_M0, cpu_env, cpu_M0, tmp);
2284             break;
2285         }
2286         tcg_temp_free_i32(tmp);
2287         gen_op_iwmmxt_movq_wRn_M0(wrd);
2288         gen_op_iwmmxt_set_mup();
2289         gen_op_iwmmxt_set_cup();
2290         break;
2291     case 0x116: case 0x316: case 0x516: case 0x716:     /* WMIN */
2292     case 0x916: case 0xb16: case 0xd16: case 0xf16:
2293         wrd = (insn >> 12) & 0xf;
2294         rd0 = (insn >> 16) & 0xf;
2295         rd1 = (insn >> 0) & 0xf;
2296         gen_op_iwmmxt_movq_M0_wRn(rd0);
2297         switch ((insn >> 22) & 3) {
2298         case 0:
2299             if (insn & (1 << 21))
2300                 gen_op_iwmmxt_minsb_M0_wRn(rd1);
2301             else
2302                 gen_op_iwmmxt_minub_M0_wRn(rd1);
2303             break;
2304         case 1:
2305             if (insn & (1 << 21))
2306                 gen_op_iwmmxt_minsw_M0_wRn(rd1);
2307             else
2308                 gen_op_iwmmxt_minuw_M0_wRn(rd1);
2309             break;
2310         case 2:
2311             if (insn & (1 << 21))
2312                 gen_op_iwmmxt_minsl_M0_wRn(rd1);
2313             else
2314                 gen_op_iwmmxt_minul_M0_wRn(rd1);
2315             break;
2316         case 3:
2317             return 1;
2318         }
2319         gen_op_iwmmxt_movq_wRn_M0(wrd);
2320         gen_op_iwmmxt_set_mup();
2321         break;
2322     case 0x016: case 0x216: case 0x416: case 0x616:     /* WMAX */
2323     case 0x816: case 0xa16: case 0xc16: case 0xe16:
2324         wrd = (insn >> 12) & 0xf;
2325         rd0 = (insn >> 16) & 0xf;
2326         rd1 = (insn >> 0) & 0xf;
2327         gen_op_iwmmxt_movq_M0_wRn(rd0);
2328         switch ((insn >> 22) & 3) {
2329         case 0:
2330             if (insn & (1 << 21))
2331                 gen_op_iwmmxt_maxsb_M0_wRn(rd1);
2332             else
2333                 gen_op_iwmmxt_maxub_M0_wRn(rd1);
2334             break;
2335         case 1:
2336             if (insn & (1 << 21))
2337                 gen_op_iwmmxt_maxsw_M0_wRn(rd1);
2338             else
2339                 gen_op_iwmmxt_maxuw_M0_wRn(rd1);
2340             break;
2341         case 2:
2342             if (insn & (1 << 21))
2343                 gen_op_iwmmxt_maxsl_M0_wRn(rd1);
2344             else
2345                 gen_op_iwmmxt_maxul_M0_wRn(rd1);
2346             break;
2347         case 3:
2348             return 1;
2349         }
2350         gen_op_iwmmxt_movq_wRn_M0(wrd);
2351         gen_op_iwmmxt_set_mup();
2352         break;
2353     case 0x002: case 0x102: case 0x202: case 0x302:     /* WALIGNI */
2354     case 0x402: case 0x502: case 0x602: case 0x702:
2355         wrd = (insn >> 12) & 0xf;
2356         rd0 = (insn >> 16) & 0xf;
2357         rd1 = (insn >> 0) & 0xf;
2358         gen_op_iwmmxt_movq_M0_wRn(rd0);
2359         tmp = tcg_const_i32((insn >> 20) & 3);
2360         iwmmxt_load_reg(cpu_V1, rd1);
2361         gen_helper_iwmmxt_align(cpu_M0, cpu_M0, cpu_V1, tmp);
2362         tcg_temp_free_i32(tmp);
2363         gen_op_iwmmxt_movq_wRn_M0(wrd);
2364         gen_op_iwmmxt_set_mup();
2365         break;
2366     case 0x01a: case 0x11a: case 0x21a: case 0x31a:     /* WSUB */
2367     case 0x41a: case 0x51a: case 0x61a: case 0x71a:
2368     case 0x81a: case 0x91a: case 0xa1a: case 0xb1a:
2369     case 0xc1a: case 0xd1a: case 0xe1a: case 0xf1a:
2370         wrd = (insn >> 12) & 0xf;
2371         rd0 = (insn >> 16) & 0xf;
2372         rd1 = (insn >> 0) & 0xf;
2373         gen_op_iwmmxt_movq_M0_wRn(rd0);
2374         switch ((insn >> 20) & 0xf) {
2375         case 0x0:
2376             gen_op_iwmmxt_subnb_M0_wRn(rd1);
2377             break;
2378         case 0x1:
2379             gen_op_iwmmxt_subub_M0_wRn(rd1);
2380             break;
2381         case 0x3:
2382             gen_op_iwmmxt_subsb_M0_wRn(rd1);
2383             break;
2384         case 0x4:
2385             gen_op_iwmmxt_subnw_M0_wRn(rd1);
2386             break;
2387         case 0x5:
2388             gen_op_iwmmxt_subuw_M0_wRn(rd1);
2389             break;
2390         case 0x7:
2391             gen_op_iwmmxt_subsw_M0_wRn(rd1);
2392             break;
2393         case 0x8:
2394             gen_op_iwmmxt_subnl_M0_wRn(rd1);
2395             break;
2396         case 0x9:
2397             gen_op_iwmmxt_subul_M0_wRn(rd1);
2398             break;
2399         case 0xb:
2400             gen_op_iwmmxt_subsl_M0_wRn(rd1);
2401             break;
2402         default:
2403             return 1;
2404         }
2405         gen_op_iwmmxt_movq_wRn_M0(wrd);
2406         gen_op_iwmmxt_set_mup();
2407         gen_op_iwmmxt_set_cup();
2408         break;
2409     case 0x01e: case 0x11e: case 0x21e: case 0x31e:     /* WSHUFH */
2410     case 0x41e: case 0x51e: case 0x61e: case 0x71e:
2411     case 0x81e: case 0x91e: case 0xa1e: case 0xb1e:
2412     case 0xc1e: case 0xd1e: case 0xe1e: case 0xf1e:
2413         wrd = (insn >> 12) & 0xf;
2414         rd0 = (insn >> 16) & 0xf;
2415         gen_op_iwmmxt_movq_M0_wRn(rd0);
2416         tmp = tcg_const_i32(((insn >> 16) & 0xf0) | (insn & 0x0f));
2417         gen_helper_iwmmxt_shufh(cpu_M0, cpu_env, cpu_M0, tmp);
2418         tcg_temp_free_i32(tmp);
2419         gen_op_iwmmxt_movq_wRn_M0(wrd);
2420         gen_op_iwmmxt_set_mup();
2421         gen_op_iwmmxt_set_cup();
2422         break;
2423     case 0x018: case 0x118: case 0x218: case 0x318:     /* WADD */
2424     case 0x418: case 0x518: case 0x618: case 0x718:
2425     case 0x818: case 0x918: case 0xa18: case 0xb18:
2426     case 0xc18: case 0xd18: case 0xe18: case 0xf18:
2427         wrd = (insn >> 12) & 0xf;
2428         rd0 = (insn >> 16) & 0xf;
2429         rd1 = (insn >> 0) & 0xf;
2430         gen_op_iwmmxt_movq_M0_wRn(rd0);
2431         switch ((insn >> 20) & 0xf) {
2432         case 0x0:
2433             gen_op_iwmmxt_addnb_M0_wRn(rd1);
2434             break;
2435         case 0x1:
2436             gen_op_iwmmxt_addub_M0_wRn(rd1);
2437             break;
2438         case 0x3:
2439             gen_op_iwmmxt_addsb_M0_wRn(rd1);
2440             break;
2441         case 0x4:
2442             gen_op_iwmmxt_addnw_M0_wRn(rd1);
2443             break;
2444         case 0x5:
2445             gen_op_iwmmxt_adduw_M0_wRn(rd1);
2446             break;
2447         case 0x7:
2448             gen_op_iwmmxt_addsw_M0_wRn(rd1);
2449             break;
2450         case 0x8:
2451             gen_op_iwmmxt_addnl_M0_wRn(rd1);
2452             break;
2453         case 0x9:
2454             gen_op_iwmmxt_addul_M0_wRn(rd1);
2455             break;
2456         case 0xb:
2457             gen_op_iwmmxt_addsl_M0_wRn(rd1);
2458             break;
2459         default:
2460             return 1;
2461         }
2462         gen_op_iwmmxt_movq_wRn_M0(wrd);
2463         gen_op_iwmmxt_set_mup();
2464         gen_op_iwmmxt_set_cup();
2465         break;
2466     case 0x008: case 0x108: case 0x208: case 0x308:     /* WPACK */
2467     case 0x408: case 0x508: case 0x608: case 0x708:
2468     case 0x808: case 0x908: case 0xa08: case 0xb08:
2469     case 0xc08: case 0xd08: case 0xe08: case 0xf08:
2470         if (!(insn & (1 << 20)) || ((insn >> 22) & 3) == 0)
2471             return 1;
2472         wrd = (insn >> 12) & 0xf;
2473         rd0 = (insn >> 16) & 0xf;
2474         rd1 = (insn >> 0) & 0xf;
2475         gen_op_iwmmxt_movq_M0_wRn(rd0);
2476         switch ((insn >> 22) & 3) {
2477         case 1:
2478             if (insn & (1 << 21))
2479                 gen_op_iwmmxt_packsw_M0_wRn(rd1);
2480             else
2481                 gen_op_iwmmxt_packuw_M0_wRn(rd1);
2482             break;
2483         case 2:
2484             if (insn & (1 << 21))
2485                 gen_op_iwmmxt_packsl_M0_wRn(rd1);
2486             else
2487                 gen_op_iwmmxt_packul_M0_wRn(rd1);
2488             break;
2489         case 3:
2490             if (insn & (1 << 21))
2491                 gen_op_iwmmxt_packsq_M0_wRn(rd1);
2492             else
2493                 gen_op_iwmmxt_packuq_M0_wRn(rd1);
2494             break;
2495         }
2496         gen_op_iwmmxt_movq_wRn_M0(wrd);
2497         gen_op_iwmmxt_set_mup();
2498         gen_op_iwmmxt_set_cup();
2499         break;
2500     case 0x201: case 0x203: case 0x205: case 0x207:
2501     case 0x209: case 0x20b: case 0x20d: case 0x20f:
2502     case 0x211: case 0x213: case 0x215: case 0x217:
2503     case 0x219: case 0x21b: case 0x21d: case 0x21f:
2504         wrd = (insn >> 5) & 0xf;
2505         rd0 = (insn >> 12) & 0xf;
2506         rd1 = (insn >> 0) & 0xf;
2507         if (rd0 == 0xf || rd1 == 0xf)
2508             return 1;
2509         gen_op_iwmmxt_movq_M0_wRn(wrd);
2510         tmp = load_reg(s, rd0);
2511         tmp2 = load_reg(s, rd1);
2512         switch ((insn >> 16) & 0xf) {
2513         case 0x0:                                       /* TMIA */
2514             gen_helper_iwmmxt_muladdsl(cpu_M0, cpu_M0, tmp, tmp2);
2515             break;
2516         case 0x8:                                       /* TMIAPH */
2517             gen_helper_iwmmxt_muladdsw(cpu_M0, cpu_M0, tmp, tmp2);
2518             break;
2519         case 0xc: case 0xd: case 0xe: case 0xf:                 /* TMIAxy */
2520             if (insn & (1 << 16))
2521                 tcg_gen_shri_i32(tmp, tmp, 16);
2522             if (insn & (1 << 17))
2523                 tcg_gen_shri_i32(tmp2, tmp2, 16);
2524             gen_helper_iwmmxt_muladdswl(cpu_M0, cpu_M0, tmp, tmp2);
2525             break;
2526         default:
2527             tcg_temp_free_i32(tmp2);
2528             tcg_temp_free_i32(tmp);
2529             return 1;
2530         }
2531         tcg_temp_free_i32(tmp2);
2532         tcg_temp_free_i32(tmp);
2533         gen_op_iwmmxt_movq_wRn_M0(wrd);
2534         gen_op_iwmmxt_set_mup();
2535         break;
2536     default:
2537         return 1;
2538     }
2539
2540     return 0;
2541 }
2542
2543 /* Disassemble an XScale DSP instruction.  Returns nonzero if an error occurred
2544    (ie. an undefined instruction).  */
2545 static int disas_dsp_insn(DisasContext *s, uint32_t insn)
2546 {
2547     int acc, rd0, rd1, rdhi, rdlo;
2548     TCGv_i32 tmp, tmp2;
2549
2550     if ((insn & 0x0ff00f10) == 0x0e200010) {
2551         /* Multiply with Internal Accumulate Format */
2552         rd0 = (insn >> 12) & 0xf;
2553         rd1 = insn & 0xf;
2554         acc = (insn >> 5) & 7;
2555
2556         if (acc != 0)
2557             return 1;
2558
2559         tmp = load_reg(s, rd0);
2560         tmp2 = load_reg(s, rd1);
2561         switch ((insn >> 16) & 0xf) {
2562         case 0x0:                                       /* MIA */
2563             gen_helper_iwmmxt_muladdsl(cpu_M0, cpu_M0, tmp, tmp2);
2564             break;
2565         case 0x8:                                       /* MIAPH */
2566             gen_helper_iwmmxt_muladdsw(cpu_M0, cpu_M0, tmp, tmp2);
2567             break;
2568         case 0xc:                                       /* MIABB */
2569         case 0xd:                                       /* MIABT */
2570         case 0xe:                                       /* MIATB */
2571         case 0xf:                                       /* MIATT */
2572             if (insn & (1 << 16))
2573                 tcg_gen_shri_i32(tmp, tmp, 16);
2574             if (insn & (1 << 17))
2575                 tcg_gen_shri_i32(tmp2, tmp2, 16);
2576             gen_helper_iwmmxt_muladdswl(cpu_M0, cpu_M0, tmp, tmp2);
2577             break;
2578         default:
2579             return 1;
2580         }
2581         tcg_temp_free_i32(tmp2);
2582         tcg_temp_free_i32(tmp);
2583
2584         gen_op_iwmmxt_movq_wRn_M0(acc);
2585         return 0;
2586     }
2587
2588     if ((insn & 0x0fe00ff8) == 0x0c400000) {
2589         /* Internal Accumulator Access Format */
2590         rdhi = (insn >> 16) & 0xf;
2591         rdlo = (insn >> 12) & 0xf;
2592         acc = insn & 7;
2593
2594         if (acc != 0)
2595             return 1;
2596
2597         if (insn & ARM_CP_RW_BIT) {                     /* MRA */
2598             iwmmxt_load_reg(cpu_V0, acc);
2599             tcg_gen_extrl_i64_i32(cpu_R[rdlo], cpu_V0);
2600             tcg_gen_extrh_i64_i32(cpu_R[rdhi], cpu_V0);
2601             tcg_gen_andi_i32(cpu_R[rdhi], cpu_R[rdhi], (1 << (40 - 32)) - 1);
2602         } else {                                        /* MAR */
2603             tcg_gen_concat_i32_i64(cpu_V0, cpu_R[rdlo], cpu_R[rdhi]);
2604             iwmmxt_store_reg(cpu_V0, acc);
2605         }
2606         return 0;
2607     }
2608
2609     return 1;
2610 }
2611
2612 #define VFP_REG_SHR(x, n) (((n) > 0) ? (x) >> (n) : (x) << -(n))
2613 #define VFP_DREG(reg, insn, bigbit, smallbit) do { \
2614     if (dc_isar_feature(aa32_simd_r32, s)) { \
2615         reg = (((insn) >> (bigbit)) & 0x0f) \
2616               | (((insn) >> ((smallbit) - 4)) & 0x10); \
2617     } else { \
2618         if (insn & (1 << (smallbit))) \
2619             return 1; \
2620         reg = ((insn) >> (bigbit)) & 0x0f; \
2621     }} while (0)
2622
2623 #define VFP_DREG_D(reg, insn) VFP_DREG(reg, insn, 12, 22)
2624 #define VFP_DREG_N(reg, insn) VFP_DREG(reg, insn, 16,  7)
2625 #define VFP_DREG_M(reg, insn) VFP_DREG(reg, insn,  0,  5)
2626
2627 static void gen_neon_dup_low16(TCGv_i32 var)
2628 {
2629     TCGv_i32 tmp = tcg_temp_new_i32();
2630     tcg_gen_ext16u_i32(var, var);
2631     tcg_gen_shli_i32(tmp, var, 16);
2632     tcg_gen_or_i32(var, var, tmp);
2633     tcg_temp_free_i32(tmp);
2634 }
2635
2636 static void gen_neon_dup_high16(TCGv_i32 var)
2637 {
2638     TCGv_i32 tmp = tcg_temp_new_i32();
2639     tcg_gen_andi_i32(var, var, 0xffff0000);
2640     tcg_gen_shri_i32(tmp, var, 16);
2641     tcg_gen_or_i32(var, var, tmp);
2642     tcg_temp_free_i32(tmp);
2643 }
2644
2645 static inline bool use_goto_tb(DisasContext *s, target_ulong dest)
2646 {
2647 #ifndef CONFIG_USER_ONLY
2648     return (s->base.tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK) ||
2649            ((s->base.pc_next - 1) & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK);
2650 #else
2651     return true;
2652 #endif
2653 }
2654
2655 static void gen_goto_ptr(void)
2656 {
2657     tcg_gen_lookup_and_goto_ptr();
2658 }
2659
2660 /* This will end the TB but doesn't guarantee we'll return to
2661  * cpu_loop_exec. Any live exit_requests will be processed as we
2662  * enter the next TB.
2663  */
2664 static void gen_goto_tb(DisasContext *s, int n, target_ulong dest)
2665 {
2666     if (use_goto_tb(s, dest)) {
2667         tcg_gen_goto_tb(n);
2668         gen_set_pc_im(s, dest);
2669         tcg_gen_exit_tb(s->base.tb, n);
2670     } else {
2671         gen_set_pc_im(s, dest);
2672         gen_goto_ptr();
2673     }
2674     s->base.is_jmp = DISAS_NORETURN;
2675 }
2676
2677 static inline void gen_jmp (DisasContext *s, uint32_t dest)
2678 {
2679     if (unlikely(is_singlestepping(s))) {
2680         /* An indirect jump so that we still trigger the debug exception.  */
2681         gen_set_pc_im(s, dest);
2682         s->base.is_jmp = DISAS_JUMP;
2683     } else {
2684         gen_goto_tb(s, 0, dest);
2685     }
2686 }
2687
2688 static inline void gen_mulxy(TCGv_i32 t0, TCGv_i32 t1, int x, int y)
2689 {
2690     if (x)
2691         tcg_gen_sari_i32(t0, t0, 16);
2692     else
2693         gen_sxth(t0);
2694     if (y)
2695         tcg_gen_sari_i32(t1, t1, 16);
2696     else
2697         gen_sxth(t1);
2698     tcg_gen_mul_i32(t0, t0, t1);
2699 }
2700
2701 /* Return the mask of PSR bits set by a MSR instruction.  */
2702 static uint32_t msr_mask(DisasContext *s, int flags, int spsr)
2703 {
2704     uint32_t mask = 0;
2705
2706     if (flags & (1 << 0)) {
2707         mask |= 0xff;
2708     }
2709     if (flags & (1 << 1)) {
2710         mask |= 0xff00;
2711     }
2712     if (flags & (1 << 2)) {
2713         mask |= 0xff0000;
2714     }
2715     if (flags & (1 << 3)) {
2716         mask |= 0xff000000;
2717     }
2718
2719     /* Mask out undefined and reserved bits.  */
2720     mask &= aarch32_cpsr_valid_mask(s->features, s->isar);
2721
2722     /* Mask out execution state.  */
2723     if (!spsr) {
2724         mask &= ~CPSR_EXEC;
2725     }
2726
2727     /* Mask out privileged bits.  */
2728     if (IS_USER(s)) {
2729         mask &= CPSR_USER;
2730     }
2731     return mask;
2732 }
2733
2734 /* Returns nonzero if access to the PSR is not permitted. Marks t0 as dead. */
2735 static int gen_set_psr(DisasContext *s, uint32_t mask, int spsr, TCGv_i32 t0)
2736 {
2737     TCGv_i32 tmp;
2738     if (spsr) {
2739         /* ??? This is also undefined in system mode.  */
2740         if (IS_USER(s))
2741             return 1;
2742
2743         tmp = load_cpu_field(spsr);
2744         tcg_gen_andi_i32(tmp, tmp, ~mask);
2745         tcg_gen_andi_i32(t0, t0, mask);
2746         tcg_gen_or_i32(tmp, tmp, t0);
2747         store_cpu_field(tmp, spsr);
2748     } else {
2749         gen_set_cpsr(t0, mask);
2750     }
2751     tcg_temp_free_i32(t0);
2752     gen_lookup_tb(s);
2753     return 0;
2754 }
2755
2756 /* Returns nonzero if access to the PSR is not permitted.  */
2757 static int gen_set_psr_im(DisasContext *s, uint32_t mask, int spsr, uint32_t val)
2758 {
2759     TCGv_i32 tmp;
2760     tmp = tcg_temp_new_i32();
2761     tcg_gen_movi_i32(tmp, val);
2762     return gen_set_psr(s, mask, spsr, tmp);
2763 }
2764
2765 static bool msr_banked_access_decode(DisasContext *s, int r, int sysm, int rn,
2766                                      int *tgtmode, int *regno)
2767 {
2768     /* Decode the r and sysm fields of MSR/MRS banked accesses into
2769      * the target mode and register number, and identify the various
2770      * unpredictable cases.
2771      * MSR (banked) and MRS (banked) are CONSTRAINED UNPREDICTABLE if:
2772      *  + executed in user mode
2773      *  + using R15 as the src/dest register
2774      *  + accessing an unimplemented register
2775      *  + accessing a register that's inaccessible at current PL/security state*
2776      *  + accessing a register that you could access with a different insn
2777      * We choose to UNDEF in all these cases.
2778      * Since we don't know which of the various AArch32 modes we are in
2779      * we have to defer some checks to runtime.
2780      * Accesses to Monitor mode registers from Secure EL1 (which implies
2781      * that EL3 is AArch64) must trap to EL3.
2782      *
2783      * If the access checks fail this function will emit code to take
2784      * an exception and return false. Otherwise it will return true,
2785      * and set *tgtmode and *regno appropriately.
2786      */
2787     int exc_target = default_exception_el(s);
2788
2789     /* These instructions are present only in ARMv8, or in ARMv7 with the
2790      * Virtualization Extensions.
2791      */
2792     if (!arm_dc_feature(s, ARM_FEATURE_V8) &&
2793         !arm_dc_feature(s, ARM_FEATURE_EL2)) {
2794         goto undef;
2795     }
2796
2797     if (IS_USER(s) || rn == 15) {
2798         goto undef;
2799     }
2800
2801     /* The table in the v8 ARM ARM section F5.2.3 describes the encoding
2802      * of registers into (r, sysm).
2803      */
2804     if (r) {
2805         /* SPSRs for other modes */
2806         switch (sysm) {
2807         case 0xe: /* SPSR_fiq */
2808             *tgtmode = ARM_CPU_MODE_FIQ;
2809             break;
2810         case 0x10: /* SPSR_irq */
2811             *tgtmode = ARM_CPU_MODE_IRQ;
2812             break;
2813         case 0x12: /* SPSR_svc */
2814             *tgtmode = ARM_CPU_MODE_SVC;
2815             break;
2816         case 0x14: /* SPSR_abt */
2817             *tgtmode = ARM_CPU_MODE_ABT;
2818             break;
2819         case 0x16: /* SPSR_und */
2820             *tgtmode = ARM_CPU_MODE_UND;
2821             break;
2822         case 0x1c: /* SPSR_mon */
2823             *tgtmode = ARM_CPU_MODE_MON;
2824             break;
2825         case 0x1e: /* SPSR_hyp */
2826             *tgtmode = ARM_CPU_MODE_HYP;
2827             break;
2828         default: /* unallocated */
2829             goto undef;
2830         }
2831         /* We arbitrarily assign SPSR a register number of 16. */
2832         *regno = 16;
2833     } else {
2834         /* general purpose registers for other modes */
2835         switch (sysm) {
2836         case 0x0 ... 0x6:   /* 0b00xxx : r8_usr ... r14_usr */
2837             *tgtmode = ARM_CPU_MODE_USR;
2838             *regno = sysm + 8;
2839             break;
2840         case 0x8 ... 0xe:   /* 0b01xxx : r8_fiq ... r14_fiq */
2841             *tgtmode = ARM_CPU_MODE_FIQ;
2842             *regno = sysm;
2843             break;
2844         case 0x10 ... 0x11: /* 0b1000x : r14_irq, r13_irq */
2845             *tgtmode = ARM_CPU_MODE_IRQ;
2846             *regno = sysm & 1 ? 13 : 14;
2847             break;
2848         case 0x12 ... 0x13: /* 0b1001x : r14_svc, r13_svc */
2849             *tgtmode = ARM_CPU_MODE_SVC;
2850             *regno = sysm & 1 ? 13 : 14;
2851             break;
2852         case 0x14 ... 0x15: /* 0b1010x : r14_abt, r13_abt */
2853             *tgtmode = ARM_CPU_MODE_ABT;
2854             *regno = sysm & 1 ? 13 : 14;
2855             break;
2856         case 0x16 ... 0x17: /* 0b1011x : r14_und, r13_und */
2857             *tgtmode = ARM_CPU_MODE_UND;
2858             *regno = sysm & 1 ? 13 : 14;
2859             break;
2860         case 0x1c ... 0x1d: /* 0b1110x : r14_mon, r13_mon */
2861             *tgtmode = ARM_CPU_MODE_MON;
2862             *regno = sysm & 1 ? 13 : 14;
2863             break;
2864         case 0x1e ... 0x1f: /* 0b1111x : elr_hyp, r13_hyp */
2865             *tgtmode = ARM_CPU_MODE_HYP;
2866             /* Arbitrarily pick 17 for ELR_Hyp (which is not a banked LR!) */
2867             *regno = sysm & 1 ? 13 : 17;
2868             break;
2869         default: /* unallocated */
2870             goto undef;
2871         }
2872     }
2873
2874     /* Catch the 'accessing inaccessible register' cases we can detect
2875      * at translate time.
2876      */
2877     switch (*tgtmode) {
2878     case ARM_CPU_MODE_MON:
2879         if (!arm_dc_feature(s, ARM_FEATURE_EL3) || s->ns) {
2880             goto undef;
2881         }
2882         if (s->current_el == 1) {
2883             /* If we're in Secure EL1 (which implies that EL3 is AArch64)
2884              * then accesses to Mon registers trap to EL3
2885              */
2886             exc_target = 3;
2887             goto undef;
2888         }
2889         break;
2890     case ARM_CPU_MODE_HYP:
2891         /*
2892          * SPSR_hyp and r13_hyp can only be accessed from Monitor mode
2893          * (and so we can forbid accesses from EL2 or below). elr_hyp
2894          * can be accessed also from Hyp mode, so forbid accesses from
2895          * EL0 or EL1.
2896          */
2897         if (!arm_dc_feature(s, ARM_FEATURE_EL2) || s->current_el < 2 ||
2898             (s->current_el < 3 && *regno != 17)) {
2899             goto undef;
2900         }
2901         break;
2902     default:
2903         break;
2904     }
2905
2906     return true;
2907
2908 undef:
2909     /* If we get here then some access check did not pass */
2910     gen_exception_insn(s, s->pc_curr, EXCP_UDEF,
2911                        syn_uncategorized(), exc_target);
2912     return false;
2913 }
2914
2915 static void gen_msr_banked(DisasContext *s, int r, int sysm, int rn)
2916 {
2917     TCGv_i32 tcg_reg, tcg_tgtmode, tcg_regno;
2918     int tgtmode = 0, regno = 0;
2919
2920     if (!msr_banked_access_decode(s, r, sysm, rn, &tgtmode, &regno)) {
2921         return;
2922     }
2923
2924     /* Sync state because msr_banked() can raise exceptions */
2925     gen_set_condexec(s);
2926     gen_set_pc_im(s, s->pc_curr);
2927     tcg_reg = load_reg(s, rn);
2928     tcg_tgtmode = tcg_const_i32(tgtmode);
2929     tcg_regno = tcg_const_i32(regno);
2930     gen_helper_msr_banked(cpu_env, tcg_reg, tcg_tgtmode, tcg_regno);
2931     tcg_temp_free_i32(tcg_tgtmode);
2932     tcg_temp_free_i32(tcg_regno);
2933     tcg_temp_free_i32(tcg_reg);
2934     s->base.is_jmp = DISAS_UPDATE;
2935 }
2936
2937 static void gen_mrs_banked(DisasContext *s, int r, int sysm, int rn)
2938 {
2939     TCGv_i32 tcg_reg, tcg_tgtmode, tcg_regno;
2940     int tgtmode = 0, regno = 0;
2941
2942     if (!msr_banked_access_decode(s, r, sysm, rn, &tgtmode, &regno)) {
2943         return;
2944     }
2945
2946     /* Sync state because mrs_banked() can raise exceptions */
2947     gen_set_condexec(s);
2948     gen_set_pc_im(s, s->pc_curr);
2949     tcg_reg = tcg_temp_new_i32();
2950     tcg_tgtmode = tcg_const_i32(tgtmode);
2951     tcg_regno = tcg_const_i32(regno);
2952     gen_helper_mrs_banked(tcg_reg, cpu_env, tcg_tgtmode, tcg_regno);
2953     tcg_temp_free_i32(tcg_tgtmode);
2954     tcg_temp_free_i32(tcg_regno);
2955     store_reg(s, rn, tcg_reg);
2956     s->base.is_jmp = DISAS_UPDATE;
2957 }
2958
2959 /* Store value to PC as for an exception return (ie don't
2960  * mask bits). The subsequent call to gen_helper_cpsr_write_eret()
2961  * will do the masking based on the new value of the Thumb bit.
2962  */
2963 static void store_pc_exc_ret(DisasContext *s, TCGv_i32 pc)
2964 {
2965     tcg_gen_mov_i32(cpu_R[15], pc);
2966     tcg_temp_free_i32(pc);
2967 }
2968
2969 /* Generate a v6 exception return.  Marks both values as dead.  */
2970 static void gen_rfe(DisasContext *s, TCGv_i32 pc, TCGv_i32 cpsr)
2971 {
2972     store_pc_exc_ret(s, pc);
2973     /* The cpsr_write_eret helper will mask the low bits of PC
2974      * appropriately depending on the new Thumb bit, so it must
2975      * be called after storing the new PC.
2976      */
2977     if (tb_cflags(s->base.tb) & CF_USE_ICOUNT) {
2978         gen_io_start();
2979     }
2980     gen_helper_cpsr_write_eret(cpu_env, cpsr);
2981     tcg_temp_free_i32(cpsr);
2982     /* Must exit loop to check un-masked IRQs */
2983     s->base.is_jmp = DISAS_EXIT;
2984 }
2985
2986 /* Generate an old-style exception return. Marks pc as dead. */
2987 static void gen_exception_return(DisasContext *s, TCGv_i32 pc)
2988 {
2989     gen_rfe(s, pc, load_cpu_field(spsr));
2990 }
2991
2992 #define CPU_V001 cpu_V0, cpu_V0, cpu_V1
2993
2994 static inline void gen_neon_add(int size, TCGv_i32 t0, TCGv_i32 t1)
2995 {
2996     switch (size) {
2997     case 0: gen_helper_neon_add_u8(t0, t0, t1); break;
2998     case 1: gen_helper_neon_add_u16(t0, t0, t1); break;
2999     case 2: tcg_gen_add_i32(t0, t0, t1); break;
3000     default: abort();
3001     }
3002 }
3003
3004 static inline void gen_neon_rsb(int size, TCGv_i32 t0, TCGv_i32 t1)
3005 {
3006     switch (size) {
3007     case 0: gen_helper_neon_sub_u8(t0, t1, t0); break;
3008     case 1: gen_helper_neon_sub_u16(t0, t1, t0); break;
3009     case 2: tcg_gen_sub_i32(t0, t1, t0); break;
3010     default: return;
3011     }
3012 }
3013
3014 #define GEN_NEON_INTEGER_OP_ENV(name) do { \
3015     switch ((size << 1) | u) { \
3016     case 0: \
3017         gen_helper_neon_##name##_s8(tmp, cpu_env, tmp, tmp2); \
3018         break; \
3019     case 1: \
3020         gen_helper_neon_##name##_u8(tmp, cpu_env, tmp, tmp2); \
3021         break; \
3022     case 2: \
3023         gen_helper_neon_##name##_s16(tmp, cpu_env, tmp, tmp2); \
3024         break; \
3025     case 3: \
3026         gen_helper_neon_##name##_u16(tmp, cpu_env, tmp, tmp2); \
3027         break; \
3028     case 4: \
3029         gen_helper_neon_##name##_s32(tmp, cpu_env, tmp, tmp2); \
3030         break; \
3031     case 5: \
3032         gen_helper_neon_##name##_u32(tmp, cpu_env, tmp, tmp2); \
3033         break; \
3034     default: return 1; \
3035     }} while (0)
3036
3037 #define GEN_NEON_INTEGER_OP(name) do { \
3038     switch ((size << 1) | u) { \
3039     case 0: \
3040         gen_helper_neon_##name##_s8(tmp, tmp, tmp2); \
3041         break; \
3042     case 1: \
3043         gen_helper_neon_##name##_u8(tmp, tmp, tmp2); \
3044         break; \
3045     case 2: \
3046         gen_helper_neon_##name##_s16(tmp, tmp, tmp2); \
3047         break; \
3048     case 3: \
3049         gen_helper_neon_##name##_u16(tmp, tmp, tmp2); \
3050         break; \
3051     case 4: \
3052         gen_helper_neon_##name##_s32(tmp, tmp, tmp2); \
3053         break; \
3054     case 5: \
3055         gen_helper_neon_##name##_u32(tmp, tmp, tmp2); \
3056         break; \
3057     default: return 1; \
3058     }} while (0)
3059
3060 static TCGv_i32 neon_load_scratch(int scratch)
3061 {
3062     TCGv_i32 tmp = tcg_temp_new_i32();
3063     tcg_gen_ld_i32(tmp, cpu_env, offsetof(CPUARMState, vfp.scratch[scratch]));
3064     return tmp;
3065 }
3066
3067 static void neon_store_scratch(int scratch, TCGv_i32 var)
3068 {
3069     tcg_gen_st_i32(var, cpu_env, offsetof(CPUARMState, vfp.scratch[scratch]));
3070     tcg_temp_free_i32(var);
3071 }
3072
3073 static inline TCGv_i32 neon_get_scalar(int size, int reg)
3074 {
3075     TCGv_i32 tmp;
3076     if (size == 1) {
3077         tmp = neon_load_reg(reg & 7, reg >> 4);
3078         if (reg & 8) {
3079             gen_neon_dup_high16(tmp);
3080         } else {
3081             gen_neon_dup_low16(tmp);
3082         }
3083     } else {
3084         tmp = neon_load_reg(reg & 15, reg >> 4);
3085     }
3086     return tmp;
3087 }
3088
3089 static int gen_neon_unzip(int rd, int rm, int size, int q)
3090 {
3091     TCGv_ptr pd, pm;
3092
3093     if (!q && size == 2) {
3094         return 1;
3095     }
3096     pd = vfp_reg_ptr(true, rd);
3097     pm = vfp_reg_ptr(true, rm);
3098     if (q) {
3099         switch (size) {
3100         case 0:
3101             gen_helper_neon_qunzip8(pd, pm);
3102             break;
3103         case 1:
3104             gen_helper_neon_qunzip16(pd, pm);
3105             break;
3106         case 2:
3107             gen_helper_neon_qunzip32(pd, pm);
3108             break;
3109         default:
3110             abort();
3111         }
3112     } else {
3113         switch (size) {
3114         case 0:
3115             gen_helper_neon_unzip8(pd, pm);
3116             break;
3117         case 1:
3118             gen_helper_neon_unzip16(pd, pm);
3119             break;
3120         default:
3121             abort();
3122         }
3123     }
3124     tcg_temp_free_ptr(pd);
3125     tcg_temp_free_ptr(pm);
3126     return 0;
3127 }
3128
3129 static int gen_neon_zip(int rd, int rm, int size, int q)
3130 {
3131     TCGv_ptr pd, pm;
3132
3133     if (!q && size == 2) {
3134         return 1;
3135     }
3136     pd = vfp_reg_ptr(true, rd);
3137     pm = vfp_reg_ptr(true, rm);
3138     if (q) {
3139         switch (size) {
3140         case 0:
3141             gen_helper_neon_qzip8(pd, pm);
3142             break;
3143         case 1:
3144             gen_helper_neon_qzip16(pd, pm);
3145             break;
3146         case 2:
3147             gen_helper_neon_qzip32(pd, pm);
3148             break;
3149         default:
3150             abort();
3151         }
3152     } else {
3153         switch (size) {
3154         case 0:
3155             gen_helper_neon_zip8(pd, pm);
3156             break;
3157         case 1:
3158             gen_helper_neon_zip16(pd, pm);
3159             break;
3160         default:
3161             abort();
3162         }
3163     }
3164     tcg_temp_free_ptr(pd);
3165     tcg_temp_free_ptr(pm);
3166     return 0;
3167 }
3168
3169 static void gen_neon_trn_u8(TCGv_i32 t0, TCGv_i32 t1)
3170 {
3171     TCGv_i32 rd, tmp;
3172
3173     rd = tcg_temp_new_i32();
3174     tmp = tcg_temp_new_i32();
3175
3176     tcg_gen_shli_i32(rd, t0, 8);
3177     tcg_gen_andi_i32(rd, rd, 0xff00ff00);
3178     tcg_gen_andi_i32(tmp, t1, 0x00ff00ff);
3179     tcg_gen_or_i32(rd, rd, tmp);
3180
3181     tcg_gen_shri_i32(t1, t1, 8);
3182     tcg_gen_andi_i32(t1, t1, 0x00ff00ff);
3183     tcg_gen_andi_i32(tmp, t0, 0xff00ff00);
3184     tcg_gen_or_i32(t1, t1, tmp);
3185     tcg_gen_mov_i32(t0, rd);
3186
3187     tcg_temp_free_i32(tmp);
3188     tcg_temp_free_i32(rd);
3189 }
3190
3191 static void gen_neon_trn_u16(TCGv_i32 t0, TCGv_i32 t1)
3192 {
3193     TCGv_i32 rd, tmp;
3194
3195     rd = tcg_temp_new_i32();
3196     tmp = tcg_temp_new_i32();
3197
3198     tcg_gen_shli_i32(rd, t0, 16);
3199     tcg_gen_andi_i32(tmp, t1, 0xffff);
3200     tcg_gen_or_i32(rd, rd, tmp);
3201     tcg_gen_shri_i32(t1, t1, 16);
3202     tcg_gen_andi_i32(tmp, t0, 0xffff0000);
3203     tcg_gen_or_i32(t1, t1, tmp);
3204     tcg_gen_mov_i32(t0, rd);
3205
3206     tcg_temp_free_i32(tmp);
3207     tcg_temp_free_i32(rd);
3208 }
3209
3210 static inline void gen_neon_narrow(int size, TCGv_i32 dest, TCGv_i64 src)
3211 {
3212     switch (size) {
3213     case 0: gen_helper_neon_narrow_u8(dest, src); break;
3214     case 1: gen_helper_neon_narrow_u16(dest, src); break;
3215     case 2: tcg_gen_extrl_i64_i32(dest, src); break;
3216     default: abort();
3217     }
3218 }
3219
3220 static inline void gen_neon_narrow_sats(int size, TCGv_i32 dest, TCGv_i64 src)
3221 {
3222     switch (size) {
3223     case 0: gen_helper_neon_narrow_sat_s8(dest, cpu_env, src); break;
3224     case 1: gen_helper_neon_narrow_sat_s16(dest, cpu_env, src); break;
3225     case 2: gen_helper_neon_narrow_sat_s32(dest, cpu_env, src); break;
3226     default: abort();
3227     }
3228 }
3229
3230 static inline void gen_neon_narrow_satu(int size, TCGv_i32 dest, TCGv_i64 src)
3231 {
3232     switch (size) {
3233     case 0: gen_helper_neon_narrow_sat_u8(dest, cpu_env, src); break;
3234     case 1: gen_helper_neon_narrow_sat_u16(dest, cpu_env, src); break;
3235     case 2: gen_helper_neon_narrow_sat_u32(dest, cpu_env, src); break;
3236     default: abort();
3237     }
3238 }
3239
3240 static inline void gen_neon_unarrow_sats(int size, TCGv_i32 dest, TCGv_i64 src)
3241 {
3242     switch (size) {
3243     case 0: gen_helper_neon_unarrow_sat8(dest, cpu_env, src); break;
3244     case 1: gen_helper_neon_unarrow_sat16(dest, cpu_env, src); break;
3245     case 2: gen_helper_neon_unarrow_sat32(dest, cpu_env, src); break;
3246     default: abort();
3247     }
3248 }
3249
3250 static inline void gen_neon_shift_narrow(int size, TCGv_i32 var, TCGv_i32 shift,
3251                                          int q, int u)
3252 {
3253     if (q) {
3254         if (u) {
3255             switch (size) {
3256             case 1: gen_helper_neon_rshl_u16(var, var, shift); break;
3257             case 2: gen_helper_neon_rshl_u32(var, var, shift); break;
3258             default: abort();
3259             }
3260         } else {
3261             switch (size) {
3262             case 1: gen_helper_neon_rshl_s16(var, var, shift); break;
3263             case 2: gen_helper_neon_rshl_s32(var, var, shift); break;
3264             default: abort();
3265             }
3266         }
3267     } else {
3268         if (u) {
3269             switch (size) {
3270             case 1: gen_helper_neon_shl_u16(var, var, shift); break;
3271             case 2: gen_ushl_i32(var, var, shift); break;
3272             default: abort();
3273             }
3274         } else {
3275             switch (size) {
3276             case 1: gen_helper_neon_shl_s16(var, var, shift); break;
3277             case 2: gen_sshl_i32(var, var, shift); break;
3278             default: abort();
3279             }
3280         }
3281     }
3282 }
3283
3284 static inline void gen_neon_widen(TCGv_i64 dest, TCGv_i32 src, int size, int u)
3285 {
3286     if (u) {
3287         switch (size) {
3288         case 0: gen_helper_neon_widen_u8(dest, src); break;
3289         case 1: gen_helper_neon_widen_u16(dest, src); break;
3290         case 2: tcg_gen_extu_i32_i64(dest, src); break;
3291         default: abort();
3292         }
3293     } else {
3294         switch (size) {
3295         case 0: gen_helper_neon_widen_s8(dest, src); break;
3296         case 1: gen_helper_neon_widen_s16(dest, src); break;
3297         case 2: tcg_gen_ext_i32_i64(dest, src); break;
3298         default: abort();
3299         }
3300     }
3301     tcg_temp_free_i32(src);
3302 }
3303
3304 static inline void gen_neon_addl(int size)
3305 {
3306     switch (size) {
3307     case 0: gen_helper_neon_addl_u16(CPU_V001); break;
3308     case 1: gen_helper_neon_addl_u32(CPU_V001); break;
3309     case 2: tcg_gen_add_i64(CPU_V001); break;
3310     default: abort();
3311     }
3312 }
3313
3314 static inline void gen_neon_subl(int size)
3315 {
3316     switch (size) {
3317     case 0: gen_helper_neon_subl_u16(CPU_V001); break;
3318     case 1: gen_helper_neon_subl_u32(CPU_V001); break;
3319     case 2: tcg_gen_sub_i64(CPU_V001); break;
3320     default: abort();
3321     }
3322 }
3323
3324 static inline void gen_neon_negl(TCGv_i64 var, int size)
3325 {
3326     switch (size) {
3327     case 0: gen_helper_neon_negl_u16(var, var); break;
3328     case 1: gen_helper_neon_negl_u32(var, var); break;
3329     case 2:
3330         tcg_gen_neg_i64(var, var);
3331         break;
3332     default: abort();
3333     }
3334 }
3335
3336 static inline void gen_neon_addl_saturate(TCGv_i64 op0, TCGv_i64 op1, int size)
3337 {
3338     switch (size) {
3339     case 1: gen_helper_neon_addl_saturate_s32(op0, cpu_env, op0, op1); break;
3340     case 2: gen_helper_neon_addl_saturate_s64(op0, cpu_env, op0, op1); break;
3341     default: abort();
3342     }
3343 }
3344
3345 static inline void gen_neon_mull(TCGv_i64 dest, TCGv_i32 a, TCGv_i32 b,
3346                                  int size, int u)
3347 {
3348     TCGv_i64 tmp;
3349
3350     switch ((size << 1) | u) {
3351     case 0: gen_helper_neon_mull_s8(dest, a, b); break;
3352     case 1: gen_helper_neon_mull_u8(dest, a, b); break;
3353     case 2: gen_helper_neon_mull_s16(dest, a, b); break;
3354     case 3: gen_helper_neon_mull_u16(dest, a, b); break;
3355     case 4:
3356         tmp = gen_muls_i64_i32(a, b);
3357         tcg_gen_mov_i64(dest, tmp);
3358         tcg_temp_free_i64(tmp);
3359         break;
3360     case 5:
3361         tmp = gen_mulu_i64_i32(a, b);
3362         tcg_gen_mov_i64(dest, tmp);
3363         tcg_temp_free_i64(tmp);
3364         break;
3365     default: abort();
3366     }
3367
3368     /* gen_helper_neon_mull_[su]{8|16} do not free their parameters.
3369        Don't forget to clean them now.  */
3370     if (size < 2) {
3371         tcg_temp_free_i32(a);
3372         tcg_temp_free_i32(b);
3373     }
3374 }
3375
3376 static void gen_neon_narrow_op(int op, int u, int size,
3377                                TCGv_i32 dest, TCGv_i64 src)
3378 {
3379     if (op) {
3380         if (u) {
3381             gen_neon_unarrow_sats(size, dest, src);
3382         } else {
3383             gen_neon_narrow(size, dest, src);
3384         }
3385     } else {
3386         if (u) {
3387             gen_neon_narrow_satu(size, dest, src);
3388         } else {
3389             gen_neon_narrow_sats(size, dest, src);
3390         }
3391     }
3392 }
3393
3394 /* Symbolic constants for op fields for Neon 3-register same-length.
3395  * The values correspond to bits [11:8,4]; see the ARM ARM DDI0406B
3396  * table A7-9.
3397  */
3398 #define NEON_3R_VHADD 0
3399 #define NEON_3R_VQADD 1
3400 #define NEON_3R_VRHADD 2
3401 #define NEON_3R_LOGIC 3 /* VAND,VBIC,VORR,VMOV,VORN,VEOR,VBIF,VBIT,VBSL */
3402 #define NEON_3R_VHSUB 4
3403 #define NEON_3R_VQSUB 5
3404 #define NEON_3R_VCGT 6
3405 #define NEON_3R_VCGE 7
3406 #define NEON_3R_VSHL 8
3407 #define NEON_3R_VQSHL 9
3408 #define NEON_3R_VRSHL 10
3409 #define NEON_3R_VQRSHL 11
3410 #define NEON_3R_VMAX 12
3411 #define NEON_3R_VMIN 13
3412 #define NEON_3R_VABD 14
3413 #define NEON_3R_VABA 15
3414 #define NEON_3R_VADD_VSUB 16
3415 #define NEON_3R_VTST_VCEQ 17
3416 #define NEON_3R_VML 18 /* VMLA, VMLS */
3417 #define NEON_3R_VMUL 19
3418 #define NEON_3R_VPMAX 20
3419 #define NEON_3R_VPMIN 21
3420 #define NEON_3R_VQDMULH_VQRDMULH 22
3421 #define NEON_3R_VPADD_VQRDMLAH 23
3422 #define NEON_3R_SHA 24 /* SHA1C,SHA1P,SHA1M,SHA1SU0,SHA256H{2},SHA256SU1 */
3423 #define NEON_3R_VFM_VQRDMLSH 25 /* VFMA, VFMS, VQRDMLSH */
3424 #define NEON_3R_FLOAT_ARITH 26 /* float VADD, VSUB, VPADD, VABD */
3425 #define NEON_3R_FLOAT_MULTIPLY 27 /* float VMLA, VMLS, VMUL */
3426 #define NEON_3R_FLOAT_CMP 28 /* float VCEQ, VCGE, VCGT */
3427 #define NEON_3R_FLOAT_ACMP 29 /* float VACGE, VACGT, VACLE, VACLT */
3428 #define NEON_3R_FLOAT_MINMAX 30 /* float VMIN, VMAX */
3429 #define NEON_3R_FLOAT_MISC 31 /* float VRECPS, VRSQRTS, VMAXNM/MINNM */
3430
3431 static const uint8_t neon_3r_sizes[] = {
3432     [NEON_3R_VHADD] = 0x7,
3433     [NEON_3R_VQADD] = 0xf,
3434     [NEON_3R_VRHADD] = 0x7,
3435     [NEON_3R_LOGIC] = 0xf, /* size field encodes op type */
3436     [NEON_3R_VHSUB] = 0x7,
3437     [NEON_3R_VQSUB] = 0xf,
3438     [NEON_3R_VCGT] = 0x7,
3439     [NEON_3R_VCGE] = 0x7,
3440     [NEON_3R_VSHL] = 0xf,
3441     [NEON_3R_VQSHL] = 0xf,
3442     [NEON_3R_VRSHL] = 0xf,
3443     [NEON_3R_VQRSHL] = 0xf,
3444     [NEON_3R_VMAX] = 0x7,
3445     [NEON_3R_VMIN] = 0x7,
3446     [NEON_3R_VABD] = 0x7,
3447     [NEON_3R_VABA] = 0x7,
3448     [NEON_3R_VADD_VSUB] = 0xf,
3449     [NEON_3R_VTST_VCEQ] = 0x7,
3450     [NEON_3R_VML] = 0x7,
3451     [NEON_3R_VMUL] = 0x7,
3452     [NEON_3R_VPMAX] = 0x7,
3453     [NEON_3R_VPMIN] = 0x7,
3454     [NEON_3R_VQDMULH_VQRDMULH] = 0x6,
3455     [NEON_3R_VPADD_VQRDMLAH] = 0x7,
3456     [NEON_3R_SHA] = 0xf, /* size field encodes op type */
3457     [NEON_3R_VFM_VQRDMLSH] = 0x7, /* For VFM, size bit 1 encodes op */
3458     [NEON_3R_FLOAT_ARITH] = 0x5, /* size bit 1 encodes op */
3459     [NEON_3R_FLOAT_MULTIPLY] = 0x5, /* size bit 1 encodes op */
3460     [NEON_3R_FLOAT_CMP] = 0x5, /* size bit 1 encodes op */
3461     [NEON_3R_FLOAT_ACMP] = 0x5, /* size bit 1 encodes op */
3462     [NEON_3R_FLOAT_MINMAX] = 0x5, /* size bit 1 encodes op */
3463     [NEON_3R_FLOAT_MISC] = 0x5, /* size bit 1 encodes op */
3464 };
3465
3466 /* Symbolic constants for op fields for Neon 2-register miscellaneous.
3467  * The values correspond to bits [17:16,10:7]; see the ARM ARM DDI0406B
3468  * table A7-13.
3469  */
3470 #define NEON_2RM_VREV64 0
3471 #define NEON_2RM_VREV32 1
3472 #define NEON_2RM_VREV16 2
3473 #define NEON_2RM_VPADDL 4
3474 #define NEON_2RM_VPADDL_U 5
3475 #define NEON_2RM_AESE 6 /* Includes AESD */
3476 #define NEON_2RM_AESMC 7 /* Includes AESIMC */
3477 #define NEON_2RM_VCLS 8
3478 #define NEON_2RM_VCLZ 9
3479 #define NEON_2RM_VCNT 10
3480 #define NEON_2RM_VMVN 11
3481 #define NEON_2RM_VPADAL 12
3482 #define NEON_2RM_VPADAL_U 13
3483 #define NEON_2RM_VQABS 14
3484 #define NEON_2RM_VQNEG 15
3485 #define NEON_2RM_VCGT0 16
3486 #define NEON_2RM_VCGE0 17
3487 #define NEON_2RM_VCEQ0 18
3488 #define NEON_2RM_VCLE0 19
3489 #define NEON_2RM_VCLT0 20
3490 #define NEON_2RM_SHA1H 21
3491 #define NEON_2RM_VABS 22
3492 #define NEON_2RM_VNEG 23
3493 #define NEON_2RM_VCGT0_F 24
3494 #define NEON_2RM_VCGE0_F 25
3495 #define NEON_2RM_VCEQ0_F 26
3496 #define NEON_2RM_VCLE0_F 27
3497 #define NEON_2RM_VCLT0_F 28
3498 #define NEON_2RM_VABS_F 30
3499 #define NEON_2RM_VNEG_F 31
3500 #define NEON_2RM_VSWP 32
3501 #define NEON_2RM_VTRN 33
3502 #define NEON_2RM_VUZP 34
3503 #define NEON_2RM_VZIP 35
3504 #define NEON_2RM_VMOVN 36 /* Includes VQMOVN, VQMOVUN */
3505 #define NEON_2RM_VQMOVN 37 /* Includes VQMOVUN */
3506 #define NEON_2RM_VSHLL 38
3507 #define NEON_2RM_SHA1SU1 39 /* Includes SHA256SU0 */
3508 #define NEON_2RM_VRINTN 40
3509 #define NEON_2RM_VRINTX 41
3510 #define NEON_2RM_VRINTA 42
3511 #define NEON_2RM_VRINTZ 43
3512 #define NEON_2RM_VCVT_F16_F32 44
3513 #define NEON_2RM_VRINTM 45
3514 #define NEON_2RM_VCVT_F32_F16 46
3515 #define NEON_2RM_VRINTP 47
3516 #define NEON_2RM_VCVTAU 48
3517 #define NEON_2RM_VCVTAS 49
3518 #define NEON_2RM_VCVTNU 50
3519 #define NEON_2RM_VCVTNS 51
3520 #define NEON_2RM_VCVTPU 52
3521 #define NEON_2RM_VCVTPS 53
3522 #define NEON_2RM_VCVTMU 54
3523 #define NEON_2RM_VCVTMS 55
3524 #define NEON_2RM_VRECPE 56
3525 #define NEON_2RM_VRSQRTE 57
3526 #define NEON_2RM_VRECPE_F 58
3527 #define NEON_2RM_VRSQRTE_F 59
3528 #define NEON_2RM_VCVT_FS 60
3529 #define NEON_2RM_VCVT_FU 61
3530 #define NEON_2RM_VCVT_SF 62
3531 #define NEON_2RM_VCVT_UF 63
3532
3533 static bool neon_2rm_is_v8_op(int op)
3534 {
3535     /* Return true if this neon 2reg-misc op is ARMv8 and up */
3536     switch (op) {
3537     case NEON_2RM_VRINTN:
3538     case NEON_2RM_VRINTA:
3539     case NEON_2RM_VRINTM:
3540     case NEON_2RM_VRINTP:
3541     case NEON_2RM_VRINTZ:
3542     case NEON_2RM_VRINTX:
3543     case NEON_2RM_VCVTAU:
3544     case NEON_2RM_VCVTAS:
3545     case NEON_2RM_VCVTNU:
3546     case NEON_2RM_VCVTNS:
3547     case NEON_2RM_VCVTPU:
3548     case NEON_2RM_VCVTPS:
3549     case NEON_2RM_VCVTMU:
3550     case NEON_2RM_VCVTMS:
3551         return true;
3552     default:
3553         return false;
3554     }
3555 }
3556
3557 /* Each entry in this array has bit n set if the insn allows
3558  * size value n (otherwise it will UNDEF). Since unallocated
3559  * op values will have no bits set they always UNDEF.
3560  */
3561 static const uint8_t neon_2rm_sizes[] = {
3562     [NEON_2RM_VREV64] = 0x7,
3563     [NEON_2RM_VREV32] = 0x3,
3564     [NEON_2RM_VREV16] = 0x1,
3565     [NEON_2RM_VPADDL] = 0x7,
3566     [NEON_2RM_VPADDL_U] = 0x7,
3567     [NEON_2RM_AESE] = 0x1,
3568     [NEON_2RM_AESMC] = 0x1,
3569     [NEON_2RM_VCLS] = 0x7,
3570     [NEON_2RM_VCLZ] = 0x7,
3571     [NEON_2RM_VCNT] = 0x1,
3572     [NEON_2RM_VMVN] = 0x1,
3573     [NEON_2RM_VPADAL] = 0x7,
3574     [NEON_2RM_VPADAL_U] = 0x7,
3575     [NEON_2RM_VQABS] = 0x7,
3576     [NEON_2RM_VQNEG] = 0x7,
3577     [NEON_2RM_VCGT0] = 0x7,
3578     [NEON_2RM_VCGE0] = 0x7,
3579     [NEON_2RM_VCEQ0] = 0x7,
3580     [NEON_2RM_VCLE0] = 0x7,
3581     [NEON_2RM_VCLT0] = 0x7,
3582     [NEON_2RM_SHA1H] = 0x4,
3583     [NEON_2RM_VABS] = 0x7,
3584     [NEON_2RM_VNEG] = 0x7,
3585     [NEON_2RM_VCGT0_F] = 0x4,
3586     [NEON_2RM_VCGE0_F] = 0x4,
3587     [NEON_2RM_VCEQ0_F] = 0x4,
3588     [NEON_2RM_VCLE0_F] = 0x4,
3589     [NEON_2RM_VCLT0_F] = 0x4,
3590     [NEON_2RM_VABS_F] = 0x4,
3591     [NEON_2RM_VNEG_F] = 0x4,
3592     [NEON_2RM_VSWP] = 0x1,
3593     [NEON_2RM_VTRN] = 0x7,
3594     [NEON_2RM_VUZP] = 0x7,
3595     [NEON_2RM_VZIP] = 0x7,
3596     [NEON_2RM_VMOVN] = 0x7,
3597     [NEON_2RM_VQMOVN] = 0x7,
3598     [NEON_2RM_VSHLL] = 0x7,
3599     [NEON_2RM_SHA1SU1] = 0x4,
3600     [NEON_2RM_VRINTN] = 0x4,
3601     [NEON_2RM_VRINTX] = 0x4,
3602     [NEON_2RM_VRINTA] = 0x4,
3603     [NEON_2RM_VRINTZ] = 0x4,
3604     [NEON_2RM_VCVT_F16_F32] = 0x2,
3605     [NEON_2RM_VRINTM] = 0x4,
3606     [NEON_2RM_VCVT_F32_F16] = 0x2,
3607     [NEON_2RM_VRINTP] = 0x4,
3608     [NEON_2RM_VCVTAU] = 0x4,
3609     [NEON_2RM_VCVTAS] = 0x4,
3610     [NEON_2RM_VCVTNU] = 0x4,
3611     [NEON_2RM_VCVTNS] = 0x4,
3612     [NEON_2RM_VCVTPU] = 0x4,
3613     [NEON_2RM_VCVTPS] = 0x4,
3614     [NEON_2RM_VCVTMU] = 0x4,
3615     [NEON_2RM_VCVTMS] = 0x4,
3616     [NEON_2RM_VRECPE] = 0x4,
3617     [NEON_2RM_VRSQRTE] = 0x4,
3618     [NEON_2RM_VRECPE_F] = 0x4,
3619     [NEON_2RM_VRSQRTE_F] = 0x4,
3620     [NEON_2RM_VCVT_FS] = 0x4,
3621     [NEON_2RM_VCVT_FU] = 0x4,
3622     [NEON_2RM_VCVT_SF] = 0x4,
3623     [NEON_2RM_VCVT_UF] = 0x4,
3624 };
3625
3626 static void gen_gvec_fn3_qc(uint32_t rd_ofs, uint32_t rn_ofs, uint32_t rm_ofs,
3627                             uint32_t opr_sz, uint32_t max_sz,
3628                             gen_helper_gvec_3_ptr *fn)
3629 {
3630     TCGv_ptr qc_ptr = tcg_temp_new_ptr();
3631
3632     tcg_gen_addi_ptr(qc_ptr, cpu_env, offsetof(CPUARMState, vfp.qc));
3633     tcg_gen_gvec_3_ptr(rd_ofs, rn_ofs, rm_ofs, qc_ptr,
3634                        opr_sz, max_sz, 0, fn);
3635     tcg_temp_free_ptr(qc_ptr);
3636 }
3637
3638 void gen_gvec_sqrdmlah_qc(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
3639                           uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
3640 {
3641     static gen_helper_gvec_3_ptr * const fns[2] = {
3642         gen_helper_gvec_qrdmlah_s16, gen_helper_gvec_qrdmlah_s32
3643     };
3644     tcg_debug_assert(vece >= 1 && vece <= 2);
3645     gen_gvec_fn3_qc(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, fns[vece - 1]);
3646 }
3647
3648 void gen_gvec_sqrdmlsh_qc(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
3649                           uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
3650 {
3651     static gen_helper_gvec_3_ptr * const fns[2] = {
3652         gen_helper_gvec_qrdmlsh_s16, gen_helper_gvec_qrdmlsh_s32
3653     };
3654     tcg_debug_assert(vece >= 1 && vece <= 2);
3655     gen_gvec_fn3_qc(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, fns[vece - 1]);
3656 }
3657
3658 #define GEN_CMP0(NAME, COND)                                            \
3659     static void gen_##NAME##0_i32(TCGv_i32 d, TCGv_i32 a)               \
3660     {                                                                   \
3661         tcg_gen_setcondi_i32(COND, d, a, 0);                            \
3662         tcg_gen_neg_i32(d, d);                                          \
3663     }                                                                   \
3664     static void gen_##NAME##0_i64(TCGv_i64 d, TCGv_i64 a)               \
3665     {                                                                   \
3666         tcg_gen_setcondi_i64(COND, d, a, 0);                            \
3667         tcg_gen_neg_i64(d, d);                                          \
3668     }                                                                   \
3669     static void gen_##NAME##0_vec(unsigned vece, TCGv_vec d, TCGv_vec a) \
3670     {                                                                   \
3671         TCGv_vec zero = tcg_const_zeros_vec_matching(d);                \
3672         tcg_gen_cmp_vec(COND, vece, d, a, zero);                        \
3673         tcg_temp_free_vec(zero);                                        \
3674     }                                                                   \
3675     void gen_gvec_##NAME##0(unsigned vece, uint32_t d, uint32_t m,      \
3676                             uint32_t opr_sz, uint32_t max_sz)           \
3677     {                                                                   \
3678         const GVecGen2 op[4] = {                                        \
3679             { .fno = gen_helper_gvec_##NAME##0_b,                       \
3680               .fniv = gen_##NAME##0_vec,                                \
3681               .opt_opc = vecop_list_cmp,                                \
3682               .vece = MO_8 },                                           \
3683             { .fno = gen_helper_gvec_##NAME##0_h,                       \
3684               .fniv = gen_##NAME##0_vec,                                \
3685               .opt_opc = vecop_list_cmp,                                \
3686               .vece = MO_16 },                                          \
3687             { .fni4 = gen_##NAME##0_i32,                                \
3688               .fniv = gen_##NAME##0_vec,                                \
3689               .opt_opc = vecop_list_cmp,                                \
3690               .vece = MO_32 },                                          \
3691             { .fni8 = gen_##NAME##0_i64,                                \
3692               .fniv = gen_##NAME##0_vec,                                \
3693               .opt_opc = vecop_list_cmp,                                \
3694               .prefer_i64 = TCG_TARGET_REG_BITS == 64,                  \
3695               .vece = MO_64 },                                          \
3696         };                                                              \
3697         tcg_gen_gvec_2(d, m, opr_sz, max_sz, &op[vece]);                \
3698     }
3699
3700 static const TCGOpcode vecop_list_cmp[] = {
3701     INDEX_op_cmp_vec, 0
3702 };
3703
3704 GEN_CMP0(ceq, TCG_COND_EQ)
3705 GEN_CMP0(cle, TCG_COND_LE)
3706 GEN_CMP0(cge, TCG_COND_GE)
3707 GEN_CMP0(clt, TCG_COND_LT)
3708 GEN_CMP0(cgt, TCG_COND_GT)
3709
3710 #undef GEN_CMP0
3711
3712 static void gen_ssra8_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
3713 {
3714     tcg_gen_vec_sar8i_i64(a, a, shift);
3715     tcg_gen_vec_add8_i64(d, d, a);
3716 }
3717
3718 static void gen_ssra16_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
3719 {
3720     tcg_gen_vec_sar16i_i64(a, a, shift);
3721     tcg_gen_vec_add16_i64(d, d, a);
3722 }
3723
3724 static void gen_ssra32_i32(TCGv_i32 d, TCGv_i32 a, int32_t shift)
3725 {
3726     tcg_gen_sari_i32(a, a, shift);
3727     tcg_gen_add_i32(d, d, a);
3728 }
3729
3730 static void gen_ssra64_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
3731 {
3732     tcg_gen_sari_i64(a, a, shift);
3733     tcg_gen_add_i64(d, d, a);
3734 }
3735
3736 static void gen_ssra_vec(unsigned vece, TCGv_vec d, TCGv_vec a, int64_t sh)
3737 {
3738     tcg_gen_sari_vec(vece, a, a, sh);
3739     tcg_gen_add_vec(vece, d, d, a);
3740 }
3741
3742 void gen_gvec_ssra(unsigned vece, uint32_t rd_ofs, uint32_t rm_ofs,
3743                    int64_t shift, uint32_t opr_sz, uint32_t max_sz)
3744 {
3745     static const TCGOpcode vecop_list[] = {
3746         INDEX_op_sari_vec, INDEX_op_add_vec, 0
3747     };
3748     static const GVecGen2i ops[4] = {
3749         { .fni8 = gen_ssra8_i64,
3750           .fniv = gen_ssra_vec,
3751           .fno = gen_helper_gvec_ssra_b,
3752           .load_dest = true,
3753           .opt_opc = vecop_list,
3754           .vece = MO_8 },
3755         { .fni8 = gen_ssra16_i64,
3756           .fniv = gen_ssra_vec,
3757           .fno = gen_helper_gvec_ssra_h,
3758           .load_dest = true,
3759           .opt_opc = vecop_list,
3760           .vece = MO_16 },
3761         { .fni4 = gen_ssra32_i32,
3762           .fniv = gen_ssra_vec,
3763           .fno = gen_helper_gvec_ssra_s,
3764           .load_dest = true,
3765           .opt_opc = vecop_list,
3766           .vece = MO_32 },
3767         { .fni8 = gen_ssra64_i64,
3768           .fniv = gen_ssra_vec,
3769           .fno = gen_helper_gvec_ssra_b,
3770           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
3771           .opt_opc = vecop_list,
3772           .load_dest = true,
3773           .vece = MO_64 },
3774     };
3775
3776     /* tszimm encoding produces immediates in the range [1..esize]. */
3777     tcg_debug_assert(shift > 0);
3778     tcg_debug_assert(shift <= (8 << vece));
3779
3780     /*
3781      * Shifts larger than the element size are architecturally valid.
3782      * Signed results in all sign bits.
3783      */
3784     shift = MIN(shift, (8 << vece) - 1);
3785     tcg_gen_gvec_2i(rd_ofs, rm_ofs, opr_sz, max_sz, shift, &ops[vece]);
3786 }
3787
3788 static void gen_usra8_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
3789 {
3790     tcg_gen_vec_shr8i_i64(a, a, shift);
3791     tcg_gen_vec_add8_i64(d, d, a);
3792 }
3793
3794 static void gen_usra16_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
3795 {
3796     tcg_gen_vec_shr16i_i64(a, a, shift);
3797     tcg_gen_vec_add16_i64(d, d, a);
3798 }
3799
3800 static void gen_usra32_i32(TCGv_i32 d, TCGv_i32 a, int32_t shift)
3801 {
3802     tcg_gen_shri_i32(a, a, shift);
3803     tcg_gen_add_i32(d, d, a);
3804 }
3805
3806 static void gen_usra64_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
3807 {
3808     tcg_gen_shri_i64(a, a, shift);
3809     tcg_gen_add_i64(d, d, a);
3810 }
3811
3812 static void gen_usra_vec(unsigned vece, TCGv_vec d, TCGv_vec a, int64_t sh)
3813 {
3814     tcg_gen_shri_vec(vece, a, a, sh);
3815     tcg_gen_add_vec(vece, d, d, a);
3816 }
3817
3818 void gen_gvec_usra(unsigned vece, uint32_t rd_ofs, uint32_t rm_ofs,
3819                    int64_t shift, uint32_t opr_sz, uint32_t max_sz)
3820 {
3821     static const TCGOpcode vecop_list[] = {
3822         INDEX_op_shri_vec, INDEX_op_add_vec, 0
3823     };
3824     static const GVecGen2i ops[4] = {
3825         { .fni8 = gen_usra8_i64,
3826           .fniv = gen_usra_vec,
3827           .fno = gen_helper_gvec_usra_b,
3828           .load_dest = true,
3829           .opt_opc = vecop_list,
3830           .vece = MO_8, },
3831         { .fni8 = gen_usra16_i64,
3832           .fniv = gen_usra_vec,
3833           .fno = gen_helper_gvec_usra_h,
3834           .load_dest = true,
3835           .opt_opc = vecop_list,
3836           .vece = MO_16, },
3837         { .fni4 = gen_usra32_i32,
3838           .fniv = gen_usra_vec,
3839           .fno = gen_helper_gvec_usra_s,
3840           .load_dest = true,
3841           .opt_opc = vecop_list,
3842           .vece = MO_32, },
3843         { .fni8 = gen_usra64_i64,
3844           .fniv = gen_usra_vec,
3845           .fno = gen_helper_gvec_usra_d,
3846           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
3847           .load_dest = true,
3848           .opt_opc = vecop_list,
3849           .vece = MO_64, },
3850     };
3851
3852     /* tszimm encoding produces immediates in the range [1..esize]. */
3853     tcg_debug_assert(shift > 0);
3854     tcg_debug_assert(shift <= (8 << vece));
3855
3856     /*
3857      * Shifts larger than the element size are architecturally valid.
3858      * Unsigned results in all zeros as input to accumulate: nop.
3859      */
3860     if (shift < (8 << vece)) {
3861         tcg_gen_gvec_2i(rd_ofs, rm_ofs, opr_sz, max_sz, shift, &ops[vece]);
3862     } else {
3863         /* Nop, but we do need to clear the tail. */
3864         tcg_gen_gvec_mov(vece, rd_ofs, rd_ofs, opr_sz, max_sz);
3865     }
3866 }
3867
3868 /*
3869  * Shift one less than the requested amount, and the low bit is
3870  * the rounding bit.  For the 8 and 16-bit operations, because we
3871  * mask the low bit, we can perform a normal integer shift instead
3872  * of a vector shift.
3873  */
3874 static void gen_srshr8_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
3875 {
3876     TCGv_i64 t = tcg_temp_new_i64();
3877
3878     tcg_gen_shri_i64(t, a, sh - 1);
3879     tcg_gen_andi_i64(t, t, dup_const(MO_8, 1));
3880     tcg_gen_vec_sar8i_i64(d, a, sh);
3881     tcg_gen_vec_add8_i64(d, d, t);
3882     tcg_temp_free_i64(t);
3883 }
3884
3885 static void gen_srshr16_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
3886 {
3887     TCGv_i64 t = tcg_temp_new_i64();
3888
3889     tcg_gen_shri_i64(t, a, sh - 1);
3890     tcg_gen_andi_i64(t, t, dup_const(MO_16, 1));
3891     tcg_gen_vec_sar16i_i64(d, a, sh);
3892     tcg_gen_vec_add16_i64(d, d, t);
3893     tcg_temp_free_i64(t);
3894 }
3895
3896 static void gen_srshr32_i32(TCGv_i32 d, TCGv_i32 a, int32_t sh)
3897 {
3898     TCGv_i32 t = tcg_temp_new_i32();
3899
3900     tcg_gen_extract_i32(t, a, sh - 1, 1);
3901     tcg_gen_sari_i32(d, a, sh);
3902     tcg_gen_add_i32(d, d, t);
3903     tcg_temp_free_i32(t);
3904 }
3905
3906 static void gen_srshr64_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
3907 {
3908     TCGv_i64 t = tcg_temp_new_i64();
3909
3910     tcg_gen_extract_i64(t, a, sh - 1, 1);
3911     tcg_gen_sari_i64(d, a, sh);
3912     tcg_gen_add_i64(d, d, t);
3913     tcg_temp_free_i64(t);
3914 }
3915
3916 static void gen_srshr_vec(unsigned vece, TCGv_vec d, TCGv_vec a, int64_t sh)
3917 {
3918     TCGv_vec t = tcg_temp_new_vec_matching(d);
3919     TCGv_vec ones = tcg_temp_new_vec_matching(d);
3920
3921     tcg_gen_shri_vec(vece, t, a, sh - 1);
3922     tcg_gen_dupi_vec(vece, ones, 1);
3923     tcg_gen_and_vec(vece, t, t, ones);
3924     tcg_gen_sari_vec(vece, d, a, sh);
3925     tcg_gen_add_vec(vece, d, d, t);
3926
3927     tcg_temp_free_vec(t);
3928     tcg_temp_free_vec(ones);
3929 }
3930
3931 void gen_gvec_srshr(unsigned vece, uint32_t rd_ofs, uint32_t rm_ofs,
3932                     int64_t shift, uint32_t opr_sz, uint32_t max_sz)
3933 {
3934     static const TCGOpcode vecop_list[] = {
3935         INDEX_op_shri_vec, INDEX_op_sari_vec, INDEX_op_add_vec, 0
3936     };
3937     static const GVecGen2i ops[4] = {
3938         { .fni8 = gen_srshr8_i64,
3939           .fniv = gen_srshr_vec,
3940           .fno = gen_helper_gvec_srshr_b,
3941           .opt_opc = vecop_list,
3942           .vece = MO_8 },
3943         { .fni8 = gen_srshr16_i64,
3944           .fniv = gen_srshr_vec,
3945           .fno = gen_helper_gvec_srshr_h,
3946           .opt_opc = vecop_list,
3947           .vece = MO_16 },
3948         { .fni4 = gen_srshr32_i32,
3949           .fniv = gen_srshr_vec,
3950           .fno = gen_helper_gvec_srshr_s,
3951           .opt_opc = vecop_list,
3952           .vece = MO_32 },
3953         { .fni8 = gen_srshr64_i64,
3954           .fniv = gen_srshr_vec,
3955           .fno = gen_helper_gvec_srshr_d,
3956           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
3957           .opt_opc = vecop_list,
3958           .vece = MO_64 },
3959     };
3960
3961     /* tszimm encoding produces immediates in the range [1..esize] */
3962     tcg_debug_assert(shift > 0);
3963     tcg_debug_assert(shift <= (8 << vece));
3964
3965     if (shift == (8 << vece)) {
3966         /*
3967          * Shifts larger than the element size are architecturally valid.
3968          * Signed results in all sign bits.  With rounding, this produces
3969          *   (-1 + 1) >> 1 == 0, or (0 + 1) >> 1 == 0.
3970          * I.e. always zero.
3971          */
3972         tcg_gen_gvec_dup_imm(vece, rd_ofs, opr_sz, max_sz, 0);
3973     } else {
3974         tcg_gen_gvec_2i(rd_ofs, rm_ofs, opr_sz, max_sz, shift, &ops[vece]);
3975     }
3976 }
3977
3978 static void gen_srsra8_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
3979 {
3980     TCGv_i64 t = tcg_temp_new_i64();
3981
3982     gen_srshr8_i64(t, a, sh);
3983     tcg_gen_vec_add8_i64(d, d, t);
3984     tcg_temp_free_i64(t);
3985 }
3986
3987 static void gen_srsra16_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
3988 {
3989     TCGv_i64 t = tcg_temp_new_i64();
3990
3991     gen_srshr16_i64(t, a, sh);
3992     tcg_gen_vec_add16_i64(d, d, t);
3993     tcg_temp_free_i64(t);
3994 }
3995
3996 static void gen_srsra32_i32(TCGv_i32 d, TCGv_i32 a, int32_t sh)
3997 {
3998     TCGv_i32 t = tcg_temp_new_i32();
3999
4000     gen_srshr32_i32(t, a, sh);
4001     tcg_gen_add_i32(d, d, t);
4002     tcg_temp_free_i32(t);
4003 }
4004
4005 static void gen_srsra64_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
4006 {
4007     TCGv_i64 t = tcg_temp_new_i64();
4008
4009     gen_srshr64_i64(t, a, sh);
4010     tcg_gen_add_i64(d, d, t);
4011     tcg_temp_free_i64(t);
4012 }
4013
4014 static void gen_srsra_vec(unsigned vece, TCGv_vec d, TCGv_vec a, int64_t sh)
4015 {
4016     TCGv_vec t = tcg_temp_new_vec_matching(d);
4017
4018     gen_srshr_vec(vece, t, a, sh);
4019     tcg_gen_add_vec(vece, d, d, t);
4020     tcg_temp_free_vec(t);
4021 }
4022
4023 void gen_gvec_srsra(unsigned vece, uint32_t rd_ofs, uint32_t rm_ofs,
4024                     int64_t shift, uint32_t opr_sz, uint32_t max_sz)
4025 {
4026     static const TCGOpcode vecop_list[] = {
4027         INDEX_op_shri_vec, INDEX_op_sari_vec, INDEX_op_add_vec, 0
4028     };
4029     static const GVecGen2i ops[4] = {
4030         { .fni8 = gen_srsra8_i64,
4031           .fniv = gen_srsra_vec,
4032           .fno = gen_helper_gvec_srsra_b,
4033           .opt_opc = vecop_list,
4034           .load_dest = true,
4035           .vece = MO_8 },
4036         { .fni8 = gen_srsra16_i64,
4037           .fniv = gen_srsra_vec,
4038           .fno = gen_helper_gvec_srsra_h,
4039           .opt_opc = vecop_list,
4040           .load_dest = true,
4041           .vece = MO_16 },
4042         { .fni4 = gen_srsra32_i32,
4043           .fniv = gen_srsra_vec,
4044           .fno = gen_helper_gvec_srsra_s,
4045           .opt_opc = vecop_list,
4046           .load_dest = true,
4047           .vece = MO_32 },
4048         { .fni8 = gen_srsra64_i64,
4049           .fniv = gen_srsra_vec,
4050           .fno = gen_helper_gvec_srsra_d,
4051           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
4052           .opt_opc = vecop_list,
4053           .load_dest = true,
4054           .vece = MO_64 },
4055     };
4056
4057     /* tszimm encoding produces immediates in the range [1..esize] */
4058     tcg_debug_assert(shift > 0);
4059     tcg_debug_assert(shift <= (8 << vece));
4060
4061     /*
4062      * Shifts larger than the element size are architecturally valid.
4063      * Signed results in all sign bits.  With rounding, this produces
4064      *   (-1 + 1) >> 1 == 0, or (0 + 1) >> 1 == 0.
4065      * I.e. always zero.  With accumulation, this leaves D unchanged.
4066      */
4067     if (shift == (8 << vece)) {
4068         /* Nop, but we do need to clear the tail. */
4069         tcg_gen_gvec_mov(vece, rd_ofs, rd_ofs, opr_sz, max_sz);
4070     } else {
4071         tcg_gen_gvec_2i(rd_ofs, rm_ofs, opr_sz, max_sz, shift, &ops[vece]);
4072     }
4073 }
4074
4075 static void gen_urshr8_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
4076 {
4077     TCGv_i64 t = tcg_temp_new_i64();
4078
4079     tcg_gen_shri_i64(t, a, sh - 1);
4080     tcg_gen_andi_i64(t, t, dup_const(MO_8, 1));
4081     tcg_gen_vec_shr8i_i64(d, a, sh);
4082     tcg_gen_vec_add8_i64(d, d, t);
4083     tcg_temp_free_i64(t);
4084 }
4085
4086 static void gen_urshr16_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
4087 {
4088     TCGv_i64 t = tcg_temp_new_i64();
4089
4090     tcg_gen_shri_i64(t, a, sh - 1);
4091     tcg_gen_andi_i64(t, t, dup_const(MO_16, 1));
4092     tcg_gen_vec_shr16i_i64(d, a, sh);
4093     tcg_gen_vec_add16_i64(d, d, t);
4094     tcg_temp_free_i64(t);
4095 }
4096
4097 static void gen_urshr32_i32(TCGv_i32 d, TCGv_i32 a, int32_t sh)
4098 {
4099     TCGv_i32 t = tcg_temp_new_i32();
4100
4101     tcg_gen_extract_i32(t, a, sh - 1, 1);
4102     tcg_gen_shri_i32(d, a, sh);
4103     tcg_gen_add_i32(d, d, t);
4104     tcg_temp_free_i32(t);
4105 }
4106
4107 static void gen_urshr64_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
4108 {
4109     TCGv_i64 t = tcg_temp_new_i64();
4110
4111     tcg_gen_extract_i64(t, a, sh - 1, 1);
4112     tcg_gen_shri_i64(d, a, sh);
4113     tcg_gen_add_i64(d, d, t);
4114     tcg_temp_free_i64(t);
4115 }
4116
4117 static void gen_urshr_vec(unsigned vece, TCGv_vec d, TCGv_vec a, int64_t shift)
4118 {
4119     TCGv_vec t = tcg_temp_new_vec_matching(d);
4120     TCGv_vec ones = tcg_temp_new_vec_matching(d);
4121
4122     tcg_gen_shri_vec(vece, t, a, shift - 1);
4123     tcg_gen_dupi_vec(vece, ones, 1);
4124     tcg_gen_and_vec(vece, t, t, ones);
4125     tcg_gen_shri_vec(vece, d, a, shift);
4126     tcg_gen_add_vec(vece, d, d, t);
4127
4128     tcg_temp_free_vec(t);
4129     tcg_temp_free_vec(ones);
4130 }
4131
4132 void gen_gvec_urshr(unsigned vece, uint32_t rd_ofs, uint32_t rm_ofs,
4133                     int64_t shift, uint32_t opr_sz, uint32_t max_sz)
4134 {
4135     static const TCGOpcode vecop_list[] = {
4136         INDEX_op_shri_vec, INDEX_op_add_vec, 0
4137     };
4138     static const GVecGen2i ops[4] = {
4139         { .fni8 = gen_urshr8_i64,
4140           .fniv = gen_urshr_vec,
4141           .fno = gen_helper_gvec_urshr_b,
4142           .opt_opc = vecop_list,
4143           .vece = MO_8 },
4144         { .fni8 = gen_urshr16_i64,
4145           .fniv = gen_urshr_vec,
4146           .fno = gen_helper_gvec_urshr_h,
4147           .opt_opc = vecop_list,
4148           .vece = MO_16 },
4149         { .fni4 = gen_urshr32_i32,
4150           .fniv = gen_urshr_vec,
4151           .fno = gen_helper_gvec_urshr_s,
4152           .opt_opc = vecop_list,
4153           .vece = MO_32 },
4154         { .fni8 = gen_urshr64_i64,
4155           .fniv = gen_urshr_vec,
4156           .fno = gen_helper_gvec_urshr_d,
4157           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
4158           .opt_opc = vecop_list,
4159           .vece = MO_64 },
4160     };
4161
4162     /* tszimm encoding produces immediates in the range [1..esize] */
4163     tcg_debug_assert(shift > 0);
4164     tcg_debug_assert(shift <= (8 << vece));
4165
4166     if (shift == (8 << vece)) {
4167         /*
4168          * Shifts larger than the element size are architecturally valid.
4169          * Unsigned results in zero.  With rounding, this produces a
4170          * copy of the most significant bit.
4171          */
4172         tcg_gen_gvec_shri(vece, rd_ofs, rm_ofs, shift - 1, opr_sz, max_sz);
4173     } else {
4174         tcg_gen_gvec_2i(rd_ofs, rm_ofs, opr_sz, max_sz, shift, &ops[vece]);
4175     }
4176 }
4177
4178 static void gen_ursra8_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
4179 {
4180     TCGv_i64 t = tcg_temp_new_i64();
4181
4182     if (sh == 8) {
4183         tcg_gen_vec_shr8i_i64(t, a, 7);
4184     } else {
4185         gen_urshr8_i64(t, a, sh);
4186     }
4187     tcg_gen_vec_add8_i64(d, d, t);
4188     tcg_temp_free_i64(t);
4189 }
4190
4191 static void gen_ursra16_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
4192 {
4193     TCGv_i64 t = tcg_temp_new_i64();
4194
4195     if (sh == 16) {
4196         tcg_gen_vec_shr16i_i64(t, a, 15);
4197     } else {
4198         gen_urshr16_i64(t, a, sh);
4199     }
4200     tcg_gen_vec_add16_i64(d, d, t);
4201     tcg_temp_free_i64(t);
4202 }
4203
4204 static void gen_ursra32_i32(TCGv_i32 d, TCGv_i32 a, int32_t sh)
4205 {
4206     TCGv_i32 t = tcg_temp_new_i32();
4207
4208     if (sh == 32) {
4209         tcg_gen_shri_i32(t, a, 31);
4210     } else {
4211         gen_urshr32_i32(t, a, sh);
4212     }
4213     tcg_gen_add_i32(d, d, t);
4214     tcg_temp_free_i32(t);
4215 }
4216
4217 static void gen_ursra64_i64(TCGv_i64 d, TCGv_i64 a, int64_t sh)
4218 {
4219     TCGv_i64 t = tcg_temp_new_i64();
4220
4221     if (sh == 64) {
4222         tcg_gen_shri_i64(t, a, 63);
4223     } else {
4224         gen_urshr64_i64(t, a, sh);
4225     }
4226     tcg_gen_add_i64(d, d, t);
4227     tcg_temp_free_i64(t);
4228 }
4229
4230 static void gen_ursra_vec(unsigned vece, TCGv_vec d, TCGv_vec a, int64_t sh)
4231 {
4232     TCGv_vec t = tcg_temp_new_vec_matching(d);
4233
4234     if (sh == (8 << vece)) {
4235         tcg_gen_shri_vec(vece, t, a, sh - 1);
4236     } else {
4237         gen_urshr_vec(vece, t, a, sh);
4238     }
4239     tcg_gen_add_vec(vece, d, d, t);
4240     tcg_temp_free_vec(t);
4241 }
4242
4243 void gen_gvec_ursra(unsigned vece, uint32_t rd_ofs, uint32_t rm_ofs,
4244                     int64_t shift, uint32_t opr_sz, uint32_t max_sz)
4245 {
4246     static const TCGOpcode vecop_list[] = {
4247         INDEX_op_shri_vec, INDEX_op_add_vec, 0
4248     };
4249     static const GVecGen2i ops[4] = {
4250         { .fni8 = gen_ursra8_i64,
4251           .fniv = gen_ursra_vec,
4252           .fno = gen_helper_gvec_ursra_b,
4253           .opt_opc = vecop_list,
4254           .load_dest = true,
4255           .vece = MO_8 },
4256         { .fni8 = gen_ursra16_i64,
4257           .fniv = gen_ursra_vec,
4258           .fno = gen_helper_gvec_ursra_h,
4259           .opt_opc = vecop_list,
4260           .load_dest = true,
4261           .vece = MO_16 },
4262         { .fni4 = gen_ursra32_i32,
4263           .fniv = gen_ursra_vec,
4264           .fno = gen_helper_gvec_ursra_s,
4265           .opt_opc = vecop_list,
4266           .load_dest = true,
4267           .vece = MO_32 },
4268         { .fni8 = gen_ursra64_i64,
4269           .fniv = gen_ursra_vec,
4270           .fno = gen_helper_gvec_ursra_d,
4271           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
4272           .opt_opc = vecop_list,
4273           .load_dest = true,
4274           .vece = MO_64 },
4275     };
4276
4277     /* tszimm encoding produces immediates in the range [1..esize] */
4278     tcg_debug_assert(shift > 0);
4279     tcg_debug_assert(shift <= (8 << vece));
4280
4281     tcg_gen_gvec_2i(rd_ofs, rm_ofs, opr_sz, max_sz, shift, &ops[vece]);
4282 }
4283
4284 static void gen_shr8_ins_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
4285 {
4286     uint64_t mask = dup_const(MO_8, 0xff >> shift);
4287     TCGv_i64 t = tcg_temp_new_i64();
4288
4289     tcg_gen_shri_i64(t, a, shift);
4290     tcg_gen_andi_i64(t, t, mask);
4291     tcg_gen_andi_i64(d, d, ~mask);
4292     tcg_gen_or_i64(d, d, t);
4293     tcg_temp_free_i64(t);
4294 }
4295
4296 static void gen_shr16_ins_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
4297 {
4298     uint64_t mask = dup_const(MO_16, 0xffff >> shift);
4299     TCGv_i64 t = tcg_temp_new_i64();
4300
4301     tcg_gen_shri_i64(t, a, shift);
4302     tcg_gen_andi_i64(t, t, mask);
4303     tcg_gen_andi_i64(d, d, ~mask);
4304     tcg_gen_or_i64(d, d, t);
4305     tcg_temp_free_i64(t);
4306 }
4307
4308 static void gen_shr32_ins_i32(TCGv_i32 d, TCGv_i32 a, int32_t shift)
4309 {
4310     tcg_gen_shri_i32(a, a, shift);
4311     tcg_gen_deposit_i32(d, d, a, 0, 32 - shift);
4312 }
4313
4314 static void gen_shr64_ins_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
4315 {
4316     tcg_gen_shri_i64(a, a, shift);
4317     tcg_gen_deposit_i64(d, d, a, 0, 64 - shift);
4318 }
4319
4320 static void gen_shr_ins_vec(unsigned vece, TCGv_vec d, TCGv_vec a, int64_t sh)
4321 {
4322     TCGv_vec t = tcg_temp_new_vec_matching(d);
4323     TCGv_vec m = tcg_temp_new_vec_matching(d);
4324
4325     tcg_gen_dupi_vec(vece, m, MAKE_64BIT_MASK((8 << vece) - sh, sh));
4326     tcg_gen_shri_vec(vece, t, a, sh);
4327     tcg_gen_and_vec(vece, d, d, m);
4328     tcg_gen_or_vec(vece, d, d, t);
4329
4330     tcg_temp_free_vec(t);
4331     tcg_temp_free_vec(m);
4332 }
4333
4334 void gen_gvec_sri(unsigned vece, uint32_t rd_ofs, uint32_t rm_ofs,
4335                   int64_t shift, uint32_t opr_sz, uint32_t max_sz)
4336 {
4337     static const TCGOpcode vecop_list[] = { INDEX_op_shri_vec, 0 };
4338     const GVecGen2i ops[4] = {
4339         { .fni8 = gen_shr8_ins_i64,
4340           .fniv = gen_shr_ins_vec,
4341           .fno = gen_helper_gvec_sri_b,
4342           .load_dest = true,
4343           .opt_opc = vecop_list,
4344           .vece = MO_8 },
4345         { .fni8 = gen_shr16_ins_i64,
4346           .fniv = gen_shr_ins_vec,
4347           .fno = gen_helper_gvec_sri_h,
4348           .load_dest = true,
4349           .opt_opc = vecop_list,
4350           .vece = MO_16 },
4351         { .fni4 = gen_shr32_ins_i32,
4352           .fniv = gen_shr_ins_vec,
4353           .fno = gen_helper_gvec_sri_s,
4354           .load_dest = true,
4355           .opt_opc = vecop_list,
4356           .vece = MO_32 },
4357         { .fni8 = gen_shr64_ins_i64,
4358           .fniv = gen_shr_ins_vec,
4359           .fno = gen_helper_gvec_sri_d,
4360           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
4361           .load_dest = true,
4362           .opt_opc = vecop_list,
4363           .vece = MO_64 },
4364     };
4365
4366     /* tszimm encoding produces immediates in the range [1..esize]. */
4367     tcg_debug_assert(shift > 0);
4368     tcg_debug_assert(shift <= (8 << vece));
4369
4370     /* Shift of esize leaves destination unchanged. */
4371     if (shift < (8 << vece)) {
4372         tcg_gen_gvec_2i(rd_ofs, rm_ofs, opr_sz, max_sz, shift, &ops[vece]);
4373     } else {
4374         /* Nop, but we do need to clear the tail. */
4375         tcg_gen_gvec_mov(vece, rd_ofs, rd_ofs, opr_sz, max_sz);
4376     }
4377 }
4378
4379 static void gen_shl8_ins_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
4380 {
4381     uint64_t mask = dup_const(MO_8, 0xff << shift);
4382     TCGv_i64 t = tcg_temp_new_i64();
4383
4384     tcg_gen_shli_i64(t, a, shift);
4385     tcg_gen_andi_i64(t, t, mask);
4386     tcg_gen_andi_i64(d, d, ~mask);
4387     tcg_gen_or_i64(d, d, t);
4388     tcg_temp_free_i64(t);
4389 }
4390
4391 static void gen_shl16_ins_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
4392 {
4393     uint64_t mask = dup_const(MO_16, 0xffff << shift);
4394     TCGv_i64 t = tcg_temp_new_i64();
4395
4396     tcg_gen_shli_i64(t, a, shift);
4397     tcg_gen_andi_i64(t, t, mask);
4398     tcg_gen_andi_i64(d, d, ~mask);
4399     tcg_gen_or_i64(d, d, t);
4400     tcg_temp_free_i64(t);
4401 }
4402
4403 static void gen_shl32_ins_i32(TCGv_i32 d, TCGv_i32 a, int32_t shift)
4404 {
4405     tcg_gen_deposit_i32(d, d, a, shift, 32 - shift);
4406 }
4407
4408 static void gen_shl64_ins_i64(TCGv_i64 d, TCGv_i64 a, int64_t shift)
4409 {
4410     tcg_gen_deposit_i64(d, d, a, shift, 64 - shift);
4411 }
4412
4413 static void gen_shl_ins_vec(unsigned vece, TCGv_vec d, TCGv_vec a, int64_t sh)
4414 {
4415     TCGv_vec t = tcg_temp_new_vec_matching(d);
4416     TCGv_vec m = tcg_temp_new_vec_matching(d);
4417
4418     tcg_gen_shli_vec(vece, t, a, sh);
4419     tcg_gen_dupi_vec(vece, m, MAKE_64BIT_MASK(0, sh));
4420     tcg_gen_and_vec(vece, d, d, m);
4421     tcg_gen_or_vec(vece, d, d, t);
4422
4423     tcg_temp_free_vec(t);
4424     tcg_temp_free_vec(m);
4425 }
4426
4427 void gen_gvec_sli(unsigned vece, uint32_t rd_ofs, uint32_t rm_ofs,
4428                   int64_t shift, uint32_t opr_sz, uint32_t max_sz)
4429 {
4430     static const TCGOpcode vecop_list[] = { INDEX_op_shli_vec, 0 };
4431     const GVecGen2i ops[4] = {
4432         { .fni8 = gen_shl8_ins_i64,
4433           .fniv = gen_shl_ins_vec,
4434           .fno = gen_helper_gvec_sli_b,
4435           .load_dest = true,
4436           .opt_opc = vecop_list,
4437           .vece = MO_8 },
4438         { .fni8 = gen_shl16_ins_i64,
4439           .fniv = gen_shl_ins_vec,
4440           .fno = gen_helper_gvec_sli_h,
4441           .load_dest = true,
4442           .opt_opc = vecop_list,
4443           .vece = MO_16 },
4444         { .fni4 = gen_shl32_ins_i32,
4445           .fniv = gen_shl_ins_vec,
4446           .fno = gen_helper_gvec_sli_s,
4447           .load_dest = true,
4448           .opt_opc = vecop_list,
4449           .vece = MO_32 },
4450         { .fni8 = gen_shl64_ins_i64,
4451           .fniv = gen_shl_ins_vec,
4452           .fno = gen_helper_gvec_sli_d,
4453           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
4454           .load_dest = true,
4455           .opt_opc = vecop_list,
4456           .vece = MO_64 },
4457     };
4458
4459     /* tszimm encoding produces immediates in the range [0..esize-1]. */
4460     tcg_debug_assert(shift >= 0);
4461     tcg_debug_assert(shift < (8 << vece));
4462
4463     if (shift == 0) {
4464         tcg_gen_gvec_mov(vece, rd_ofs, rm_ofs, opr_sz, max_sz);
4465     } else {
4466         tcg_gen_gvec_2i(rd_ofs, rm_ofs, opr_sz, max_sz, shift, &ops[vece]);
4467     }
4468 }
4469
4470 static void gen_mla8_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
4471 {
4472     gen_helper_neon_mul_u8(a, a, b);
4473     gen_helper_neon_add_u8(d, d, a);
4474 }
4475
4476 static void gen_mls8_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
4477 {
4478     gen_helper_neon_mul_u8(a, a, b);
4479     gen_helper_neon_sub_u8(d, d, a);
4480 }
4481
4482 static void gen_mla16_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
4483 {
4484     gen_helper_neon_mul_u16(a, a, b);
4485     gen_helper_neon_add_u16(d, d, a);
4486 }
4487
4488 static void gen_mls16_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
4489 {
4490     gen_helper_neon_mul_u16(a, a, b);
4491     gen_helper_neon_sub_u16(d, d, a);
4492 }
4493
4494 static void gen_mla32_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
4495 {
4496     tcg_gen_mul_i32(a, a, b);
4497     tcg_gen_add_i32(d, d, a);
4498 }
4499
4500 static void gen_mls32_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
4501 {
4502     tcg_gen_mul_i32(a, a, b);
4503     tcg_gen_sub_i32(d, d, a);
4504 }
4505
4506 static void gen_mla64_i64(TCGv_i64 d, TCGv_i64 a, TCGv_i64 b)
4507 {
4508     tcg_gen_mul_i64(a, a, b);
4509     tcg_gen_add_i64(d, d, a);
4510 }
4511
4512 static void gen_mls64_i64(TCGv_i64 d, TCGv_i64 a, TCGv_i64 b)
4513 {
4514     tcg_gen_mul_i64(a, a, b);
4515     tcg_gen_sub_i64(d, d, a);
4516 }
4517
4518 static void gen_mla_vec(unsigned vece, TCGv_vec d, TCGv_vec a, TCGv_vec b)
4519 {
4520     tcg_gen_mul_vec(vece, a, a, b);
4521     tcg_gen_add_vec(vece, d, d, a);
4522 }
4523
4524 static void gen_mls_vec(unsigned vece, TCGv_vec d, TCGv_vec a, TCGv_vec b)
4525 {
4526     tcg_gen_mul_vec(vece, a, a, b);
4527     tcg_gen_sub_vec(vece, d, d, a);
4528 }
4529
4530 /* Note that while NEON does not support VMLA and VMLS as 64-bit ops,
4531  * these tables are shared with AArch64 which does support them.
4532  */
4533 void gen_gvec_mla(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
4534                   uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
4535 {
4536     static const TCGOpcode vecop_list[] = {
4537         INDEX_op_mul_vec, INDEX_op_add_vec, 0
4538     };
4539     static const GVecGen3 ops[4] = {
4540         { .fni4 = gen_mla8_i32,
4541           .fniv = gen_mla_vec,
4542           .load_dest = true,
4543           .opt_opc = vecop_list,
4544           .vece = MO_8 },
4545         { .fni4 = gen_mla16_i32,
4546           .fniv = gen_mla_vec,
4547           .load_dest = true,
4548           .opt_opc = vecop_list,
4549           .vece = MO_16 },
4550         { .fni4 = gen_mla32_i32,
4551           .fniv = gen_mla_vec,
4552           .load_dest = true,
4553           .opt_opc = vecop_list,
4554           .vece = MO_32 },
4555         { .fni8 = gen_mla64_i64,
4556           .fniv = gen_mla_vec,
4557           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
4558           .load_dest = true,
4559           .opt_opc = vecop_list,
4560           .vece = MO_64 },
4561     };
4562     tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
4563 }
4564
4565 void gen_gvec_mls(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
4566                   uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
4567 {
4568     static const TCGOpcode vecop_list[] = {
4569         INDEX_op_mul_vec, INDEX_op_sub_vec, 0
4570     };
4571     static const GVecGen3 ops[4] = {
4572         { .fni4 = gen_mls8_i32,
4573           .fniv = gen_mls_vec,
4574           .load_dest = true,
4575           .opt_opc = vecop_list,
4576           .vece = MO_8 },
4577         { .fni4 = gen_mls16_i32,
4578           .fniv = gen_mls_vec,
4579           .load_dest = true,
4580           .opt_opc = vecop_list,
4581           .vece = MO_16 },
4582         { .fni4 = gen_mls32_i32,
4583           .fniv = gen_mls_vec,
4584           .load_dest = true,
4585           .opt_opc = vecop_list,
4586           .vece = MO_32 },
4587         { .fni8 = gen_mls64_i64,
4588           .fniv = gen_mls_vec,
4589           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
4590           .load_dest = true,
4591           .opt_opc = vecop_list,
4592           .vece = MO_64 },
4593     };
4594     tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
4595 }
4596
4597 /* CMTST : test is "if (X & Y != 0)". */
4598 static void gen_cmtst_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
4599 {
4600     tcg_gen_and_i32(d, a, b);
4601     tcg_gen_setcondi_i32(TCG_COND_NE, d, d, 0);
4602     tcg_gen_neg_i32(d, d);
4603 }
4604
4605 void gen_cmtst_i64(TCGv_i64 d, TCGv_i64 a, TCGv_i64 b)
4606 {
4607     tcg_gen_and_i64(d, a, b);
4608     tcg_gen_setcondi_i64(TCG_COND_NE, d, d, 0);
4609     tcg_gen_neg_i64(d, d);
4610 }
4611
4612 static void gen_cmtst_vec(unsigned vece, TCGv_vec d, TCGv_vec a, TCGv_vec b)
4613 {
4614     tcg_gen_and_vec(vece, d, a, b);
4615     tcg_gen_dupi_vec(vece, a, 0);
4616     tcg_gen_cmp_vec(TCG_COND_NE, vece, d, d, a);
4617 }
4618
4619 void gen_gvec_cmtst(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
4620                     uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
4621 {
4622     static const TCGOpcode vecop_list[] = { INDEX_op_cmp_vec, 0 };
4623     static const GVecGen3 ops[4] = {
4624         { .fni4 = gen_helper_neon_tst_u8,
4625           .fniv = gen_cmtst_vec,
4626           .opt_opc = vecop_list,
4627           .vece = MO_8 },
4628         { .fni4 = gen_helper_neon_tst_u16,
4629           .fniv = gen_cmtst_vec,
4630           .opt_opc = vecop_list,
4631           .vece = MO_16 },
4632         { .fni4 = gen_cmtst_i32,
4633           .fniv = gen_cmtst_vec,
4634           .opt_opc = vecop_list,
4635           .vece = MO_32 },
4636         { .fni8 = gen_cmtst_i64,
4637           .fniv = gen_cmtst_vec,
4638           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
4639           .opt_opc = vecop_list,
4640           .vece = MO_64 },
4641     };
4642     tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
4643 }
4644
4645 void gen_ushl_i32(TCGv_i32 dst, TCGv_i32 src, TCGv_i32 shift)
4646 {
4647     TCGv_i32 lval = tcg_temp_new_i32();
4648     TCGv_i32 rval = tcg_temp_new_i32();
4649     TCGv_i32 lsh = tcg_temp_new_i32();
4650     TCGv_i32 rsh = tcg_temp_new_i32();
4651     TCGv_i32 zero = tcg_const_i32(0);
4652     TCGv_i32 max = tcg_const_i32(32);
4653
4654     /*
4655      * Rely on the TCG guarantee that out of range shifts produce
4656      * unspecified results, not undefined behaviour (i.e. no trap).
4657      * Discard out-of-range results after the fact.
4658      */
4659     tcg_gen_ext8s_i32(lsh, shift);
4660     tcg_gen_neg_i32(rsh, lsh);
4661     tcg_gen_shl_i32(lval, src, lsh);
4662     tcg_gen_shr_i32(rval, src, rsh);
4663     tcg_gen_movcond_i32(TCG_COND_LTU, dst, lsh, max, lval, zero);
4664     tcg_gen_movcond_i32(TCG_COND_LTU, dst, rsh, max, rval, dst);
4665
4666     tcg_temp_free_i32(lval);
4667     tcg_temp_free_i32(rval);
4668     tcg_temp_free_i32(lsh);
4669     tcg_temp_free_i32(rsh);
4670     tcg_temp_free_i32(zero);
4671     tcg_temp_free_i32(max);
4672 }
4673
4674 void gen_ushl_i64(TCGv_i64 dst, TCGv_i64 src, TCGv_i64 shift)
4675 {
4676     TCGv_i64 lval = tcg_temp_new_i64();
4677     TCGv_i64 rval = tcg_temp_new_i64();
4678     TCGv_i64 lsh = tcg_temp_new_i64();
4679     TCGv_i64 rsh = tcg_temp_new_i64();
4680     TCGv_i64 zero = tcg_const_i64(0);
4681     TCGv_i64 max = tcg_const_i64(64);
4682
4683     /*
4684      * Rely on the TCG guarantee that out of range shifts produce
4685      * unspecified results, not undefined behaviour (i.e. no trap).
4686      * Discard out-of-range results after the fact.
4687      */
4688     tcg_gen_ext8s_i64(lsh, shift);
4689     tcg_gen_neg_i64(rsh, lsh);
4690     tcg_gen_shl_i64(lval, src, lsh);
4691     tcg_gen_shr_i64(rval, src, rsh);
4692     tcg_gen_movcond_i64(TCG_COND_LTU, dst, lsh, max, lval, zero);
4693     tcg_gen_movcond_i64(TCG_COND_LTU, dst, rsh, max, rval, dst);
4694
4695     tcg_temp_free_i64(lval);
4696     tcg_temp_free_i64(rval);
4697     tcg_temp_free_i64(lsh);
4698     tcg_temp_free_i64(rsh);
4699     tcg_temp_free_i64(zero);
4700     tcg_temp_free_i64(max);
4701 }
4702
4703 static void gen_ushl_vec(unsigned vece, TCGv_vec dst,
4704                          TCGv_vec src, TCGv_vec shift)
4705 {
4706     TCGv_vec lval = tcg_temp_new_vec_matching(dst);
4707     TCGv_vec rval = tcg_temp_new_vec_matching(dst);
4708     TCGv_vec lsh = tcg_temp_new_vec_matching(dst);
4709     TCGv_vec rsh = tcg_temp_new_vec_matching(dst);
4710     TCGv_vec msk, max;
4711
4712     tcg_gen_neg_vec(vece, rsh, shift);
4713     if (vece == MO_8) {
4714         tcg_gen_mov_vec(lsh, shift);
4715     } else {
4716         msk = tcg_temp_new_vec_matching(dst);
4717         tcg_gen_dupi_vec(vece, msk, 0xff);
4718         tcg_gen_and_vec(vece, lsh, shift, msk);
4719         tcg_gen_and_vec(vece, rsh, rsh, msk);
4720         tcg_temp_free_vec(msk);
4721     }
4722
4723     /*
4724      * Rely on the TCG guarantee that out of range shifts produce
4725      * unspecified results, not undefined behaviour (i.e. no trap).
4726      * Discard out-of-range results after the fact.
4727      */
4728     tcg_gen_shlv_vec(vece, lval, src, lsh);
4729     tcg_gen_shrv_vec(vece, rval, src, rsh);
4730
4731     max = tcg_temp_new_vec_matching(dst);
4732     tcg_gen_dupi_vec(vece, max, 8 << vece);
4733
4734     /*
4735      * The choice of LT (signed) and GEU (unsigned) are biased toward
4736      * the instructions of the x86_64 host.  For MO_8, the whole byte
4737      * is significant so we must use an unsigned compare; otherwise we
4738      * have already masked to a byte and so a signed compare works.
4739      * Other tcg hosts have a full set of comparisons and do not care.
4740      */
4741     if (vece == MO_8) {
4742         tcg_gen_cmp_vec(TCG_COND_GEU, vece, lsh, lsh, max);
4743         tcg_gen_cmp_vec(TCG_COND_GEU, vece, rsh, rsh, max);
4744         tcg_gen_andc_vec(vece, lval, lval, lsh);
4745         tcg_gen_andc_vec(vece, rval, rval, rsh);
4746     } else {
4747         tcg_gen_cmp_vec(TCG_COND_LT, vece, lsh, lsh, max);
4748         tcg_gen_cmp_vec(TCG_COND_LT, vece, rsh, rsh, max);
4749         tcg_gen_and_vec(vece, lval, lval, lsh);
4750         tcg_gen_and_vec(vece, rval, rval, rsh);
4751     }
4752     tcg_gen_or_vec(vece, dst, lval, rval);
4753
4754     tcg_temp_free_vec(max);
4755     tcg_temp_free_vec(lval);
4756     tcg_temp_free_vec(rval);
4757     tcg_temp_free_vec(lsh);
4758     tcg_temp_free_vec(rsh);
4759 }
4760
4761 void gen_gvec_ushl(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
4762                    uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
4763 {
4764     static const TCGOpcode vecop_list[] = {
4765         INDEX_op_neg_vec, INDEX_op_shlv_vec,
4766         INDEX_op_shrv_vec, INDEX_op_cmp_vec, 0
4767     };
4768     static const GVecGen3 ops[4] = {
4769         { .fniv = gen_ushl_vec,
4770           .fno = gen_helper_gvec_ushl_b,
4771           .opt_opc = vecop_list,
4772           .vece = MO_8 },
4773         { .fniv = gen_ushl_vec,
4774           .fno = gen_helper_gvec_ushl_h,
4775           .opt_opc = vecop_list,
4776           .vece = MO_16 },
4777         { .fni4 = gen_ushl_i32,
4778           .fniv = gen_ushl_vec,
4779           .opt_opc = vecop_list,
4780           .vece = MO_32 },
4781         { .fni8 = gen_ushl_i64,
4782           .fniv = gen_ushl_vec,
4783           .opt_opc = vecop_list,
4784           .vece = MO_64 },
4785     };
4786     tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
4787 }
4788
4789 void gen_sshl_i32(TCGv_i32 dst, TCGv_i32 src, TCGv_i32 shift)
4790 {
4791     TCGv_i32 lval = tcg_temp_new_i32();
4792     TCGv_i32 rval = tcg_temp_new_i32();
4793     TCGv_i32 lsh = tcg_temp_new_i32();
4794     TCGv_i32 rsh = tcg_temp_new_i32();
4795     TCGv_i32 zero = tcg_const_i32(0);
4796     TCGv_i32 max = tcg_const_i32(31);
4797
4798     /*
4799      * Rely on the TCG guarantee that out of range shifts produce
4800      * unspecified results, not undefined behaviour (i.e. no trap).
4801      * Discard out-of-range results after the fact.
4802      */
4803     tcg_gen_ext8s_i32(lsh, shift);
4804     tcg_gen_neg_i32(rsh, lsh);
4805     tcg_gen_shl_i32(lval, src, lsh);
4806     tcg_gen_umin_i32(rsh, rsh, max);
4807     tcg_gen_sar_i32(rval, src, rsh);
4808     tcg_gen_movcond_i32(TCG_COND_LEU, lval, lsh, max, lval, zero);
4809     tcg_gen_movcond_i32(TCG_COND_LT, dst, lsh, zero, rval, lval);
4810
4811     tcg_temp_free_i32(lval);
4812     tcg_temp_free_i32(rval);
4813     tcg_temp_free_i32(lsh);
4814     tcg_temp_free_i32(rsh);
4815     tcg_temp_free_i32(zero);
4816     tcg_temp_free_i32(max);
4817 }
4818
4819 void gen_sshl_i64(TCGv_i64 dst, TCGv_i64 src, TCGv_i64 shift)
4820 {
4821     TCGv_i64 lval = tcg_temp_new_i64();
4822     TCGv_i64 rval = tcg_temp_new_i64();
4823     TCGv_i64 lsh = tcg_temp_new_i64();
4824     TCGv_i64 rsh = tcg_temp_new_i64();
4825     TCGv_i64 zero = tcg_const_i64(0);
4826     TCGv_i64 max = tcg_const_i64(63);
4827
4828     /*
4829      * Rely on the TCG guarantee that out of range shifts produce
4830      * unspecified results, not undefined behaviour (i.e. no trap).
4831      * Discard out-of-range results after the fact.
4832      */
4833     tcg_gen_ext8s_i64(lsh, shift);
4834     tcg_gen_neg_i64(rsh, lsh);
4835     tcg_gen_shl_i64(lval, src, lsh);
4836     tcg_gen_umin_i64(rsh, rsh, max);
4837     tcg_gen_sar_i64(rval, src, rsh);
4838     tcg_gen_movcond_i64(TCG_COND_LEU, lval, lsh, max, lval, zero);
4839     tcg_gen_movcond_i64(TCG_COND_LT, dst, lsh, zero, rval, lval);
4840
4841     tcg_temp_free_i64(lval);
4842     tcg_temp_free_i64(rval);
4843     tcg_temp_free_i64(lsh);
4844     tcg_temp_free_i64(rsh);
4845     tcg_temp_free_i64(zero);
4846     tcg_temp_free_i64(max);
4847 }
4848
4849 static void gen_sshl_vec(unsigned vece, TCGv_vec dst,
4850                          TCGv_vec src, TCGv_vec shift)
4851 {
4852     TCGv_vec lval = tcg_temp_new_vec_matching(dst);
4853     TCGv_vec rval = tcg_temp_new_vec_matching(dst);
4854     TCGv_vec lsh = tcg_temp_new_vec_matching(dst);
4855     TCGv_vec rsh = tcg_temp_new_vec_matching(dst);
4856     TCGv_vec tmp = tcg_temp_new_vec_matching(dst);
4857
4858     /*
4859      * Rely on the TCG guarantee that out of range shifts produce
4860      * unspecified results, not undefined behaviour (i.e. no trap).
4861      * Discard out-of-range results after the fact.
4862      */
4863     tcg_gen_neg_vec(vece, rsh, shift);
4864     if (vece == MO_8) {
4865         tcg_gen_mov_vec(lsh, shift);
4866     } else {
4867         tcg_gen_dupi_vec(vece, tmp, 0xff);
4868         tcg_gen_and_vec(vece, lsh, shift, tmp);
4869         tcg_gen_and_vec(vece, rsh, rsh, tmp);
4870     }
4871
4872     /* Bound rsh so out of bound right shift gets -1.  */
4873     tcg_gen_dupi_vec(vece, tmp, (8 << vece) - 1);
4874     tcg_gen_umin_vec(vece, rsh, rsh, tmp);
4875     tcg_gen_cmp_vec(TCG_COND_GT, vece, tmp, lsh, tmp);
4876
4877     tcg_gen_shlv_vec(vece, lval, src, lsh);
4878     tcg_gen_sarv_vec(vece, rval, src, rsh);
4879
4880     /* Select in-bound left shift.  */
4881     tcg_gen_andc_vec(vece, lval, lval, tmp);
4882
4883     /* Select between left and right shift.  */
4884     if (vece == MO_8) {
4885         tcg_gen_dupi_vec(vece, tmp, 0);
4886         tcg_gen_cmpsel_vec(TCG_COND_LT, vece, dst, lsh, tmp, rval, lval);
4887     } else {
4888         tcg_gen_dupi_vec(vece, tmp, 0x80);
4889         tcg_gen_cmpsel_vec(TCG_COND_LT, vece, dst, lsh, tmp, lval, rval);
4890     }
4891
4892     tcg_temp_free_vec(lval);
4893     tcg_temp_free_vec(rval);
4894     tcg_temp_free_vec(lsh);
4895     tcg_temp_free_vec(rsh);
4896     tcg_temp_free_vec(tmp);
4897 }
4898
4899 void gen_gvec_sshl(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
4900                    uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
4901 {
4902     static const TCGOpcode vecop_list[] = {
4903         INDEX_op_neg_vec, INDEX_op_umin_vec, INDEX_op_shlv_vec,
4904         INDEX_op_sarv_vec, INDEX_op_cmp_vec, INDEX_op_cmpsel_vec, 0
4905     };
4906     static const GVecGen3 ops[4] = {
4907         { .fniv = gen_sshl_vec,
4908           .fno = gen_helper_gvec_sshl_b,
4909           .opt_opc = vecop_list,
4910           .vece = MO_8 },
4911         { .fniv = gen_sshl_vec,
4912           .fno = gen_helper_gvec_sshl_h,
4913           .opt_opc = vecop_list,
4914           .vece = MO_16 },
4915         { .fni4 = gen_sshl_i32,
4916           .fniv = gen_sshl_vec,
4917           .opt_opc = vecop_list,
4918           .vece = MO_32 },
4919         { .fni8 = gen_sshl_i64,
4920           .fniv = gen_sshl_vec,
4921           .opt_opc = vecop_list,
4922           .vece = MO_64 },
4923     };
4924     tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
4925 }
4926
4927 static void gen_uqadd_vec(unsigned vece, TCGv_vec t, TCGv_vec sat,
4928                           TCGv_vec a, TCGv_vec b)
4929 {
4930     TCGv_vec x = tcg_temp_new_vec_matching(t);
4931     tcg_gen_add_vec(vece, x, a, b);
4932     tcg_gen_usadd_vec(vece, t, a, b);
4933     tcg_gen_cmp_vec(TCG_COND_NE, vece, x, x, t);
4934     tcg_gen_or_vec(vece, sat, sat, x);
4935     tcg_temp_free_vec(x);
4936 }
4937
4938 void gen_gvec_uqadd_qc(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
4939                        uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
4940 {
4941     static const TCGOpcode vecop_list[] = {
4942         INDEX_op_usadd_vec, INDEX_op_cmp_vec, INDEX_op_add_vec, 0
4943     };
4944     static const GVecGen4 ops[4] = {
4945         { .fniv = gen_uqadd_vec,
4946           .fno = gen_helper_gvec_uqadd_b,
4947           .write_aofs = true,
4948           .opt_opc = vecop_list,
4949           .vece = MO_8 },
4950         { .fniv = gen_uqadd_vec,
4951           .fno = gen_helper_gvec_uqadd_h,
4952           .write_aofs = true,
4953           .opt_opc = vecop_list,
4954           .vece = MO_16 },
4955         { .fniv = gen_uqadd_vec,
4956           .fno = gen_helper_gvec_uqadd_s,
4957           .write_aofs = true,
4958           .opt_opc = vecop_list,
4959           .vece = MO_32 },
4960         { .fniv = gen_uqadd_vec,
4961           .fno = gen_helper_gvec_uqadd_d,
4962           .write_aofs = true,
4963           .opt_opc = vecop_list,
4964           .vece = MO_64 },
4965     };
4966     tcg_gen_gvec_4(rd_ofs, offsetof(CPUARMState, vfp.qc),
4967                    rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
4968 }
4969
4970 static void gen_sqadd_vec(unsigned vece, TCGv_vec t, TCGv_vec sat,
4971                           TCGv_vec a, TCGv_vec b)
4972 {
4973     TCGv_vec x = tcg_temp_new_vec_matching(t);
4974     tcg_gen_add_vec(vece, x, a, b);
4975     tcg_gen_ssadd_vec(vece, t, a, b);
4976     tcg_gen_cmp_vec(TCG_COND_NE, vece, x, x, t);
4977     tcg_gen_or_vec(vece, sat, sat, x);
4978     tcg_temp_free_vec(x);
4979 }
4980
4981 void gen_gvec_sqadd_qc(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
4982                        uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
4983 {
4984     static const TCGOpcode vecop_list[] = {
4985         INDEX_op_ssadd_vec, INDEX_op_cmp_vec, INDEX_op_add_vec, 0
4986     };
4987     static const GVecGen4 ops[4] = {
4988         { .fniv = gen_sqadd_vec,
4989           .fno = gen_helper_gvec_sqadd_b,
4990           .opt_opc = vecop_list,
4991           .write_aofs = true,
4992           .vece = MO_8 },
4993         { .fniv = gen_sqadd_vec,
4994           .fno = gen_helper_gvec_sqadd_h,
4995           .opt_opc = vecop_list,
4996           .write_aofs = true,
4997           .vece = MO_16 },
4998         { .fniv = gen_sqadd_vec,
4999           .fno = gen_helper_gvec_sqadd_s,
5000           .opt_opc = vecop_list,
5001           .write_aofs = true,
5002           .vece = MO_32 },
5003         { .fniv = gen_sqadd_vec,
5004           .fno = gen_helper_gvec_sqadd_d,
5005           .opt_opc = vecop_list,
5006           .write_aofs = true,
5007           .vece = MO_64 },
5008     };
5009     tcg_gen_gvec_4(rd_ofs, offsetof(CPUARMState, vfp.qc),
5010                    rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
5011 }
5012
5013 static void gen_uqsub_vec(unsigned vece, TCGv_vec t, TCGv_vec sat,
5014                           TCGv_vec a, TCGv_vec b)
5015 {
5016     TCGv_vec x = tcg_temp_new_vec_matching(t);
5017     tcg_gen_sub_vec(vece, x, a, b);
5018     tcg_gen_ussub_vec(vece, t, a, b);
5019     tcg_gen_cmp_vec(TCG_COND_NE, vece, x, x, t);
5020     tcg_gen_or_vec(vece, sat, sat, x);
5021     tcg_temp_free_vec(x);
5022 }
5023
5024 void gen_gvec_uqsub_qc(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
5025                        uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
5026 {
5027     static const TCGOpcode vecop_list[] = {
5028         INDEX_op_ussub_vec, INDEX_op_cmp_vec, INDEX_op_sub_vec, 0
5029     };
5030     static const GVecGen4 ops[4] = {
5031         { .fniv = gen_uqsub_vec,
5032           .fno = gen_helper_gvec_uqsub_b,
5033           .opt_opc = vecop_list,
5034           .write_aofs = true,
5035           .vece = MO_8 },
5036         { .fniv = gen_uqsub_vec,
5037           .fno = gen_helper_gvec_uqsub_h,
5038           .opt_opc = vecop_list,
5039           .write_aofs = true,
5040           .vece = MO_16 },
5041         { .fniv = gen_uqsub_vec,
5042           .fno = gen_helper_gvec_uqsub_s,
5043           .opt_opc = vecop_list,
5044           .write_aofs = true,
5045           .vece = MO_32 },
5046         { .fniv = gen_uqsub_vec,
5047           .fno = gen_helper_gvec_uqsub_d,
5048           .opt_opc = vecop_list,
5049           .write_aofs = true,
5050           .vece = MO_64 },
5051     };
5052     tcg_gen_gvec_4(rd_ofs, offsetof(CPUARMState, vfp.qc),
5053                    rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
5054 }
5055
5056 static void gen_sqsub_vec(unsigned vece, TCGv_vec t, TCGv_vec sat,
5057                           TCGv_vec a, TCGv_vec b)
5058 {
5059     TCGv_vec x = tcg_temp_new_vec_matching(t);
5060     tcg_gen_sub_vec(vece, x, a, b);
5061     tcg_gen_sssub_vec(vece, t, a, b);
5062     tcg_gen_cmp_vec(TCG_COND_NE, vece, x, x, t);
5063     tcg_gen_or_vec(vece, sat, sat, x);
5064     tcg_temp_free_vec(x);
5065 }
5066
5067 void gen_gvec_sqsub_qc(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
5068                        uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
5069 {
5070     static const TCGOpcode vecop_list[] = {
5071         INDEX_op_sssub_vec, INDEX_op_cmp_vec, INDEX_op_sub_vec, 0
5072     };
5073     static const GVecGen4 ops[4] = {
5074         { .fniv = gen_sqsub_vec,
5075           .fno = gen_helper_gvec_sqsub_b,
5076           .opt_opc = vecop_list,
5077           .write_aofs = true,
5078           .vece = MO_8 },
5079         { .fniv = gen_sqsub_vec,
5080           .fno = gen_helper_gvec_sqsub_h,
5081           .opt_opc = vecop_list,
5082           .write_aofs = true,
5083           .vece = MO_16 },
5084         { .fniv = gen_sqsub_vec,
5085           .fno = gen_helper_gvec_sqsub_s,
5086           .opt_opc = vecop_list,
5087           .write_aofs = true,
5088           .vece = MO_32 },
5089         { .fniv = gen_sqsub_vec,
5090           .fno = gen_helper_gvec_sqsub_d,
5091           .opt_opc = vecop_list,
5092           .write_aofs = true,
5093           .vece = MO_64 },
5094     };
5095     tcg_gen_gvec_4(rd_ofs, offsetof(CPUARMState, vfp.qc),
5096                    rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
5097 }
5098
5099 static void gen_sabd_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
5100 {
5101     TCGv_i32 t = tcg_temp_new_i32();
5102
5103     tcg_gen_sub_i32(t, a, b);
5104     tcg_gen_sub_i32(d, b, a);
5105     tcg_gen_movcond_i32(TCG_COND_LT, d, a, b, d, t);
5106     tcg_temp_free_i32(t);
5107 }
5108
5109 static void gen_sabd_i64(TCGv_i64 d, TCGv_i64 a, TCGv_i64 b)
5110 {
5111     TCGv_i64 t = tcg_temp_new_i64();
5112
5113     tcg_gen_sub_i64(t, a, b);
5114     tcg_gen_sub_i64(d, b, a);
5115     tcg_gen_movcond_i64(TCG_COND_LT, d, a, b, d, t);
5116     tcg_temp_free_i64(t);
5117 }
5118
5119 static void gen_sabd_vec(unsigned vece, TCGv_vec d, TCGv_vec a, TCGv_vec b)
5120 {
5121     TCGv_vec t = tcg_temp_new_vec_matching(d);
5122
5123     tcg_gen_smin_vec(vece, t, a, b);
5124     tcg_gen_smax_vec(vece, d, a, b);
5125     tcg_gen_sub_vec(vece, d, d, t);
5126     tcg_temp_free_vec(t);
5127 }
5128
5129 void gen_gvec_sabd(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
5130                    uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
5131 {
5132     static const TCGOpcode vecop_list[] = {
5133         INDEX_op_sub_vec, INDEX_op_smin_vec, INDEX_op_smax_vec, 0
5134     };
5135     static const GVecGen3 ops[4] = {
5136         { .fniv = gen_sabd_vec,
5137           .fno = gen_helper_gvec_sabd_b,
5138           .opt_opc = vecop_list,
5139           .vece = MO_8 },
5140         { .fniv = gen_sabd_vec,
5141           .fno = gen_helper_gvec_sabd_h,
5142           .opt_opc = vecop_list,
5143           .vece = MO_16 },
5144         { .fni4 = gen_sabd_i32,
5145           .fniv = gen_sabd_vec,
5146           .fno = gen_helper_gvec_sabd_s,
5147           .opt_opc = vecop_list,
5148           .vece = MO_32 },
5149         { .fni8 = gen_sabd_i64,
5150           .fniv = gen_sabd_vec,
5151           .fno = gen_helper_gvec_sabd_d,
5152           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
5153           .opt_opc = vecop_list,
5154           .vece = MO_64 },
5155     };
5156     tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
5157 }
5158
5159 static void gen_uabd_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
5160 {
5161     TCGv_i32 t = tcg_temp_new_i32();
5162
5163     tcg_gen_sub_i32(t, a, b);
5164     tcg_gen_sub_i32(d, b, a);
5165     tcg_gen_movcond_i32(TCG_COND_LTU, d, a, b, d, t);
5166     tcg_temp_free_i32(t);
5167 }
5168
5169 static void gen_uabd_i64(TCGv_i64 d, TCGv_i64 a, TCGv_i64 b)
5170 {
5171     TCGv_i64 t = tcg_temp_new_i64();
5172
5173     tcg_gen_sub_i64(t, a, b);
5174     tcg_gen_sub_i64(d, b, a);
5175     tcg_gen_movcond_i64(TCG_COND_LTU, d, a, b, d, t);
5176     tcg_temp_free_i64(t);
5177 }
5178
5179 static void gen_uabd_vec(unsigned vece, TCGv_vec d, TCGv_vec a, TCGv_vec b)
5180 {
5181     TCGv_vec t = tcg_temp_new_vec_matching(d);
5182
5183     tcg_gen_umin_vec(vece, t, a, b);
5184     tcg_gen_umax_vec(vece, d, a, b);
5185     tcg_gen_sub_vec(vece, d, d, t);
5186     tcg_temp_free_vec(t);
5187 }
5188
5189 void gen_gvec_uabd(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
5190                    uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
5191 {
5192     static const TCGOpcode vecop_list[] = {
5193         INDEX_op_sub_vec, INDEX_op_umin_vec, INDEX_op_umax_vec, 0
5194     };
5195     static const GVecGen3 ops[4] = {
5196         { .fniv = gen_uabd_vec,
5197           .fno = gen_helper_gvec_uabd_b,
5198           .opt_opc = vecop_list,
5199           .vece = MO_8 },
5200         { .fniv = gen_uabd_vec,
5201           .fno = gen_helper_gvec_uabd_h,
5202           .opt_opc = vecop_list,
5203           .vece = MO_16 },
5204         { .fni4 = gen_uabd_i32,
5205           .fniv = gen_uabd_vec,
5206           .fno = gen_helper_gvec_uabd_s,
5207           .opt_opc = vecop_list,
5208           .vece = MO_32 },
5209         { .fni8 = gen_uabd_i64,
5210           .fniv = gen_uabd_vec,
5211           .fno = gen_helper_gvec_uabd_d,
5212           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
5213           .opt_opc = vecop_list,
5214           .vece = MO_64 },
5215     };
5216     tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
5217 }
5218
5219 static void gen_saba_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
5220 {
5221     TCGv_i32 t = tcg_temp_new_i32();
5222     gen_sabd_i32(t, a, b);
5223     tcg_gen_add_i32(d, d, t);
5224     tcg_temp_free_i32(t);
5225 }
5226
5227 static void gen_saba_i64(TCGv_i64 d, TCGv_i64 a, TCGv_i64 b)
5228 {
5229     TCGv_i64 t = tcg_temp_new_i64();
5230     gen_sabd_i64(t, a, b);
5231     tcg_gen_add_i64(d, d, t);
5232     tcg_temp_free_i64(t);
5233 }
5234
5235 static void gen_saba_vec(unsigned vece, TCGv_vec d, TCGv_vec a, TCGv_vec b)
5236 {
5237     TCGv_vec t = tcg_temp_new_vec_matching(d);
5238     gen_sabd_vec(vece, t, a, b);
5239     tcg_gen_add_vec(vece, d, d, t);
5240     tcg_temp_free_vec(t);
5241 }
5242
5243 void gen_gvec_saba(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
5244                    uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
5245 {
5246     static const TCGOpcode vecop_list[] = {
5247         INDEX_op_sub_vec, INDEX_op_add_vec,
5248         INDEX_op_smin_vec, INDEX_op_smax_vec, 0
5249     };
5250     static const GVecGen3 ops[4] = {
5251         { .fniv = gen_saba_vec,
5252           .fno = gen_helper_gvec_saba_b,
5253           .opt_opc = vecop_list,
5254           .load_dest = true,
5255           .vece = MO_8 },
5256         { .fniv = gen_saba_vec,
5257           .fno = gen_helper_gvec_saba_h,
5258           .opt_opc = vecop_list,
5259           .load_dest = true,
5260           .vece = MO_16 },
5261         { .fni4 = gen_saba_i32,
5262           .fniv = gen_saba_vec,
5263           .fno = gen_helper_gvec_saba_s,
5264           .opt_opc = vecop_list,
5265           .load_dest = true,
5266           .vece = MO_32 },
5267         { .fni8 = gen_saba_i64,
5268           .fniv = gen_saba_vec,
5269           .fno = gen_helper_gvec_saba_d,
5270           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
5271           .opt_opc = vecop_list,
5272           .load_dest = true,
5273           .vece = MO_64 },
5274     };
5275     tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
5276 }
5277
5278 static void gen_uaba_i32(TCGv_i32 d, TCGv_i32 a, TCGv_i32 b)
5279 {
5280     TCGv_i32 t = tcg_temp_new_i32();
5281     gen_uabd_i32(t, a, b);
5282     tcg_gen_add_i32(d, d, t);
5283     tcg_temp_free_i32(t);
5284 }
5285
5286 static void gen_uaba_i64(TCGv_i64 d, TCGv_i64 a, TCGv_i64 b)
5287 {
5288     TCGv_i64 t = tcg_temp_new_i64();
5289     gen_uabd_i64(t, a, b);
5290     tcg_gen_add_i64(d, d, t);
5291     tcg_temp_free_i64(t);
5292 }
5293
5294 static void gen_uaba_vec(unsigned vece, TCGv_vec d, TCGv_vec a, TCGv_vec b)
5295 {
5296     TCGv_vec t = tcg_temp_new_vec_matching(d);
5297     gen_uabd_vec(vece, t, a, b);
5298     tcg_gen_add_vec(vece, d, d, t);
5299     tcg_temp_free_vec(t);
5300 }
5301
5302 void gen_gvec_uaba(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs,
5303                    uint32_t rm_ofs, uint32_t opr_sz, uint32_t max_sz)
5304 {
5305     static const TCGOpcode vecop_list[] = {
5306         INDEX_op_sub_vec, INDEX_op_add_vec,
5307         INDEX_op_umin_vec, INDEX_op_umax_vec, 0
5308     };
5309     static const GVecGen3 ops[4] = {
5310         { .fniv = gen_uaba_vec,
5311           .fno = gen_helper_gvec_uaba_b,
5312           .opt_opc = vecop_list,
5313           .load_dest = true,
5314           .vece = MO_8 },
5315         { .fniv = gen_uaba_vec,
5316           .fno = gen_helper_gvec_uaba_h,
5317           .opt_opc = vecop_list,
5318           .load_dest = true,
5319           .vece = MO_16 },
5320         { .fni4 = gen_uaba_i32,
5321           .fniv = gen_uaba_vec,
5322           .fno = gen_helper_gvec_uaba_s,
5323           .opt_opc = vecop_list,
5324           .load_dest = true,
5325           .vece = MO_32 },
5326         { .fni8 = gen_uaba_i64,
5327           .fniv = gen_uaba_vec,
5328           .fno = gen_helper_gvec_uaba_d,
5329           .prefer_i64 = TCG_TARGET_REG_BITS == 64,
5330           .opt_opc = vecop_list,
5331           .load_dest = true,
5332           .vece = MO_64 },
5333     };
5334     tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, opr_sz, max_sz, &ops[vece]);
5335 }
5336
5337 /* Translate a NEON data processing instruction.  Return nonzero if the
5338    instruction is invalid.
5339    We process data in a mixture of 32-bit and 64-bit chunks.
5340    Mostly we use 32-bit chunks so we can use normal scalar instructions.  */
5341
5342 static int disas_neon_data_insn(DisasContext *s, uint32_t insn)
5343 {
5344     int op;
5345     int q;
5346     int rd, rn, rm, rd_ofs, rn_ofs, rm_ofs;
5347     int size;
5348     int shift;
5349     int pass;
5350     int count;
5351     int pairwise;
5352     int u;
5353     int vec_size;
5354     uint32_t imm;
5355     TCGv_i32 tmp, tmp2, tmp3, tmp4, tmp5;
5356     TCGv_ptr ptr1, ptr2;
5357     TCGv_i64 tmp64;
5358
5359     if (!arm_dc_feature(s, ARM_FEATURE_NEON)) {
5360         return 1;
5361     }
5362
5363     /* FIXME: this access check should not take precedence over UNDEF
5364      * for invalid encodings; we will generate incorrect syndrome information
5365      * for attempts to execute invalid vfp/neon encodings with FP disabled.
5366      */
5367     if (s->fp_excp_el) {
5368         gen_exception_insn(s, s->pc_curr, EXCP_UDEF,
5369                            syn_simd_access_trap(1, 0xe, false), s->fp_excp_el);
5370         return 0;
5371     }
5372
5373     if (!s->vfp_enabled)
5374       return 1;
5375     q = (insn & (1 << 6)) != 0;
5376     u = (insn >> 24) & 1;
5377     VFP_DREG_D(rd, insn);
5378     VFP_DREG_N(rn, insn);
5379     VFP_DREG_M(rm, insn);
5380     size = (insn >> 20) & 3;
5381     vec_size = q ? 16 : 8;
5382     rd_ofs = neon_reg_offset(rd, 0);
5383     rn_ofs = neon_reg_offset(rn, 0);
5384     rm_ofs = neon_reg_offset(rm, 0);
5385
5386     if ((insn & (1 << 23)) == 0) {
5387         /* Three register same length.  */
5388         op = ((insn >> 7) & 0x1e) | ((insn >> 4) & 1);
5389         /* Catch invalid op and bad size combinations: UNDEF */
5390         if ((neon_3r_sizes[op] & (1 << size)) == 0) {
5391             return 1;
5392         }
5393         /* All insns of this form UNDEF for either this condition or the
5394          * superset of cases "Q==1"; we catch the latter later.
5395          */
5396         if (q && ((rd | rn | rm) & 1)) {
5397             return 1;
5398         }
5399         switch (op) {
5400         case NEON_3R_VFM_VQRDMLSH:
5401             if (!u) {
5402                 /* VFM, VFMS */
5403                 if (size == 1) {
5404                     return 1;
5405                 }
5406                 break;
5407             }
5408             /* VQRDMLSH : handled by decodetree */
5409             return 1;
5410
5411         case NEON_3R_VADD_VSUB:
5412         case NEON_3R_LOGIC:
5413         case NEON_3R_VMAX:
5414         case NEON_3R_VMIN:
5415         case NEON_3R_VTST_VCEQ:
5416         case NEON_3R_VCGT:
5417         case NEON_3R_VCGE:
5418         case NEON_3R_VQADD:
5419         case NEON_3R_VQSUB:
5420         case NEON_3R_VMUL:
5421         case NEON_3R_VML:
5422         case NEON_3R_VSHL:
5423         case NEON_3R_SHA:
5424         case NEON_3R_VHADD:
5425         case NEON_3R_VRHADD:
5426         case NEON_3R_VHSUB:
5427         case NEON_3R_VABD:
5428         case NEON_3R_VABA:
5429         case NEON_3R_VQSHL:
5430         case NEON_3R_VRSHL:
5431         case NEON_3R_VQRSHL:
5432         case NEON_3R_VPMAX:
5433         case NEON_3R_VPMIN:
5434         case NEON_3R_VPADD_VQRDMLAH:
5435         case NEON_3R_VQDMULH_VQRDMULH:
5436             /* Already handled by decodetree */
5437             return 1;
5438         }
5439
5440         if (size == 3) {
5441             /* 64-bit element instructions: handled by decodetree */
5442             return 1;
5443         }
5444         pairwise = 0;
5445         switch (op) {
5446         case NEON_3R_FLOAT_ARITH:
5447             pairwise = (u && size < 2); /* if VPADD (float) */
5448             if (!pairwise) {
5449                 return 1; /* handled by decodetree */
5450             }
5451             break;
5452         case NEON_3R_FLOAT_MINMAX:
5453             pairwise = u; /* if VPMIN/VPMAX (float) */
5454             break;
5455         case NEON_3R_FLOAT_CMP:
5456             if (!u && size) {
5457                 /* no encoding for U=0 C=1x */
5458                 return 1;
5459             }
5460             break;
5461         case NEON_3R_FLOAT_ACMP:
5462             if (!u) {
5463                 return 1;
5464             }
5465             break;
5466         case NEON_3R_FLOAT_MISC:
5467             /* VMAXNM/VMINNM in ARMv8 */
5468             if (u && !arm_dc_feature(s, ARM_FEATURE_V8)) {
5469                 return 1;
5470             }
5471             break;
5472         case NEON_3R_VFM_VQRDMLSH:
5473             if (!dc_isar_feature(aa32_simdfmac, s)) {
5474                 return 1;
5475             }
5476             break;
5477         default:
5478             break;
5479         }
5480
5481         if (pairwise && q) {
5482             /* All the pairwise insns UNDEF if Q is set */
5483             return 1;
5484         }
5485
5486         for (pass = 0; pass < (q ? 4 : 2); pass++) {
5487
5488         if (pairwise) {
5489             /* Pairwise.  */
5490             if (pass < 1) {
5491                 tmp = neon_load_reg(rn, 0);
5492                 tmp2 = neon_load_reg(rn, 1);
5493             } else {
5494                 tmp = neon_load_reg(rm, 0);
5495                 tmp2 = neon_load_reg(rm, 1);
5496             }
5497         } else {
5498             /* Elementwise.  */
5499             tmp = neon_load_reg(rn, pass);
5500             tmp2 = neon_load_reg(rm, pass);
5501         }
5502         switch (op) {
5503         case NEON_3R_FLOAT_ARITH: /* Floating point arithmetic. */
5504         {
5505             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5506             switch ((u << 2) | size) {
5507             case 4: /* VPADD */
5508                 gen_helper_vfp_adds(tmp, tmp, tmp2, fpstatus);
5509                 break;
5510             default:
5511                 abort();
5512             }
5513             tcg_temp_free_ptr(fpstatus);
5514             break;
5515         }
5516         case NEON_3R_FLOAT_MULTIPLY:
5517         {
5518             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5519             gen_helper_vfp_muls(tmp, tmp, tmp2, fpstatus);
5520             if (!u) {
5521                 tcg_temp_free_i32(tmp2);
5522                 tmp2 = neon_load_reg(rd, pass);
5523                 if (size == 0) {
5524                     gen_helper_vfp_adds(tmp, tmp, tmp2, fpstatus);
5525                 } else {
5526                     gen_helper_vfp_subs(tmp, tmp2, tmp, fpstatus);
5527                 }
5528             }
5529             tcg_temp_free_ptr(fpstatus);
5530             break;
5531         }
5532         case NEON_3R_FLOAT_CMP:
5533         {
5534             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5535             if (!u) {
5536                 gen_helper_neon_ceq_f32(tmp, tmp, tmp2, fpstatus);
5537             } else {
5538                 if (size == 0) {
5539                     gen_helper_neon_cge_f32(tmp, tmp, tmp2, fpstatus);
5540                 } else {
5541                     gen_helper_neon_cgt_f32(tmp, tmp, tmp2, fpstatus);
5542                 }
5543             }
5544             tcg_temp_free_ptr(fpstatus);
5545             break;
5546         }
5547         case NEON_3R_FLOAT_ACMP:
5548         {
5549             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5550             if (size == 0) {
5551                 gen_helper_neon_acge_f32(tmp, tmp, tmp2, fpstatus);
5552             } else {
5553                 gen_helper_neon_acgt_f32(tmp, tmp, tmp2, fpstatus);
5554             }
5555             tcg_temp_free_ptr(fpstatus);
5556             break;
5557         }
5558         case NEON_3R_FLOAT_MINMAX:
5559         {
5560             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5561             if (size == 0) {
5562                 gen_helper_vfp_maxs(tmp, tmp, tmp2, fpstatus);
5563             } else {
5564                 gen_helper_vfp_mins(tmp, tmp, tmp2, fpstatus);
5565             }
5566             tcg_temp_free_ptr(fpstatus);
5567             break;
5568         }
5569         case NEON_3R_FLOAT_MISC:
5570             if (u) {
5571                 /* VMAXNM/VMINNM */
5572                 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5573                 if (size == 0) {
5574                     gen_helper_vfp_maxnums(tmp, tmp, tmp2, fpstatus);
5575                 } else {
5576                     gen_helper_vfp_minnums(tmp, tmp, tmp2, fpstatus);
5577                 }
5578                 tcg_temp_free_ptr(fpstatus);
5579             } else {
5580                 if (size == 0) {
5581                     gen_helper_recps_f32(tmp, tmp, tmp2, cpu_env);
5582                 } else {
5583                     gen_helper_rsqrts_f32(tmp, tmp, tmp2, cpu_env);
5584               }
5585             }
5586             break;
5587         case NEON_3R_VFM_VQRDMLSH:
5588         {
5589             /* VFMA, VFMS: fused multiply-add */
5590             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
5591             TCGv_i32 tmp3 = neon_load_reg(rd, pass);
5592             if (size) {
5593                 /* VFMS */
5594                 gen_helper_vfp_negs(tmp, tmp);
5595             }
5596             gen_helper_vfp_muladds(tmp, tmp, tmp2, tmp3, fpstatus);
5597             tcg_temp_free_i32(tmp3);
5598             tcg_temp_free_ptr(fpstatus);
5599             break;
5600         }
5601         default:
5602             abort();
5603         }
5604         tcg_temp_free_i32(tmp2);
5605
5606         /* Save the result.  For elementwise operations we can put it
5607            straight into the destination register.  For pairwise operations
5608            we have to be careful to avoid clobbering the source operands.  */
5609         if (pairwise && rd == rm) {
5610             neon_store_scratch(pass, tmp);
5611         } else {
5612             neon_store_reg(rd, pass, tmp);
5613         }
5614
5615         } /* for pass */
5616         if (pairwise && rd == rm) {
5617             for (pass = 0; pass < (q ? 4 : 2); pass++) {
5618                 tmp = neon_load_scratch(pass);
5619                 neon_store_reg(rd, pass, tmp);
5620             }
5621         }
5622         /* End of 3 register same size operations.  */
5623     } else if (insn & (1 << 4)) {
5624         if ((insn & 0x00380080) != 0) {
5625             /* Two registers and shift.  */
5626             op = (insn >> 8) & 0xf;
5627             if (insn & (1 << 7)) {
5628                 /* 64-bit shift. */
5629                 if (op > 7) {
5630                     return 1;
5631                 }
5632                 size = 3;
5633             } else {
5634                 size = 2;
5635                 while ((insn & (1 << (size + 19))) == 0)
5636                     size--;
5637             }
5638             shift = (insn >> 16) & ((1 << (3 + size)) - 1);
5639             if (op < 8) {
5640                 /* Shift by immediate:
5641                    VSHR, VSRA, VRSHR, VRSRA, VSRI, VSHL, VQSHL, VQSHLU.  */
5642                 if (q && ((rd | rm) & 1)) {
5643                     return 1;
5644                 }
5645                 if (!u && (op == 4 || op == 6)) {
5646                     return 1;
5647                 }
5648                 /* Right shifts are encoded as N - shift, where N is the
5649                    element size in bits.  */
5650                 if (op <= 4) {
5651                     shift = shift - (1 << (size + 3));
5652                 }
5653
5654                 switch (op) {
5655                 case 0:  /* VSHR */
5656                     /* Right shift comes here negative.  */
5657                     shift = -shift;
5658                     /* Shifts larger than the element size are architecturally
5659                      * valid.  Unsigned results in all zeros; signed results
5660                      * in all sign bits.
5661                      */
5662                     if (!u) {
5663                         tcg_gen_gvec_sari(size, rd_ofs, rm_ofs,
5664                                           MIN(shift, (8 << size) - 1),
5665                                           vec_size, vec_size);
5666                     } else if (shift >= 8 << size) {
5667                         tcg_gen_gvec_dup_imm(MO_8, rd_ofs, vec_size,
5668                                              vec_size, 0);
5669                     } else {
5670                         tcg_gen_gvec_shri(size, rd_ofs, rm_ofs, shift,
5671                                           vec_size, vec_size);
5672                     }
5673                     return 0;
5674
5675                 case 1:  /* VSRA */
5676                     /* Right shift comes here negative.  */
5677                     shift = -shift;
5678                     if (u) {
5679                         gen_gvec_usra(size, rd_ofs, rm_ofs, shift,
5680                                       vec_size, vec_size);
5681                     } else {
5682                         gen_gvec_ssra(size, rd_ofs, rm_ofs, shift,
5683                                       vec_size, vec_size);
5684                     }
5685                     return 0;
5686
5687                 case 2: /* VRSHR */
5688                     /* Right shift comes here negative.  */
5689                     shift = -shift;
5690                     if (u) {
5691                         gen_gvec_urshr(size, rd_ofs, rm_ofs, shift,
5692                                        vec_size, vec_size);
5693                     } else {
5694                         gen_gvec_srshr(size, rd_ofs, rm_ofs, shift,
5695                                        vec_size, vec_size);
5696                     }
5697                     return 0;
5698
5699                 case 3: /* VRSRA */
5700                     /* Right shift comes here negative.  */
5701                     shift = -shift;
5702                     if (u) {
5703                         gen_gvec_ursra(size, rd_ofs, rm_ofs, shift,
5704                                        vec_size, vec_size);
5705                     } else {
5706                         gen_gvec_srsra(size, rd_ofs, rm_ofs, shift,
5707                                        vec_size, vec_size);
5708                     }
5709                     return 0;
5710
5711                 case 4: /* VSRI */
5712                     if (!u) {
5713                         return 1;
5714                     }
5715                     /* Right shift comes here negative.  */
5716                     shift = -shift;
5717                     gen_gvec_sri(size, rd_ofs, rm_ofs, shift,
5718                                  vec_size, vec_size);
5719                     return 0;
5720
5721                 case 5: /* VSHL, VSLI */
5722                     if (u) { /* VSLI */
5723                         gen_gvec_sli(size, rd_ofs, rm_ofs, shift,
5724                                      vec_size, vec_size);
5725                     } else { /* VSHL */
5726                         tcg_gen_gvec_shli(size, rd_ofs, rm_ofs, shift,
5727                                           vec_size, vec_size);
5728                     }
5729                     return 0;
5730                 }
5731
5732                 if (size == 3) {
5733                     count = q + 1;
5734                 } else {
5735                     count = q ? 4: 2;
5736                 }
5737
5738                 /* To avoid excessive duplication of ops we implement shift
5739                  * by immediate using the variable shift operations.
5740                   */
5741                 imm = dup_const(size, shift);
5742
5743                 for (pass = 0; pass < count; pass++) {
5744                     if (size == 3) {
5745                         neon_load_reg64(cpu_V0, rm + pass);
5746                         tcg_gen_movi_i64(cpu_V1, imm);
5747                         switch (op) {
5748                         case 6: /* VQSHLU */
5749                             gen_helper_neon_qshlu_s64(cpu_V0, cpu_env,
5750                                                       cpu_V0, cpu_V1);
5751                             break;
5752                         case 7: /* VQSHL */
5753                             if (u) {
5754                                 gen_helper_neon_qshl_u64(cpu_V0, cpu_env,
5755                                                          cpu_V0, cpu_V1);
5756                             } else {
5757                                 gen_helper_neon_qshl_s64(cpu_V0, cpu_env,
5758                                                          cpu_V0, cpu_V1);
5759                             }
5760                             break;
5761                         default:
5762                             g_assert_not_reached();
5763                         }
5764                         neon_store_reg64(cpu_V0, rd + pass);
5765                     } else { /* size < 3 */
5766                         /* Operands in T0 and T1.  */
5767                         tmp = neon_load_reg(rm, pass);
5768                         tmp2 = tcg_temp_new_i32();
5769                         tcg_gen_movi_i32(tmp2, imm);
5770                         switch (op) {
5771                         case 6: /* VQSHLU */
5772                             switch (size) {
5773                             case 0:
5774                                 gen_helper_neon_qshlu_s8(tmp, cpu_env,
5775                                                          tmp, tmp2);
5776                                 break;
5777                             case 1:
5778                                 gen_helper_neon_qshlu_s16(tmp, cpu_env,
5779                                                           tmp, tmp2);
5780                                 break;
5781                             case 2:
5782                                 gen_helper_neon_qshlu_s32(tmp, cpu_env,
5783                                                           tmp, tmp2);
5784                                 break;
5785                             default:
5786                                 abort();
5787                             }
5788                             break;
5789                         case 7: /* VQSHL */
5790                             GEN_NEON_INTEGER_OP_ENV(qshl);
5791                             break;
5792                         default:
5793                             g_assert_not_reached();
5794                         }
5795                         tcg_temp_free_i32(tmp2);
5796                         neon_store_reg(rd, pass, tmp);
5797                     }
5798                 } /* for pass */
5799             } else if (op < 10) {
5800                 /* Shift by immediate and narrow:
5801                    VSHRN, VRSHRN, VQSHRN, VQRSHRN.  */
5802                 int input_unsigned = (op == 8) ? !u : u;
5803                 if (rm & 1) {
5804                     return 1;
5805                 }
5806                 shift = shift - (1 << (size + 3));
5807                 size++;
5808                 if (size == 3) {
5809                     tmp64 = tcg_const_i64(shift);
5810                     neon_load_reg64(cpu_V0, rm);
5811                     neon_load_reg64(cpu_V1, rm + 1);
5812                     for (pass = 0; pass < 2; pass++) {
5813                         TCGv_i64 in;
5814                         if (pass == 0) {
5815                             in = cpu_V0;
5816                         } else {
5817                             in = cpu_V1;
5818                         }
5819                         if (q) {
5820                             if (input_unsigned) {
5821                                 gen_helper_neon_rshl_u64(cpu_V0, in, tmp64);
5822                             } else {
5823                                 gen_helper_neon_rshl_s64(cpu_V0, in, tmp64);
5824                             }
5825                         } else {
5826                             if (input_unsigned) {
5827                                 gen_ushl_i64(cpu_V0, in, tmp64);
5828                             } else {
5829                                 gen_sshl_i64(cpu_V0, in, tmp64);
5830                             }
5831                         }
5832                         tmp = tcg_temp_new_i32();
5833                         gen_neon_narrow_op(op == 8, u, size - 1, tmp, cpu_V0);
5834                         neon_store_reg(rd, pass, tmp);
5835                     } /* for pass */
5836                     tcg_temp_free_i64(tmp64);
5837                 } else {
5838                     if (size == 1) {
5839                         imm = (uint16_t)shift;
5840                         imm |= imm << 16;
5841                     } else {
5842                         /* size == 2 */
5843                         imm = (uint32_t)shift;
5844                     }
5845                     tmp2 = tcg_const_i32(imm);
5846                     tmp4 = neon_load_reg(rm + 1, 0);
5847                     tmp5 = neon_load_reg(rm + 1, 1);
5848                     for (pass = 0; pass < 2; pass++) {
5849                         if (pass == 0) {
5850                             tmp = neon_load_reg(rm, 0);
5851                         } else {
5852                             tmp = tmp4;
5853                         }
5854                         gen_neon_shift_narrow(size, tmp, tmp2, q,
5855                                               input_unsigned);
5856                         if (pass == 0) {
5857                             tmp3 = neon_load_reg(rm, 1);
5858                         } else {
5859                             tmp3 = tmp5;
5860                         }
5861                         gen_neon_shift_narrow(size, tmp3, tmp2, q,
5862                                               input_unsigned);
5863                         tcg_gen_concat_i32_i64(cpu_V0, tmp, tmp3);
5864                         tcg_temp_free_i32(tmp);
5865                         tcg_temp_free_i32(tmp3);
5866                         tmp = tcg_temp_new_i32();
5867                         gen_neon_narrow_op(op == 8, u, size - 1, tmp, cpu_V0);
5868                         neon_store_reg(rd, pass, tmp);
5869                     } /* for pass */
5870                     tcg_temp_free_i32(tmp2);
5871                 }
5872             } else if (op == 10) {
5873                 /* VSHLL, VMOVL */
5874                 if (q || (rd & 1)) {
5875                     return 1;
5876                 }
5877                 tmp = neon_load_reg(rm, 0);
5878                 tmp2 = neon_load_reg(rm, 1);
5879                 for (pass = 0; pass < 2; pass++) {
5880                     if (pass == 1)
5881                         tmp = tmp2;
5882
5883                     gen_neon_widen(cpu_V0, tmp, size, u);
5884
5885                     if (shift != 0) {
5886                         /* The shift is less than the width of the source
5887                            type, so we can just shift the whole register.  */
5888                         tcg_gen_shli_i64(cpu_V0, cpu_V0, shift);
5889                         /* Widen the result of shift: we need to clear
5890                          * the potential overflow bits resulting from
5891                          * left bits of the narrow input appearing as
5892                          * right bits of left the neighbour narrow
5893                          * input.  */
5894                         if (size < 2 || !u) {
5895                             uint64_t imm64;
5896                             if (size == 0) {
5897                                 imm = (0xffu >> (8 - shift));
5898                                 imm |= imm << 16;
5899                             } else if (size == 1) {
5900                                 imm = 0xffff >> (16 - shift);
5901                             } else {
5902                                 /* size == 2 */
5903                                 imm = 0xffffffff >> (32 - shift);
5904                             }
5905                             if (size < 2) {
5906                                 imm64 = imm | (((uint64_t)imm) << 32);
5907                             } else {
5908                                 imm64 = imm;
5909                             }
5910                             tcg_gen_andi_i64(cpu_V0, cpu_V0, ~imm64);
5911                         }
5912                     }
5913                     neon_store_reg64(cpu_V0, rd + pass);
5914                 }
5915             } else if (op >= 14) {
5916                 /* VCVT fixed-point.  */
5917                 TCGv_ptr fpst;
5918                 TCGv_i32 shiftv;
5919                 VFPGenFixPointFn *fn;
5920
5921                 if (!(insn & (1 << 21)) || (q && ((rd | rm) & 1))) {
5922                     return 1;
5923                 }
5924
5925                 if (!(op & 1)) {
5926                     if (u) {
5927                         fn = gen_helper_vfp_ultos;
5928                     } else {
5929                         fn = gen_helper_vfp_sltos;
5930                     }
5931                 } else {
5932                     if (u) {
5933                         fn = gen_helper_vfp_touls_round_to_zero;
5934                     } else {
5935                         fn = gen_helper_vfp_tosls_round_to_zero;
5936                     }
5937                 }
5938
5939                 /* We have already masked out the must-be-1 top bit of imm6,
5940                  * hence this 32-shift where the ARM ARM has 64-imm6.
5941                  */
5942                 shift = 32 - shift;
5943                 fpst = get_fpstatus_ptr(1);
5944                 shiftv = tcg_const_i32(shift);
5945                 for (pass = 0; pass < (q ? 4 : 2); pass++) {
5946                     TCGv_i32 tmpf = neon_load_reg(rm, pass);
5947                     fn(tmpf, tmpf, shiftv, fpst);
5948                     neon_store_reg(rd, pass, tmpf);
5949                 }
5950                 tcg_temp_free_ptr(fpst);
5951                 tcg_temp_free_i32(shiftv);
5952             } else {
5953                 return 1;
5954             }
5955         } else { /* (insn & 0x00380080) == 0 */
5956             int invert, reg_ofs, vec_size;
5957
5958             if (q && (rd & 1)) {
5959                 return 1;
5960             }
5961
5962             op = (insn >> 8) & 0xf;
5963             /* One register and immediate.  */
5964             imm = (u << 7) | ((insn >> 12) & 0x70) | (insn & 0xf);
5965             invert = (insn & (1 << 5)) != 0;
5966             /* Note that op = 2,3,4,5,6,7,10,11,12,13 imm=0 is UNPREDICTABLE.
5967              * We choose to not special-case this and will behave as if a
5968              * valid constant encoding of 0 had been given.
5969              */
5970             switch (op) {
5971             case 0: case 1:
5972                 /* no-op */
5973                 break;
5974             case 2: case 3:
5975                 imm <<= 8;
5976                 break;
5977             case 4: case 5:
5978                 imm <<= 16;
5979                 break;
5980             case 6: case 7:
5981                 imm <<= 24;
5982                 break;
5983             case 8: case 9:
5984                 imm |= imm << 16;
5985                 break;
5986             case 10: case 11:
5987                 imm = (imm << 8) | (imm << 24);
5988                 break;
5989             case 12:
5990                 imm = (imm << 8) | 0xff;
5991                 break;
5992             case 13:
5993                 imm = (imm << 16) | 0xffff;
5994                 break;
5995             case 14:
5996                 imm |= (imm << 8) | (imm << 16) | (imm << 24);
5997                 if (invert) {
5998                     imm = ~imm;
5999                 }
6000                 break;
6001             case 15:
6002                 if (invert) {
6003                     return 1;
6004                 }
6005                 imm = ((imm & 0x80) << 24) | ((imm & 0x3f) << 19)
6006                       | ((imm & 0x40) ? (0x1f << 25) : (1 << 30));
6007                 break;
6008             }
6009             if (invert) {
6010                 imm = ~imm;
6011             }
6012
6013             reg_ofs = neon_reg_offset(rd, 0);
6014             vec_size = q ? 16 : 8;
6015
6016             if (op & 1 && op < 12) {
6017                 if (invert) {
6018                     /* The immediate value has already been inverted,
6019                      * so BIC becomes AND.
6020                      */
6021                     tcg_gen_gvec_andi(MO_32, reg_ofs, reg_ofs, imm,
6022                                       vec_size, vec_size);
6023                 } else {
6024                     tcg_gen_gvec_ori(MO_32, reg_ofs, reg_ofs, imm,
6025                                      vec_size, vec_size);
6026                 }
6027             } else {
6028                 /* VMOV, VMVN.  */
6029                 if (op == 14 && invert) {
6030                     TCGv_i64 t64 = tcg_temp_new_i64();
6031
6032                     for (pass = 0; pass <= q; ++pass) {
6033                         uint64_t val = 0;
6034                         int n;
6035
6036                         for (n = 0; n < 8; n++) {
6037                             if (imm & (1 << (n + pass * 8))) {
6038                                 val |= 0xffull << (n * 8);
6039                             }
6040                         }
6041                         tcg_gen_movi_i64(t64, val);
6042                         neon_store_reg64(t64, rd + pass);
6043                     }
6044                     tcg_temp_free_i64(t64);
6045                 } else {
6046                     tcg_gen_gvec_dup_imm(MO_32, reg_ofs, vec_size,
6047                                          vec_size, imm);
6048                 }
6049             }
6050         }
6051     } else { /* (insn & 0x00800010 == 0x00800000) */
6052         if (size != 3) {
6053             op = (insn >> 8) & 0xf;
6054             if ((insn & (1 << 6)) == 0) {
6055                 /* Three registers of different lengths.  */
6056                 int src1_wide;
6057                 int src2_wide;
6058                 int prewiden;
6059                 /* undefreq: bit 0 : UNDEF if size == 0
6060                  *           bit 1 : UNDEF if size == 1
6061                  *           bit 2 : UNDEF if size == 2
6062                  *           bit 3 : UNDEF if U == 1
6063                  * Note that [2:0] set implies 'always UNDEF'
6064                  */
6065                 int undefreq;
6066                 /* prewiden, src1_wide, src2_wide, undefreq */
6067                 static const int neon_3reg_wide[16][4] = {
6068                     {1, 0, 0, 0}, /* VADDL */
6069                     {1, 1, 0, 0}, /* VADDW */
6070                     {1, 0, 0, 0}, /* VSUBL */
6071                     {1, 1, 0, 0}, /* VSUBW */
6072                     {0, 1, 1, 0}, /* VADDHN */
6073                     {0, 0, 0, 0}, /* VABAL */
6074                     {0, 1, 1, 0}, /* VSUBHN */
6075                     {0, 0, 0, 0}, /* VABDL */
6076                     {0, 0, 0, 0}, /* VMLAL */
6077                     {0, 0, 0, 9}, /* VQDMLAL */
6078                     {0, 0, 0, 0}, /* VMLSL */
6079                     {0, 0, 0, 9}, /* VQDMLSL */
6080                     {0, 0, 0, 0}, /* Integer VMULL */
6081                     {0, 0, 0, 9}, /* VQDMULL */
6082                     {0, 0, 0, 0xa}, /* Polynomial VMULL */
6083                     {0, 0, 0, 7}, /* Reserved: always UNDEF */
6084                 };
6085
6086                 prewiden = neon_3reg_wide[op][0];
6087                 src1_wide = neon_3reg_wide[op][1];
6088                 src2_wide = neon_3reg_wide[op][2];
6089                 undefreq = neon_3reg_wide[op][3];
6090
6091                 if ((undefreq & (1 << size)) ||
6092                     ((undefreq & 8) && u)) {
6093                     return 1;
6094                 }
6095                 if ((src1_wide && (rn & 1)) ||
6096                     (src2_wide && (rm & 1)) ||
6097                     (!src2_wide && (rd & 1))) {
6098                     return 1;
6099                 }
6100
6101                 /* Handle polynomial VMULL in a single pass.  */
6102                 if (op == 14) {
6103                     if (size == 0) {
6104                         /* VMULL.P8 */
6105                         tcg_gen_gvec_3_ool(rd_ofs, rn_ofs, rm_ofs, 16, 16,
6106                                            0, gen_helper_neon_pmull_h);
6107                     } else {
6108                         /* VMULL.P64 */
6109                         if (!dc_isar_feature(aa32_pmull, s)) {
6110                             return 1;
6111                         }
6112                         tcg_gen_gvec_3_ool(rd_ofs, rn_ofs, rm_ofs, 16, 16,
6113                                            0, gen_helper_gvec_pmull_q);
6114                     }
6115                     return 0;
6116                 }
6117
6118                 /* Avoid overlapping operands.  Wide source operands are
6119                    always aligned so will never overlap with wide
6120                    destinations in problematic ways.  */
6121                 if (rd == rm && !src2_wide) {
6122                     tmp = neon_load_reg(rm, 1);
6123                     neon_store_scratch(2, tmp);
6124                 } else if (rd == rn && !src1_wide) {
6125                     tmp = neon_load_reg(rn, 1);
6126                     neon_store_scratch(2, tmp);
6127                 }
6128                 tmp3 = NULL;
6129                 for (pass = 0; pass < 2; pass++) {
6130                     if (src1_wide) {
6131                         neon_load_reg64(cpu_V0, rn + pass);
6132                         tmp = NULL;
6133                     } else {
6134                         if (pass == 1 && rd == rn) {
6135                             tmp = neon_load_scratch(2);
6136                         } else {
6137                             tmp = neon_load_reg(rn, pass);
6138                         }
6139                         if (prewiden) {
6140                             gen_neon_widen(cpu_V0, tmp, size, u);
6141                         }
6142                     }
6143                     if (src2_wide) {
6144                         neon_load_reg64(cpu_V1, rm + pass);
6145                         tmp2 = NULL;
6146                     } else {
6147                         if (pass == 1 && rd == rm) {
6148                             tmp2 = neon_load_scratch(2);
6149                         } else {
6150                             tmp2 = neon_load_reg(rm, pass);
6151                         }
6152                         if (prewiden) {
6153                             gen_neon_widen(cpu_V1, tmp2, size, u);
6154                         }
6155                     }
6156                     switch (op) {
6157                     case 0: case 1: case 4: /* VADDL, VADDW, VADDHN, VRADDHN */
6158                         gen_neon_addl(size);
6159                         break;
6160                     case 2: case 3: case 6: /* VSUBL, VSUBW, VSUBHN, VRSUBHN */
6161                         gen_neon_subl(size);
6162                         break;
6163                     case 5: case 7: /* VABAL, VABDL */
6164                         switch ((size << 1) | u) {
6165                         case 0:
6166                             gen_helper_neon_abdl_s16(cpu_V0, tmp, tmp2);
6167                             break;
6168                         case 1:
6169                             gen_helper_neon_abdl_u16(cpu_V0, tmp, tmp2);
6170                             break;
6171                         case 2:
6172                             gen_helper_neon_abdl_s32(cpu_V0, tmp, tmp2);
6173                             break;
6174                         case 3:
6175                             gen_helper_neon_abdl_u32(cpu_V0, tmp, tmp2);
6176                             break;
6177                         case 4:
6178                             gen_helper_neon_abdl_s64(cpu_V0, tmp, tmp2);
6179                             break;
6180                         case 5:
6181                             gen_helper_neon_abdl_u64(cpu_V0, tmp, tmp2);
6182                             break;
6183                         default: abort();
6184                         }
6185                         tcg_temp_free_i32(tmp2);
6186                         tcg_temp_free_i32(tmp);
6187                         break;
6188                     case 8: case 9: case 10: case 11: case 12: case 13:
6189                         /* VMLAL, VQDMLAL, VMLSL, VQDMLSL, VMULL, VQDMULL */
6190                         gen_neon_mull(cpu_V0, tmp, tmp2, size, u);
6191                         break;
6192                     default: /* 15 is RESERVED: caught earlier  */
6193                         abort();
6194                     }
6195                     if (op == 13) {
6196                         /* VQDMULL */
6197                         gen_neon_addl_saturate(cpu_V0, cpu_V0, size);
6198                         neon_store_reg64(cpu_V0, rd + pass);
6199                     } else if (op == 5 || (op >= 8 && op <= 11)) {
6200                         /* Accumulate.  */
6201                         neon_load_reg64(cpu_V1, rd + pass);
6202                         switch (op) {
6203                         case 10: /* VMLSL */
6204                             gen_neon_negl(cpu_V0, size);
6205                             /* Fall through */
6206                         case 5: case 8: /* VABAL, VMLAL */
6207                             gen_neon_addl(size);
6208                             break;
6209                         case 9: case 11: /* VQDMLAL, VQDMLSL */
6210                             gen_neon_addl_saturate(cpu_V0, cpu_V0, size);
6211                             if (op == 11) {
6212                                 gen_neon_negl(cpu_V0, size);
6213                             }
6214                             gen_neon_addl_saturate(cpu_V0, cpu_V1, size);
6215                             break;
6216                         default:
6217                             abort();
6218                         }
6219                         neon_store_reg64(cpu_V0, rd + pass);
6220                     } else if (op == 4 || op == 6) {
6221                         /* Narrowing operation.  */
6222                         tmp = tcg_temp_new_i32();
6223                         if (!u) {
6224                             switch (size) {
6225                             case 0:
6226                                 gen_helper_neon_narrow_high_u8(tmp, cpu_V0);
6227                                 break;
6228                             case 1:
6229                                 gen_helper_neon_narrow_high_u16(tmp, cpu_V0);
6230                                 break;
6231                             case 2:
6232                                 tcg_gen_extrh_i64_i32(tmp, cpu_V0);
6233                                 break;
6234                             default: abort();
6235                             }
6236                         } else {
6237                             switch (size) {
6238                             case 0:
6239                                 gen_helper_neon_narrow_round_high_u8(tmp, cpu_V0);
6240                                 break;
6241                             case 1:
6242                                 gen_helper_neon_narrow_round_high_u16(tmp, cpu_V0);
6243                                 break;
6244                             case 2:
6245                                 tcg_gen_addi_i64(cpu_V0, cpu_V0, 1u << 31);
6246                                 tcg_gen_extrh_i64_i32(tmp, cpu_V0);
6247                                 break;
6248                             default: abort();
6249                             }
6250                         }
6251                         if (pass == 0) {
6252                             tmp3 = tmp;
6253                         } else {
6254                             neon_store_reg(rd, 0, tmp3);
6255                             neon_store_reg(rd, 1, tmp);
6256                         }
6257                     } else {
6258                         /* Write back the result.  */
6259                         neon_store_reg64(cpu_V0, rd + pass);
6260                     }
6261                 }
6262             } else {
6263                 /* Two registers and a scalar. NB that for ops of this form
6264                  * the ARM ARM labels bit 24 as Q, but it is in our variable
6265                  * 'u', not 'q'.
6266                  */
6267                 if (size == 0) {
6268                     return 1;
6269                 }
6270                 switch (op) {
6271                 case 1: /* Float VMLA scalar */
6272                 case 5: /* Floating point VMLS scalar */
6273                 case 9: /* Floating point VMUL scalar */
6274                     if (size == 1) {
6275                         return 1;
6276                     }
6277                     /* fall through */
6278                 case 0: /* Integer VMLA scalar */
6279                 case 4: /* Integer VMLS scalar */
6280                 case 8: /* Integer VMUL scalar */
6281                 case 12: /* VQDMULH scalar */
6282                 case 13: /* VQRDMULH scalar */
6283                     if (u && ((rd | rn) & 1)) {
6284                         return 1;
6285                     }
6286                     tmp = neon_get_scalar(size, rm);
6287                     neon_store_scratch(0, tmp);
6288                     for (pass = 0; pass < (u ? 4 : 2); pass++) {
6289                         tmp = neon_load_scratch(0);
6290                         tmp2 = neon_load_reg(rn, pass);
6291                         if (op == 12) {
6292                             if (size == 1) {
6293                                 gen_helper_neon_qdmulh_s16(tmp, cpu_env, tmp, tmp2);
6294                             } else {
6295                                 gen_helper_neon_qdmulh_s32(tmp, cpu_env, tmp, tmp2);
6296                             }
6297                         } else if (op == 13) {
6298                             if (size == 1) {
6299                                 gen_helper_neon_qrdmulh_s16(tmp, cpu_env, tmp, tmp2);
6300                             } else {
6301                                 gen_helper_neon_qrdmulh_s32(tmp, cpu_env, tmp, tmp2);
6302                             }
6303                         } else if (op & 1) {
6304                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6305                             gen_helper_vfp_muls(tmp, tmp, tmp2, fpstatus);
6306                             tcg_temp_free_ptr(fpstatus);
6307                         } else {
6308                             switch (size) {
6309                             case 0: gen_helper_neon_mul_u8(tmp, tmp, tmp2); break;
6310                             case 1: gen_helper_neon_mul_u16(tmp, tmp, tmp2); break;
6311                             case 2: tcg_gen_mul_i32(tmp, tmp, tmp2); break;
6312                             default: abort();
6313                             }
6314                         }
6315                         tcg_temp_free_i32(tmp2);
6316                         if (op < 8) {
6317                             /* Accumulate.  */
6318                             tmp2 = neon_load_reg(rd, pass);
6319                             switch (op) {
6320                             case 0:
6321                                 gen_neon_add(size, tmp, tmp2);
6322                                 break;
6323                             case 1:
6324                             {
6325                                 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6326                                 gen_helper_vfp_adds(tmp, tmp, tmp2, fpstatus);
6327                                 tcg_temp_free_ptr(fpstatus);
6328                                 break;
6329                             }
6330                             case 4:
6331                                 gen_neon_rsb(size, tmp, tmp2);
6332                                 break;
6333                             case 5:
6334                             {
6335                                 TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6336                                 gen_helper_vfp_subs(tmp, tmp2, tmp, fpstatus);
6337                                 tcg_temp_free_ptr(fpstatus);
6338                                 break;
6339                             }
6340                             default:
6341                                 abort();
6342                             }
6343                             tcg_temp_free_i32(tmp2);
6344                         }
6345                         neon_store_reg(rd, pass, tmp);
6346                     }
6347                     break;
6348                 case 3: /* VQDMLAL scalar */
6349                 case 7: /* VQDMLSL scalar */
6350                 case 11: /* VQDMULL scalar */
6351                     if (u == 1) {
6352                         return 1;
6353                     }
6354                     /* fall through */
6355                 case 2: /* VMLAL sclar */
6356                 case 6: /* VMLSL scalar */
6357                 case 10: /* VMULL scalar */
6358                     if (rd & 1) {
6359                         return 1;
6360                     }
6361                     tmp2 = neon_get_scalar(size, rm);
6362                     /* We need a copy of tmp2 because gen_neon_mull
6363                      * deletes it during pass 0.  */
6364                     tmp4 = tcg_temp_new_i32();
6365                     tcg_gen_mov_i32(tmp4, tmp2);
6366                     tmp3 = neon_load_reg(rn, 1);
6367
6368                     for (pass = 0; pass < 2; pass++) {
6369                         if (pass == 0) {
6370                             tmp = neon_load_reg(rn, 0);
6371                         } else {
6372                             tmp = tmp3;
6373                             tmp2 = tmp4;
6374                         }
6375                         gen_neon_mull(cpu_V0, tmp, tmp2, size, u);
6376                         if (op != 11) {
6377                             neon_load_reg64(cpu_V1, rd + pass);
6378                         }
6379                         switch (op) {
6380                         case 6:
6381                             gen_neon_negl(cpu_V0, size);
6382                             /* Fall through */
6383                         case 2:
6384                             gen_neon_addl(size);
6385                             break;
6386                         case 3: case 7:
6387                             gen_neon_addl_saturate(cpu_V0, cpu_V0, size);
6388                             if (op == 7) {
6389                                 gen_neon_negl(cpu_V0, size);
6390                             }
6391                             gen_neon_addl_saturate(cpu_V0, cpu_V1, size);
6392                             break;
6393                         case 10:
6394                             /* no-op */
6395                             break;
6396                         case 11:
6397                             gen_neon_addl_saturate(cpu_V0, cpu_V0, size);
6398                             break;
6399                         default:
6400                             abort();
6401                         }
6402                         neon_store_reg64(cpu_V0, rd + pass);
6403                     }
6404                     break;
6405                 case 14: /* VQRDMLAH scalar */
6406                 case 15: /* VQRDMLSH scalar */
6407                     {
6408                         NeonGenThreeOpEnvFn *fn;
6409
6410                         if (!dc_isar_feature(aa32_rdm, s)) {
6411                             return 1;
6412                         }
6413                         if (u && ((rd | rn) & 1)) {
6414                             return 1;
6415                         }
6416                         if (op == 14) {
6417                             if (size == 1) {
6418                                 fn = gen_helper_neon_qrdmlah_s16;
6419                             } else {
6420                                 fn = gen_helper_neon_qrdmlah_s32;
6421                             }
6422                         } else {
6423                             if (size == 1) {
6424                                 fn = gen_helper_neon_qrdmlsh_s16;
6425                             } else {
6426                                 fn = gen_helper_neon_qrdmlsh_s32;
6427                             }
6428                         }
6429
6430                         tmp2 = neon_get_scalar(size, rm);
6431                         for (pass = 0; pass < (u ? 4 : 2); pass++) {
6432                             tmp = neon_load_reg(rn, pass);
6433                             tmp3 = neon_load_reg(rd, pass);
6434                             fn(tmp, cpu_env, tmp, tmp2, tmp3);
6435                             tcg_temp_free_i32(tmp3);
6436                             neon_store_reg(rd, pass, tmp);
6437                         }
6438                         tcg_temp_free_i32(tmp2);
6439                     }
6440                     break;
6441                 default:
6442                     g_assert_not_reached();
6443                 }
6444             }
6445         } else { /* size == 3 */
6446             if (!u) {
6447                 /* Extract.  */
6448                 imm = (insn >> 8) & 0xf;
6449
6450                 if (imm > 7 && !q)
6451                     return 1;
6452
6453                 if (q && ((rd | rn | rm) & 1)) {
6454                     return 1;
6455                 }
6456
6457                 if (imm == 0) {
6458                     neon_load_reg64(cpu_V0, rn);
6459                     if (q) {
6460                         neon_load_reg64(cpu_V1, rn + 1);
6461                     }
6462                 } else if (imm == 8) {
6463                     neon_load_reg64(cpu_V0, rn + 1);
6464                     if (q) {
6465                         neon_load_reg64(cpu_V1, rm);
6466                     }
6467                 } else if (q) {
6468                     tmp64 = tcg_temp_new_i64();
6469                     if (imm < 8) {
6470                         neon_load_reg64(cpu_V0, rn);
6471                         neon_load_reg64(tmp64, rn + 1);
6472                     } else {
6473                         neon_load_reg64(cpu_V0, rn + 1);
6474                         neon_load_reg64(tmp64, rm);
6475                     }
6476                     tcg_gen_shri_i64(cpu_V0, cpu_V0, (imm & 7) * 8);
6477                     tcg_gen_shli_i64(cpu_V1, tmp64, 64 - ((imm & 7) * 8));
6478                     tcg_gen_or_i64(cpu_V0, cpu_V0, cpu_V1);
6479                     if (imm < 8) {
6480                         neon_load_reg64(cpu_V1, rm);
6481                     } else {
6482                         neon_load_reg64(cpu_V1, rm + 1);
6483                         imm -= 8;
6484                     }
6485                     tcg_gen_shli_i64(cpu_V1, cpu_V1, 64 - (imm * 8));
6486                     tcg_gen_shri_i64(tmp64, tmp64, imm * 8);
6487                     tcg_gen_or_i64(cpu_V1, cpu_V1, tmp64);
6488                     tcg_temp_free_i64(tmp64);
6489                 } else {
6490                     /* BUGFIX */
6491                     neon_load_reg64(cpu_V0, rn);
6492                     tcg_gen_shri_i64(cpu_V0, cpu_V0, imm * 8);
6493                     neon_load_reg64(cpu_V1, rm);
6494                     tcg_gen_shli_i64(cpu_V1, cpu_V1, 64 - (imm * 8));
6495                     tcg_gen_or_i64(cpu_V0, cpu_V0, cpu_V1);
6496                 }
6497                 neon_store_reg64(cpu_V0, rd);
6498                 if (q) {
6499                     neon_store_reg64(cpu_V1, rd + 1);
6500                 }
6501             } else if ((insn & (1 << 11)) == 0) {
6502                 /* Two register misc.  */
6503                 op = ((insn >> 12) & 0x30) | ((insn >> 7) & 0xf);
6504                 size = (insn >> 18) & 3;
6505                 /* UNDEF for unknown op values and bad op-size combinations */
6506                 if ((neon_2rm_sizes[op] & (1 << size)) == 0) {
6507                     return 1;
6508                 }
6509                 if (neon_2rm_is_v8_op(op) &&
6510                     !arm_dc_feature(s, ARM_FEATURE_V8)) {
6511                     return 1;
6512                 }
6513                 if ((op != NEON_2RM_VMOVN && op != NEON_2RM_VQMOVN) &&
6514                     q && ((rm | rd) & 1)) {
6515                     return 1;
6516                 }
6517                 switch (op) {
6518                 case NEON_2RM_VREV64:
6519                     for (pass = 0; pass < (q ? 2 : 1); pass++) {
6520                         tmp = neon_load_reg(rm, pass * 2);
6521                         tmp2 = neon_load_reg(rm, pass * 2 + 1);
6522                         switch (size) {
6523                         case 0: tcg_gen_bswap32_i32(tmp, tmp); break;
6524                         case 1: gen_swap_half(tmp); break;
6525                         case 2: /* no-op */ break;
6526                         default: abort();
6527                         }
6528                         neon_store_reg(rd, pass * 2 + 1, tmp);
6529                         if (size == 2) {
6530                             neon_store_reg(rd, pass * 2, tmp2);
6531                         } else {
6532                             switch (size) {
6533                             case 0: tcg_gen_bswap32_i32(tmp2, tmp2); break;
6534                             case 1: gen_swap_half(tmp2); break;
6535                             default: abort();
6536                             }
6537                             neon_store_reg(rd, pass * 2, tmp2);
6538                         }
6539                     }
6540                     break;
6541                 case NEON_2RM_VPADDL: case NEON_2RM_VPADDL_U:
6542                 case NEON_2RM_VPADAL: case NEON_2RM_VPADAL_U:
6543                     for (pass = 0; pass < q + 1; pass++) {
6544                         tmp = neon_load_reg(rm, pass * 2);
6545                         gen_neon_widen(cpu_V0, tmp, size, op & 1);
6546                         tmp = neon_load_reg(rm, pass * 2 + 1);
6547                         gen_neon_widen(cpu_V1, tmp, size, op & 1);
6548                         switch (size) {
6549                         case 0: gen_helper_neon_paddl_u16(CPU_V001); break;
6550                         case 1: gen_helper_neon_paddl_u32(CPU_V001); break;
6551                         case 2: tcg_gen_add_i64(CPU_V001); break;
6552                         default: abort();
6553                         }
6554                         if (op >= NEON_2RM_VPADAL) {
6555                             /* Accumulate.  */
6556                             neon_load_reg64(cpu_V1, rd + pass);
6557                             gen_neon_addl(size);
6558                         }
6559                         neon_store_reg64(cpu_V0, rd + pass);
6560                     }
6561                     break;
6562                 case NEON_2RM_VTRN:
6563                     if (size == 2) {
6564                         int n;
6565                         for (n = 0; n < (q ? 4 : 2); n += 2) {
6566                             tmp = neon_load_reg(rm, n);
6567                             tmp2 = neon_load_reg(rd, n + 1);
6568                             neon_store_reg(rm, n, tmp2);
6569                             neon_store_reg(rd, n + 1, tmp);
6570                         }
6571                     } else {
6572                         goto elementwise;
6573                     }
6574                     break;
6575                 case NEON_2RM_VUZP:
6576                     if (gen_neon_unzip(rd, rm, size, q)) {
6577                         return 1;
6578                     }
6579                     break;
6580                 case NEON_2RM_VZIP:
6581                     if (gen_neon_zip(rd, rm, size, q)) {
6582                         return 1;
6583                     }
6584                     break;
6585                 case NEON_2RM_VMOVN: case NEON_2RM_VQMOVN:
6586                     /* also VQMOVUN; op field and mnemonics don't line up */
6587                     if (rm & 1) {
6588                         return 1;
6589                     }
6590                     tmp2 = NULL;
6591                     for (pass = 0; pass < 2; pass++) {
6592                         neon_load_reg64(cpu_V0, rm + pass);
6593                         tmp = tcg_temp_new_i32();
6594                         gen_neon_narrow_op(op == NEON_2RM_VMOVN, q, size,
6595                                            tmp, cpu_V0);
6596                         if (pass == 0) {
6597                             tmp2 = tmp;
6598                         } else {
6599                             neon_store_reg(rd, 0, tmp2);
6600                             neon_store_reg(rd, 1, tmp);
6601                         }
6602                     }
6603                     break;
6604                 case NEON_2RM_VSHLL:
6605                     if (q || (rd & 1)) {
6606                         return 1;
6607                     }
6608                     tmp = neon_load_reg(rm, 0);
6609                     tmp2 = neon_load_reg(rm, 1);
6610                     for (pass = 0; pass < 2; pass++) {
6611                         if (pass == 1)
6612                             tmp = tmp2;
6613                         gen_neon_widen(cpu_V0, tmp, size, 1);
6614                         tcg_gen_shli_i64(cpu_V0, cpu_V0, 8 << size);
6615                         neon_store_reg64(cpu_V0, rd + pass);
6616                     }
6617                     break;
6618                 case NEON_2RM_VCVT_F16_F32:
6619                 {
6620                     TCGv_ptr fpst;
6621                     TCGv_i32 ahp;
6622
6623                     if (!dc_isar_feature(aa32_fp16_spconv, s) ||
6624                         q || (rm & 1)) {
6625                         return 1;
6626                     }
6627                     fpst = get_fpstatus_ptr(true);
6628                     ahp = get_ahp_flag();
6629                     tmp = neon_load_reg(rm, 0);
6630                     gen_helper_vfp_fcvt_f32_to_f16(tmp, tmp, fpst, ahp);
6631                     tmp2 = neon_load_reg(rm, 1);
6632                     gen_helper_vfp_fcvt_f32_to_f16(tmp2, tmp2, fpst, ahp);
6633                     tcg_gen_shli_i32(tmp2, tmp2, 16);
6634                     tcg_gen_or_i32(tmp2, tmp2, tmp);
6635                     tcg_temp_free_i32(tmp);
6636                     tmp = neon_load_reg(rm, 2);
6637                     gen_helper_vfp_fcvt_f32_to_f16(tmp, tmp, fpst, ahp);
6638                     tmp3 = neon_load_reg(rm, 3);
6639                     neon_store_reg(rd, 0, tmp2);
6640                     gen_helper_vfp_fcvt_f32_to_f16(tmp3, tmp3, fpst, ahp);
6641                     tcg_gen_shli_i32(tmp3, tmp3, 16);
6642                     tcg_gen_or_i32(tmp3, tmp3, tmp);
6643                     neon_store_reg(rd, 1, tmp3);
6644                     tcg_temp_free_i32(tmp);
6645                     tcg_temp_free_i32(ahp);
6646                     tcg_temp_free_ptr(fpst);
6647                     break;
6648                 }
6649                 case NEON_2RM_VCVT_F32_F16:
6650                 {
6651                     TCGv_ptr fpst;
6652                     TCGv_i32 ahp;
6653                     if (!dc_isar_feature(aa32_fp16_spconv, s) ||
6654                         q || (rd & 1)) {
6655                         return 1;
6656                     }
6657                     fpst = get_fpstatus_ptr(true);
6658                     ahp = get_ahp_flag();
6659                     tmp3 = tcg_temp_new_i32();
6660                     tmp = neon_load_reg(rm, 0);
6661                     tmp2 = neon_load_reg(rm, 1);
6662                     tcg_gen_ext16u_i32(tmp3, tmp);
6663                     gen_helper_vfp_fcvt_f16_to_f32(tmp3, tmp3, fpst, ahp);
6664                     neon_store_reg(rd, 0, tmp3);
6665                     tcg_gen_shri_i32(tmp, tmp, 16);
6666                     gen_helper_vfp_fcvt_f16_to_f32(tmp, tmp, fpst, ahp);
6667                     neon_store_reg(rd, 1, tmp);
6668                     tmp3 = tcg_temp_new_i32();
6669                     tcg_gen_ext16u_i32(tmp3, tmp2);
6670                     gen_helper_vfp_fcvt_f16_to_f32(tmp3, tmp3, fpst, ahp);
6671                     neon_store_reg(rd, 2, tmp3);
6672                     tcg_gen_shri_i32(tmp2, tmp2, 16);
6673                     gen_helper_vfp_fcvt_f16_to_f32(tmp2, tmp2, fpst, ahp);
6674                     neon_store_reg(rd, 3, tmp2);
6675                     tcg_temp_free_i32(ahp);
6676                     tcg_temp_free_ptr(fpst);
6677                     break;
6678                 }
6679                 case NEON_2RM_AESE: case NEON_2RM_AESMC:
6680                     if (!dc_isar_feature(aa32_aes, s) || ((rm | rd) & 1)) {
6681                         return 1;
6682                     }
6683                     ptr1 = vfp_reg_ptr(true, rd);
6684                     ptr2 = vfp_reg_ptr(true, rm);
6685
6686                      /* Bit 6 is the lowest opcode bit; it distinguishes between
6687                       * encryption (AESE/AESMC) and decryption (AESD/AESIMC)
6688                       */
6689                     tmp3 = tcg_const_i32(extract32(insn, 6, 1));
6690
6691                     if (op == NEON_2RM_AESE) {
6692                         gen_helper_crypto_aese(ptr1, ptr2, tmp3);
6693                     } else {
6694                         gen_helper_crypto_aesmc(ptr1, ptr2, tmp3);
6695                     }
6696                     tcg_temp_free_ptr(ptr1);
6697                     tcg_temp_free_ptr(ptr2);
6698                     tcg_temp_free_i32(tmp3);
6699                     break;
6700                 case NEON_2RM_SHA1H:
6701                     if (!dc_isar_feature(aa32_sha1, s) || ((rm | rd) & 1)) {
6702                         return 1;
6703                     }
6704                     ptr1 = vfp_reg_ptr(true, rd);
6705                     ptr2 = vfp_reg_ptr(true, rm);
6706
6707                     gen_helper_crypto_sha1h(ptr1, ptr2);
6708
6709                     tcg_temp_free_ptr(ptr1);
6710                     tcg_temp_free_ptr(ptr2);
6711                     break;
6712                 case NEON_2RM_SHA1SU1:
6713                     if ((rm | rd) & 1) {
6714                             return 1;
6715                     }
6716                     /* bit 6 (q): set -> SHA256SU0, cleared -> SHA1SU1 */
6717                     if (q) {
6718                         if (!dc_isar_feature(aa32_sha2, s)) {
6719                             return 1;
6720                         }
6721                     } else if (!dc_isar_feature(aa32_sha1, s)) {
6722                         return 1;
6723                     }
6724                     ptr1 = vfp_reg_ptr(true, rd);
6725                     ptr2 = vfp_reg_ptr(true, rm);
6726                     if (q) {
6727                         gen_helper_crypto_sha256su0(ptr1, ptr2);
6728                     } else {
6729                         gen_helper_crypto_sha1su1(ptr1, ptr2);
6730                     }
6731                     tcg_temp_free_ptr(ptr1);
6732                     tcg_temp_free_ptr(ptr2);
6733                     break;
6734
6735                 case NEON_2RM_VMVN:
6736                     tcg_gen_gvec_not(0, rd_ofs, rm_ofs, vec_size, vec_size);
6737                     break;
6738                 case NEON_2RM_VNEG:
6739                     tcg_gen_gvec_neg(size, rd_ofs, rm_ofs, vec_size, vec_size);
6740                     break;
6741                 case NEON_2RM_VABS:
6742                     tcg_gen_gvec_abs(size, rd_ofs, rm_ofs, vec_size, vec_size);
6743                     break;
6744
6745                 case NEON_2RM_VCEQ0:
6746                     gen_gvec_ceq0(size, rd_ofs, rm_ofs, vec_size, vec_size);
6747                     break;
6748                 case NEON_2RM_VCGT0:
6749                     gen_gvec_cgt0(size, rd_ofs, rm_ofs, vec_size, vec_size);
6750                     break;
6751                 case NEON_2RM_VCLE0:
6752                     gen_gvec_cle0(size, rd_ofs, rm_ofs, vec_size, vec_size);
6753                     break;
6754                 case NEON_2RM_VCGE0:
6755                     gen_gvec_cge0(size, rd_ofs, rm_ofs, vec_size, vec_size);
6756                     break;
6757                 case NEON_2RM_VCLT0:
6758                     gen_gvec_clt0(size, rd_ofs, rm_ofs, vec_size, vec_size);
6759                     break;
6760
6761                 default:
6762                 elementwise:
6763                     for (pass = 0; pass < (q ? 4 : 2); pass++) {
6764                         tmp = neon_load_reg(rm, pass);
6765                         switch (op) {
6766                         case NEON_2RM_VREV32:
6767                             switch (size) {
6768                             case 0: tcg_gen_bswap32_i32(tmp, tmp); break;
6769                             case 1: gen_swap_half(tmp); break;
6770                             default: abort();
6771                             }
6772                             break;
6773                         case NEON_2RM_VREV16:
6774                             gen_rev16(tmp, tmp);
6775                             break;
6776                         case NEON_2RM_VCLS:
6777                             switch (size) {
6778                             case 0: gen_helper_neon_cls_s8(tmp, tmp); break;
6779                             case 1: gen_helper_neon_cls_s16(tmp, tmp); break;
6780                             case 2: gen_helper_neon_cls_s32(tmp, tmp); break;
6781                             default: abort();
6782                             }
6783                             break;
6784                         case NEON_2RM_VCLZ:
6785                             switch (size) {
6786                             case 0: gen_helper_neon_clz_u8(tmp, tmp); break;
6787                             case 1: gen_helper_neon_clz_u16(tmp, tmp); break;
6788                             case 2: tcg_gen_clzi_i32(tmp, tmp, 32); break;
6789                             default: abort();
6790                             }
6791                             break;
6792                         case NEON_2RM_VCNT:
6793                             gen_helper_neon_cnt_u8(tmp, tmp);
6794                             break;
6795                         case NEON_2RM_VQABS:
6796                             switch (size) {
6797                             case 0:
6798                                 gen_helper_neon_qabs_s8(tmp, cpu_env, tmp);
6799                                 break;
6800                             case 1:
6801                                 gen_helper_neon_qabs_s16(tmp, cpu_env, tmp);
6802                                 break;
6803                             case 2:
6804                                 gen_helper_neon_qabs_s32(tmp, cpu_env, tmp);
6805                                 break;
6806                             default: abort();
6807                             }
6808                             break;
6809                         case NEON_2RM_VQNEG:
6810                             switch (size) {
6811                             case 0:
6812                                 gen_helper_neon_qneg_s8(tmp, cpu_env, tmp);
6813                                 break;
6814                             case 1:
6815                                 gen_helper_neon_qneg_s16(tmp, cpu_env, tmp);
6816                                 break;
6817                             case 2:
6818                                 gen_helper_neon_qneg_s32(tmp, cpu_env, tmp);
6819                                 break;
6820                             default: abort();
6821                             }
6822                             break;
6823                         case NEON_2RM_VCGT0_F:
6824                         {
6825                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6826                             tmp2 = tcg_const_i32(0);
6827                             gen_helper_neon_cgt_f32(tmp, tmp, tmp2, fpstatus);
6828                             tcg_temp_free_i32(tmp2);
6829                             tcg_temp_free_ptr(fpstatus);
6830                             break;
6831                         }
6832                         case NEON_2RM_VCGE0_F:
6833                         {
6834                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6835                             tmp2 = tcg_const_i32(0);
6836                             gen_helper_neon_cge_f32(tmp, tmp, tmp2, fpstatus);
6837                             tcg_temp_free_i32(tmp2);
6838                             tcg_temp_free_ptr(fpstatus);
6839                             break;
6840                         }
6841                         case NEON_2RM_VCEQ0_F:
6842                         {
6843                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6844                             tmp2 = tcg_const_i32(0);
6845                             gen_helper_neon_ceq_f32(tmp, tmp, tmp2, fpstatus);
6846                             tcg_temp_free_i32(tmp2);
6847                             tcg_temp_free_ptr(fpstatus);
6848                             break;
6849                         }
6850                         case NEON_2RM_VCLE0_F:
6851                         {
6852                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6853                             tmp2 = tcg_const_i32(0);
6854                             gen_helper_neon_cge_f32(tmp, tmp2, tmp, fpstatus);
6855                             tcg_temp_free_i32(tmp2);
6856                             tcg_temp_free_ptr(fpstatus);
6857                             break;
6858                         }
6859                         case NEON_2RM_VCLT0_F:
6860                         {
6861                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6862                             tmp2 = tcg_const_i32(0);
6863                             gen_helper_neon_cgt_f32(tmp, tmp2, tmp, fpstatus);
6864                             tcg_temp_free_i32(tmp2);
6865                             tcg_temp_free_ptr(fpstatus);
6866                             break;
6867                         }
6868                         case NEON_2RM_VABS_F:
6869                             gen_helper_vfp_abss(tmp, tmp);
6870                             break;
6871                         case NEON_2RM_VNEG_F:
6872                             gen_helper_vfp_negs(tmp, tmp);
6873                             break;
6874                         case NEON_2RM_VSWP:
6875                             tmp2 = neon_load_reg(rd, pass);
6876                             neon_store_reg(rm, pass, tmp2);
6877                             break;
6878                         case NEON_2RM_VTRN:
6879                             tmp2 = neon_load_reg(rd, pass);
6880                             switch (size) {
6881                             case 0: gen_neon_trn_u8(tmp, tmp2); break;
6882                             case 1: gen_neon_trn_u16(tmp, tmp2); break;
6883                             default: abort();
6884                             }
6885                             neon_store_reg(rm, pass, tmp2);
6886                             break;
6887                         case NEON_2RM_VRINTN:
6888                         case NEON_2RM_VRINTA:
6889                         case NEON_2RM_VRINTM:
6890                         case NEON_2RM_VRINTP:
6891                         case NEON_2RM_VRINTZ:
6892                         {
6893                             TCGv_i32 tcg_rmode;
6894                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6895                             int rmode;
6896
6897                             if (op == NEON_2RM_VRINTZ) {
6898                                 rmode = FPROUNDING_ZERO;
6899                             } else {
6900                                 rmode = fp_decode_rm[((op & 0x6) >> 1) ^ 1];
6901                             }
6902
6903                             tcg_rmode = tcg_const_i32(arm_rmode_to_sf(rmode));
6904                             gen_helper_set_neon_rmode(tcg_rmode, tcg_rmode,
6905                                                       cpu_env);
6906                             gen_helper_rints(tmp, tmp, fpstatus);
6907                             gen_helper_set_neon_rmode(tcg_rmode, tcg_rmode,
6908                                                       cpu_env);
6909                             tcg_temp_free_ptr(fpstatus);
6910                             tcg_temp_free_i32(tcg_rmode);
6911                             break;
6912                         }
6913                         case NEON_2RM_VRINTX:
6914                         {
6915                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6916                             gen_helper_rints_exact(tmp, tmp, fpstatus);
6917                             tcg_temp_free_ptr(fpstatus);
6918                             break;
6919                         }
6920                         case NEON_2RM_VCVTAU:
6921                         case NEON_2RM_VCVTAS:
6922                         case NEON_2RM_VCVTNU:
6923                         case NEON_2RM_VCVTNS:
6924                         case NEON_2RM_VCVTPU:
6925                         case NEON_2RM_VCVTPS:
6926                         case NEON_2RM_VCVTMU:
6927                         case NEON_2RM_VCVTMS:
6928                         {
6929                             bool is_signed = !extract32(insn, 7, 1);
6930                             TCGv_ptr fpst = get_fpstatus_ptr(1);
6931                             TCGv_i32 tcg_rmode, tcg_shift;
6932                             int rmode = fp_decode_rm[extract32(insn, 8, 2)];
6933
6934                             tcg_shift = tcg_const_i32(0);
6935                             tcg_rmode = tcg_const_i32(arm_rmode_to_sf(rmode));
6936                             gen_helper_set_neon_rmode(tcg_rmode, tcg_rmode,
6937                                                       cpu_env);
6938
6939                             if (is_signed) {
6940                                 gen_helper_vfp_tosls(tmp, tmp,
6941                                                      tcg_shift, fpst);
6942                             } else {
6943                                 gen_helper_vfp_touls(tmp, tmp,
6944                                                      tcg_shift, fpst);
6945                             }
6946
6947                             gen_helper_set_neon_rmode(tcg_rmode, tcg_rmode,
6948                                                       cpu_env);
6949                             tcg_temp_free_i32(tcg_rmode);
6950                             tcg_temp_free_i32(tcg_shift);
6951                             tcg_temp_free_ptr(fpst);
6952                             break;
6953                         }
6954                         case NEON_2RM_VRECPE:
6955                             gen_helper_recpe_u32(tmp, tmp);
6956                             break;
6957                         case NEON_2RM_VRSQRTE:
6958                             gen_helper_rsqrte_u32(tmp, tmp);
6959                             break;
6960                         case NEON_2RM_VRECPE_F:
6961                         {
6962                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6963                             gen_helper_recpe_f32(tmp, tmp, fpstatus);
6964                             tcg_temp_free_ptr(fpstatus);
6965                             break;
6966                         }
6967                         case NEON_2RM_VRSQRTE_F:
6968                         {
6969                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6970                             gen_helper_rsqrte_f32(tmp, tmp, fpstatus);
6971                             tcg_temp_free_ptr(fpstatus);
6972                             break;
6973                         }
6974                         case NEON_2RM_VCVT_FS: /* VCVT.F32.S32 */
6975                         {
6976                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6977                             gen_helper_vfp_sitos(tmp, tmp, fpstatus);
6978                             tcg_temp_free_ptr(fpstatus);
6979                             break;
6980                         }
6981                         case NEON_2RM_VCVT_FU: /* VCVT.F32.U32 */
6982                         {
6983                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6984                             gen_helper_vfp_uitos(tmp, tmp, fpstatus);
6985                             tcg_temp_free_ptr(fpstatus);
6986                             break;
6987                         }
6988                         case NEON_2RM_VCVT_SF: /* VCVT.S32.F32 */
6989                         {
6990                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6991                             gen_helper_vfp_tosizs(tmp, tmp, fpstatus);
6992                             tcg_temp_free_ptr(fpstatus);
6993                             break;
6994                         }
6995                         case NEON_2RM_VCVT_UF: /* VCVT.U32.F32 */
6996                         {
6997                             TCGv_ptr fpstatus = get_fpstatus_ptr(1);
6998                             gen_helper_vfp_touizs(tmp, tmp, fpstatus);
6999                             tcg_temp_free_ptr(fpstatus);
7000                             break;
7001                         }
7002                         default:
7003                             /* Reserved op values were caught by the
7004                              * neon_2rm_sizes[] check earlier.
7005                              */
7006                             abort();
7007                         }
7008                         neon_store_reg(rd, pass, tmp);
7009                     }
7010                     break;
7011                 }
7012             } else if ((insn & (1 << 10)) == 0) {
7013                 /* VTBL, VTBX.  */
7014                 int n = ((insn >> 8) & 3) + 1;
7015                 if ((rn + n) > 32) {
7016                     /* This is UNPREDICTABLE; we choose to UNDEF to avoid the
7017                      * helper function running off the end of the register file.
7018                      */
7019                     return 1;
7020                 }
7021                 n <<= 3;
7022                 if (insn & (1 << 6)) {
7023                     tmp = neon_load_reg(rd, 0);
7024                 } else {
7025                     tmp = tcg_temp_new_i32();
7026                     tcg_gen_movi_i32(tmp, 0);
7027                 }
7028                 tmp2 = neon_load_reg(rm, 0);
7029                 ptr1 = vfp_reg_ptr(true, rn);
7030                 tmp5 = tcg_const_i32(n);
7031                 gen_helper_neon_tbl(tmp2, tmp2, tmp, ptr1, tmp5);
7032                 tcg_temp_free_i32(tmp);
7033                 if (insn & (1 << 6)) {
7034                     tmp = neon_load_reg(rd, 1);
7035                 } else {
7036                     tmp = tcg_temp_new_i32();
7037                     tcg_gen_movi_i32(tmp, 0);
7038                 }
7039                 tmp3 = neon_load_reg(rm, 1);
7040                 gen_helper_neon_tbl(tmp3, tmp3, tmp, ptr1, tmp5);
7041                 tcg_temp_free_i32(tmp5);
7042                 tcg_temp_free_ptr(ptr1);
7043                 neon_store_reg(rd, 0, tmp2);
7044                 neon_store_reg(rd, 1, tmp3);
7045                 tcg_temp_free_i32(tmp);
7046             } else if ((insn & 0x380) == 0) {
7047                 /* VDUP */
7048                 int element;
7049                 MemOp size;
7050
7051                 if ((insn & (7 << 16)) == 0 || (q && (rd & 1))) {
7052                     return 1;
7053                 }
7054                 if (insn & (1 << 16)) {
7055                     size = MO_8;
7056                     element = (insn >> 17) & 7;
7057                 } else if (insn & (1 << 17)) {
7058                     size = MO_16;
7059                     element = (insn >> 18) & 3;
7060                 } else {
7061                     size = MO_32;
7062                     element = (insn >> 19) & 1;
7063                 }
7064                 tcg_gen_gvec_dup_mem(size, neon_reg_offset(rd, 0),
7065                                      neon_element_offset(rm, element, size),
7066                                      q ? 16 : 8, q ? 16 : 8);
7067             } else {
7068                 return 1;
7069             }
7070         }
7071     }
7072     return 0;
7073 }
7074
7075 static int disas_coproc_insn(DisasContext *s, uint32_t insn)
7076 {
7077     int cpnum, is64, crn, crm, opc1, opc2, isread, rt, rt2;
7078     const ARMCPRegInfo *ri;
7079
7080     cpnum = (insn >> 8) & 0xf;
7081
7082     /* First check for coprocessor space used for XScale/iwMMXt insns */
7083     if (arm_dc_feature(s, ARM_FEATURE_XSCALE) && (cpnum < 2)) {
7084         if (extract32(s->c15_cpar, cpnum, 1) == 0) {
7085             return 1;
7086         }
7087         if (arm_dc_feature(s, ARM_FEATURE_IWMMXT)) {
7088             return disas_iwmmxt_insn(s, insn);
7089         } else if (arm_dc_feature(s, ARM_FEATURE_XSCALE)) {
7090             return disas_dsp_insn(s, insn);
7091         }
7092         return 1;
7093     }
7094
7095     /* Otherwise treat as a generic register access */
7096     is64 = (insn & (1 << 25)) == 0;
7097     if (!is64 && ((insn & (1 << 4)) == 0)) {
7098         /* cdp */
7099         return 1;
7100     }
7101
7102     crm = insn & 0xf;
7103     if (is64) {
7104         crn = 0;
7105         opc1 = (insn >> 4) & 0xf;
7106         opc2 = 0;
7107         rt2 = (insn >> 16) & 0xf;
7108     } else {
7109         crn = (insn >> 16) & 0xf;
7110         opc1 = (insn >> 21) & 7;
7111         opc2 = (insn >> 5) & 7;
7112         rt2 = 0;
7113     }
7114     isread = (insn >> 20) & 1;
7115     rt = (insn >> 12) & 0xf;
7116
7117     ri = get_arm_cp_reginfo(s->cp_regs,
7118             ENCODE_CP_REG(cpnum, is64, s->ns, crn, crm, opc1, opc2));
7119     if (ri) {
7120         bool need_exit_tb;
7121
7122         /* Check access permissions */
7123         if (!cp_access_ok(s->current_el, ri, isread)) {
7124             return 1;
7125         }
7126
7127         if (s->hstr_active || ri->accessfn ||
7128             (arm_dc_feature(s, ARM_FEATURE_XSCALE) && cpnum < 14)) {
7129             /* Emit code to perform further access permissions checks at
7130              * runtime; this may result in an exception.
7131              * Note that on XScale all cp0..c13 registers do an access check
7132              * call in order to handle c15_cpar.
7133              */
7134             TCGv_ptr tmpptr;
7135             TCGv_i32 tcg_syn, tcg_isread;
7136             uint32_t syndrome;
7137
7138             /* Note that since we are an implementation which takes an
7139              * exception on a trapped conditional instruction only if the
7140              * instruction passes its condition code check, we can take
7141              * advantage of the clause in the ARM ARM that allows us to set
7142              * the COND field in the instruction to 0xE in all cases.
7143              * We could fish the actual condition out of the insn (ARM)
7144              * or the condexec bits (Thumb) but it isn't necessary.
7145              */
7146             switch (cpnum) {
7147             case 14:
7148                 if (is64) {
7149                     syndrome = syn_cp14_rrt_trap(1, 0xe, opc1, crm, rt, rt2,
7150                                                  isread, false);
7151                 } else {
7152                     syndrome = syn_cp14_rt_trap(1, 0xe, opc1, opc2, crn, crm,
7153                                                 rt, isread, false);
7154                 }
7155                 break;
7156             case 15:
7157                 if (is64) {
7158                     syndrome = syn_cp15_rrt_trap(1, 0xe, opc1, crm, rt, rt2,
7159                                                  isread, false);
7160                 } else {
7161                     syndrome = syn_cp15_rt_trap(1, 0xe, opc1, opc2, crn, crm,
7162                                                 rt, isread, false);
7163                 }
7164                 break;
7165             default:
7166                 /* ARMv8 defines that only coprocessors 14 and 15 exist,
7167                  * so this can only happen if this is an ARMv7 or earlier CPU,
7168                  * in which case the syndrome information won't actually be
7169                  * guest visible.
7170                  */
7171                 assert(!arm_dc_feature(s, ARM_FEATURE_V8));
7172                 syndrome = syn_uncategorized();
7173                 break;
7174             }
7175
7176             gen_set_condexec(s);
7177             gen_set_pc_im(s, s->pc_curr);
7178             tmpptr = tcg_const_ptr(ri);
7179             tcg_syn = tcg_const_i32(syndrome);
7180             tcg_isread = tcg_const_i32(isread);
7181             gen_helper_access_check_cp_reg(cpu_env, tmpptr, tcg_syn,
7182                                            tcg_isread);
7183             tcg_temp_free_ptr(tmpptr);
7184             tcg_temp_free_i32(tcg_syn);
7185             tcg_temp_free_i32(tcg_isread);
7186         } else if (ri->type & ARM_CP_RAISES_EXC) {
7187             /*
7188              * The readfn or writefn might raise an exception;
7189              * synchronize the CPU state in case it does.
7190              */
7191             gen_set_condexec(s);
7192             gen_set_pc_im(s, s->pc_curr);
7193         }
7194
7195         /* Handle special cases first */
7196         switch (ri->type & ~(ARM_CP_FLAG_MASK & ~ARM_CP_SPECIAL)) {
7197         case ARM_CP_NOP:
7198             return 0;
7199         case ARM_CP_WFI:
7200             if (isread) {
7201                 return 1;
7202             }
7203             gen_set_pc_im(s, s->base.pc_next);
7204             s->base.is_jmp = DISAS_WFI;
7205             return 0;
7206         default:
7207             break;
7208         }
7209
7210         if ((tb_cflags(s->base.tb) & CF_USE_ICOUNT) && (ri->type & ARM_CP_IO)) {
7211             gen_io_start();
7212         }
7213
7214         if (isread) {
7215             /* Read */
7216             if (is64) {
7217                 TCGv_i64 tmp64;
7218                 TCGv_i32 tmp;
7219                 if (ri->type & ARM_CP_CONST) {
7220                     tmp64 = tcg_const_i64(ri->resetvalue);
7221                 } else if (ri->readfn) {
7222                     TCGv_ptr tmpptr;
7223                     tmp64 = tcg_temp_new_i64();
7224                     tmpptr = tcg_const_ptr(ri);
7225                     gen_helper_get_cp_reg64(tmp64, cpu_env, tmpptr);
7226                     tcg_temp_free_ptr(tmpptr);
7227                 } else {
7228                     tmp64 = tcg_temp_new_i64();
7229                     tcg_gen_ld_i64(tmp64, cpu_env, ri->fieldoffset);
7230                 }
7231                 tmp = tcg_temp_new_i32();
7232                 tcg_gen_extrl_i64_i32(tmp, tmp64);
7233                 store_reg(s, rt, tmp);
7234                 tmp = tcg_temp_new_i32();
7235                 tcg_gen_extrh_i64_i32(tmp, tmp64);
7236                 tcg_temp_free_i64(tmp64);
7237                 store_reg(s, rt2, tmp);
7238             } else {
7239                 TCGv_i32 tmp;
7240                 if (ri->type & ARM_CP_CONST) {
7241                     tmp = tcg_const_i32(ri->resetvalue);
7242                 } else if (ri->readfn) {
7243                     TCGv_ptr tmpptr;
7244                     tmp = tcg_temp_new_i32();
7245                     tmpptr = tcg_const_ptr(ri);
7246                     gen_helper_get_cp_reg(tmp, cpu_env, tmpptr);
7247                     tcg_temp_free_ptr(tmpptr);
7248                 } else {
7249                     tmp = load_cpu_offset(ri->fieldoffset);
7250                 }
7251                 if (rt == 15) {
7252                     /* Destination register of r15 for 32 bit loads sets
7253                      * the condition codes from the high 4 bits of the value
7254                      */
7255                     gen_set_nzcv(tmp);
7256                     tcg_temp_free_i32(tmp);
7257                 } else {
7258                     store_reg(s, rt, tmp);
7259                 }
7260             }
7261         } else {
7262             /* Write */
7263             if (ri->type & ARM_CP_CONST) {
7264                 /* If not forbidden by access permissions, treat as WI */
7265                 return 0;
7266             }
7267
7268             if (is64) {
7269                 TCGv_i32 tmplo, tmphi;
7270                 TCGv_i64 tmp64 = tcg_temp_new_i64();
7271                 tmplo = load_reg(s, rt);
7272                 tmphi = load_reg(s, rt2);
7273                 tcg_gen_concat_i32_i64(tmp64, tmplo, tmphi);
7274                 tcg_temp_free_i32(tmplo);
7275                 tcg_temp_free_i32(tmphi);
7276                 if (ri->writefn) {
7277                     TCGv_ptr tmpptr = tcg_const_ptr(ri);
7278                     gen_helper_set_cp_reg64(cpu_env, tmpptr, tmp64);
7279                     tcg_temp_free_ptr(tmpptr);
7280                 } else {
7281                     tcg_gen_st_i64(tmp64, cpu_env, ri->fieldoffset);
7282                 }
7283                 tcg_temp_free_i64(tmp64);
7284             } else {
7285                 if (ri->writefn) {
7286                     TCGv_i32 tmp;
7287                     TCGv_ptr tmpptr;
7288                     tmp = load_reg(s, rt);
7289                     tmpptr = tcg_const_ptr(ri);
7290                     gen_helper_set_cp_reg(cpu_env, tmpptr, tmp);
7291                     tcg_temp_free_ptr(tmpptr);
7292                     tcg_temp_free_i32(tmp);
7293                 } else {
7294                     TCGv_i32 tmp = load_reg(s, rt);
7295                     store_cpu_offset(tmp, ri->fieldoffset);
7296                 }
7297             }
7298         }
7299
7300         /* I/O operations must end the TB here (whether read or write) */
7301         need_exit_tb = ((tb_cflags(s->base.tb) & CF_USE_ICOUNT) &&
7302                         (ri->type & ARM_CP_IO));
7303
7304         if (!isread && !(ri->type & ARM_CP_SUPPRESS_TB_END)) {
7305             /*
7306              * A write to any coprocessor register that ends a TB
7307              * must rebuild the hflags for the next TB.
7308              */
7309             TCGv_i32 tcg_el = tcg_const_i32(s->current_el);
7310             if (arm_dc_feature(s, ARM_FEATURE_M)) {
7311                 gen_helper_rebuild_hflags_m32(cpu_env, tcg_el);
7312             } else {
7313                 if (ri->type & ARM_CP_NEWEL) {
7314                     gen_helper_rebuild_hflags_a32_newel(cpu_env);
7315                 } else {
7316                     gen_helper_rebuild_hflags_a32(cpu_env, tcg_el);
7317                 }
7318             }
7319             tcg_temp_free_i32(tcg_el);
7320             /*
7321              * We default to ending the TB on a coprocessor register write,
7322              * but allow this to be suppressed by the register definition
7323              * (usually only necessary to work around guest bugs).
7324              */
7325             need_exit_tb = true;
7326         }
7327         if (need_exit_tb) {
7328             gen_lookup_tb(s);
7329         }
7330
7331         return 0;
7332     }
7333
7334     /* Unknown register; this might be a guest error or a QEMU
7335      * unimplemented feature.
7336      */
7337     if (is64) {
7338         qemu_log_mask(LOG_UNIMP, "%s access to unsupported AArch32 "
7339                       "64 bit system register cp:%d opc1: %d crm:%d "
7340                       "(%s)\n",
7341                       isread ? "read" : "write", cpnum, opc1, crm,
7342                       s->ns ? "non-secure" : "secure");
7343     } else {
7344         qemu_log_mask(LOG_UNIMP, "%s access to unsupported AArch32 "
7345                       "system register cp:%d opc1:%d crn:%d crm:%d opc2:%d "
7346                       "(%s)\n",
7347                       isread ? "read" : "write", cpnum, opc1, crn, crm, opc2,
7348                       s->ns ? "non-secure" : "secure");
7349     }
7350
7351     return 1;
7352 }
7353
7354
7355 /* Store a 64-bit value to a register pair.  Clobbers val.  */
7356 static void gen_storeq_reg(DisasContext *s, int rlow, int rhigh, TCGv_i64 val)
7357 {
7358     TCGv_i32 tmp;
7359     tmp = tcg_temp_new_i32();
7360     tcg_gen_extrl_i64_i32(tmp, val);
7361     store_reg(s, rlow, tmp);
7362     tmp = tcg_temp_new_i32();
7363     tcg_gen_extrh_i64_i32(tmp, val);
7364     store_reg(s, rhigh, tmp);
7365 }
7366
7367 /* load and add a 64-bit value from a register pair.  */
7368 static void gen_addq(DisasContext *s, TCGv_i64 val, int rlow, int rhigh)
7369 {
7370     TCGv_i64 tmp;
7371     TCGv_i32 tmpl;
7372     TCGv_i32 tmph;
7373
7374     /* Load 64-bit value rd:rn.  */
7375     tmpl = load_reg(s, rlow);
7376     tmph = load_reg(s, rhigh);
7377     tmp = tcg_temp_new_i64();
7378     tcg_gen_concat_i32_i64(tmp, tmpl, tmph);
7379     tcg_temp_free_i32(tmpl);
7380     tcg_temp_free_i32(tmph);
7381     tcg_gen_add_i64(val, val, tmp);
7382     tcg_temp_free_i64(tmp);
7383 }
7384
7385 /* Set N and Z flags from hi|lo.  */
7386 static void gen_logicq_cc(TCGv_i32 lo, TCGv_i32 hi)
7387 {
7388     tcg_gen_mov_i32(cpu_NF, hi);
7389     tcg_gen_or_i32(cpu_ZF, lo, hi);
7390 }
7391
7392 /* Load/Store exclusive instructions are implemented by remembering
7393    the value/address loaded, and seeing if these are the same
7394    when the store is performed.  This should be sufficient to implement
7395    the architecturally mandated semantics, and avoids having to monitor
7396    regular stores.  The compare vs the remembered value is done during
7397    the cmpxchg operation, but we must compare the addresses manually.  */
7398 static void gen_load_exclusive(DisasContext *s, int rt, int rt2,
7399                                TCGv_i32 addr, int size)
7400 {
7401     TCGv_i32 tmp = tcg_temp_new_i32();
7402     MemOp opc = size | MO_ALIGN | s->be_data;
7403
7404     s->is_ldex = true;
7405
7406     if (size == 3) {
7407         TCGv_i32 tmp2 = tcg_temp_new_i32();
7408         TCGv_i64 t64 = tcg_temp_new_i64();
7409
7410         /* For AArch32, architecturally the 32-bit word at the lowest
7411          * address is always Rt and the one at addr+4 is Rt2, even if
7412          * the CPU is big-endian. That means we don't want to do a
7413          * gen_aa32_ld_i64(), which invokes gen_aa32_frob64() as if
7414          * for an architecturally 64-bit access, but instead do a
7415          * 64-bit access using MO_BE if appropriate and then split
7416          * the two halves.
7417          * This only makes a difference for BE32 user-mode, where
7418          * frob64() must not flip the two halves of the 64-bit data
7419          * but this code must treat BE32 user-mode like BE32 system.
7420          */
7421         TCGv taddr = gen_aa32_addr(s, addr, opc);
7422
7423         tcg_gen_qemu_ld_i64(t64, taddr, get_mem_index(s), opc);
7424         tcg_temp_free(taddr);
7425         tcg_gen_mov_i64(cpu_exclusive_val, t64);
7426         if (s->be_data == MO_BE) {
7427             tcg_gen_extr_i64_i32(tmp2, tmp, t64);
7428         } else {
7429             tcg_gen_extr_i64_i32(tmp, tmp2, t64);
7430         }
7431         tcg_temp_free_i64(t64);
7432
7433         store_reg(s, rt2, tmp2);
7434     } else {
7435         gen_aa32_ld_i32(s, tmp, addr, get_mem_index(s), opc);
7436         tcg_gen_extu_i32_i64(cpu_exclusive_val, tmp);
7437     }
7438
7439     store_reg(s, rt, tmp);
7440     tcg_gen_extu_i32_i64(cpu_exclusive_addr, addr);
7441 }
7442
7443 static void gen_clrex(DisasContext *s)
7444 {
7445     tcg_gen_movi_i64(cpu_exclusive_addr, -1);
7446 }
7447
7448 static void gen_store_exclusive(DisasContext *s, int rd, int rt, int rt2,
7449                                 TCGv_i32 addr, int size)
7450 {
7451     TCGv_i32 t0, t1, t2;
7452     TCGv_i64 extaddr;
7453     TCGv taddr;
7454     TCGLabel *done_label;
7455     TCGLabel *fail_label;
7456     MemOp opc = size | MO_ALIGN | s->be_data;
7457
7458     /* if (env->exclusive_addr == addr && env->exclusive_val == [addr]) {
7459          [addr] = {Rt};
7460          {Rd} = 0;
7461        } else {
7462          {Rd} = 1;
7463        } */
7464     fail_label = gen_new_label();
7465     done_label = gen_new_label();
7466     extaddr = tcg_temp_new_i64();
7467     tcg_gen_extu_i32_i64(extaddr, addr);
7468     tcg_gen_brcond_i64(TCG_COND_NE, extaddr, cpu_exclusive_addr, fail_label);
7469     tcg_temp_free_i64(extaddr);
7470
7471     taddr = gen_aa32_addr(s, addr, opc);
7472     t0 = tcg_temp_new_i32();
7473     t1 = load_reg(s, rt);
7474     if (size == 3) {
7475         TCGv_i64 o64 = tcg_temp_new_i64();
7476         TCGv_i64 n64 = tcg_temp_new_i64();
7477
7478         t2 = load_reg(s, rt2);
7479         /* For AArch32, architecturally the 32-bit word at the lowest
7480          * address is always Rt and the one at addr+4 is Rt2, even if
7481          * the CPU is big-endian. Since we're going to treat this as a
7482          * single 64-bit BE store, we need to put the two halves in the
7483          * opposite order for BE to LE, so that they end up in the right
7484          * places.
7485          * We don't want gen_aa32_frob64() because that does the wrong
7486          * thing for BE32 usermode.
7487          */
7488         if (s->be_data == MO_BE) {
7489             tcg_gen_concat_i32_i64(n64, t2, t1);
7490         } else {
7491             tcg_gen_concat_i32_i64(n64, t1, t2);
7492         }
7493         tcg_temp_free_i32(t2);
7494
7495         tcg_gen_atomic_cmpxchg_i64(o64, taddr, cpu_exclusive_val, n64,
7496                                    get_mem_index(s), opc);
7497         tcg_temp_free_i64(n64);
7498
7499         tcg_gen_setcond_i64(TCG_COND_NE, o64, o64, cpu_exclusive_val);
7500         tcg_gen_extrl_i64_i32(t0, o64);
7501
7502         tcg_temp_free_i64(o64);
7503     } else {
7504         t2 = tcg_temp_new_i32();
7505         tcg_gen_extrl_i64_i32(t2, cpu_exclusive_val);
7506         tcg_gen_atomic_cmpxchg_i32(t0, taddr, t2, t1, get_mem_index(s), opc);
7507         tcg_gen_setcond_i32(TCG_COND_NE, t0, t0, t2);
7508         tcg_temp_free_i32(t2);
7509     }
7510     tcg_temp_free_i32(t1);
7511     tcg_temp_free(taddr);
7512     tcg_gen_mov_i32(cpu_R[rd], t0);
7513     tcg_temp_free_i32(t0);
7514     tcg_gen_br(done_label);
7515
7516     gen_set_label(fail_label);
7517     tcg_gen_movi_i32(cpu_R[rd], 1);
7518     gen_set_label(done_label);
7519     tcg_gen_movi_i64(cpu_exclusive_addr, -1);
7520 }
7521
7522 /* gen_srs:
7523  * @env: CPUARMState
7524  * @s: DisasContext
7525  * @mode: mode field from insn (which stack to store to)
7526  * @amode: addressing mode (DA/IA/DB/IB), encoded as per P,U bits in ARM insn
7527  * @writeback: true if writeback bit set
7528  *
7529  * Generate code for the SRS (Store Return State) insn.
7530  */
7531 static void gen_srs(DisasContext *s,
7532                     uint32_t mode, uint32_t amode, bool writeback)
7533 {
7534     int32_t offset;
7535     TCGv_i32 addr, tmp;
7536     bool undef = false;
7537
7538     /* SRS is:
7539      * - trapped to EL3 if EL3 is AArch64 and we are at Secure EL1
7540      *   and specified mode is monitor mode
7541      * - UNDEFINED in Hyp mode
7542      * - UNPREDICTABLE in User or System mode
7543      * - UNPREDICTABLE if the specified mode is:
7544      * -- not implemented
7545      * -- not a valid mode number
7546      * -- a mode that's at a higher exception level
7547      * -- Monitor, if we are Non-secure
7548      * For the UNPREDICTABLE cases we choose to UNDEF.
7549      */
7550     if (s->current_el == 1 && !s->ns && mode == ARM_CPU_MODE_MON) {
7551         gen_exception_insn(s, s->pc_curr, EXCP_UDEF, syn_uncategorized(), 3);
7552         return;
7553     }
7554
7555     if (s->current_el == 0 || s->current_el == 2) {
7556         undef = true;
7557     }
7558
7559     switch (mode) {
7560     case ARM_CPU_MODE_USR:
7561     case ARM_CPU_MODE_FIQ:
7562     case ARM_CPU_MODE_IRQ:
7563     case ARM_CPU_MODE_SVC:
7564     case ARM_CPU_MODE_ABT:
7565     case ARM_CPU_MODE_UND:
7566     case ARM_CPU_MODE_SYS:
7567         break;
7568     case ARM_CPU_MODE_HYP:
7569         if (s->current_el == 1 || !arm_dc_feature(s, ARM_FEATURE_EL2)) {
7570             undef = true;
7571         }
7572         break;
7573     case ARM_CPU_MODE_MON:
7574         /* No need to check specifically for "are we non-secure" because
7575          * we've already made EL0 UNDEF and handled the trap for S-EL1;
7576          * so if this isn't EL3 then we must be non-secure.
7577          */
7578         if (s->current_el != 3) {
7579             undef = true;
7580         }
7581         break;
7582     default:
7583         undef = true;
7584     }
7585
7586     if (undef) {
7587         unallocated_encoding(s);
7588         return;
7589     }
7590
7591     addr = tcg_temp_new_i32();
7592     tmp = tcg_const_i32(mode);
7593     /* get_r13_banked() will raise an exception if called from System mode */
7594     gen_set_condexec(s);
7595     gen_set_pc_im(s, s->pc_curr);
7596     gen_helper_get_r13_banked(addr, cpu_env, tmp);
7597     tcg_temp_free_i32(tmp);
7598     switch (amode) {
7599     case 0: /* DA */
7600         offset = -4;
7601         break;
7602     case 1: /* IA */
7603         offset = 0;
7604         break;
7605     case 2: /* DB */
7606         offset = -8;
7607         break;
7608     case 3: /* IB */
7609         offset = 4;
7610         break;
7611     default:
7612         abort();
7613     }
7614     tcg_gen_addi_i32(addr, addr, offset);
7615     tmp = load_reg(s, 14);
7616     gen_aa32_st32(s, tmp, addr, get_mem_index(s));
7617     tcg_temp_free_i32(tmp);
7618     tmp = load_cpu_field(spsr);
7619     tcg_gen_addi_i32(addr, addr, 4);
7620     gen_aa32_st32(s, tmp, addr, get_mem_index(s));
7621     tcg_temp_free_i32(tmp);
7622     if (writeback) {
7623         switch (amode) {
7624         case 0:
7625             offset = -8;
7626             break;
7627         case 1:
7628             offset = 4;
7629             break;
7630         case 2:
7631             offset = -4;
7632             break;
7633         case 3:
7634             offset = 0;
7635             break;
7636         default:
7637             abort();
7638         }
7639         tcg_gen_addi_i32(addr, addr, offset);
7640         tmp = tcg_const_i32(mode);
7641         gen_helper_set_r13_banked(cpu_env, tmp, addr);
7642         tcg_temp_free_i32(tmp);
7643     }
7644     tcg_temp_free_i32(addr);
7645     s->base.is_jmp = DISAS_UPDATE;
7646 }
7647
7648 /* Generate a label used for skipping this instruction */
7649 static void arm_gen_condlabel(DisasContext *s)
7650 {
7651     if (!s->condjmp) {
7652         s->condlabel = gen_new_label();
7653         s->condjmp = 1;
7654     }
7655 }
7656
7657 /* Skip this instruction if the ARM condition is false */
7658 static void arm_skip_unless(DisasContext *s, uint32_t cond)
7659 {
7660     arm_gen_condlabel(s);
7661     arm_gen_test_cc(cond ^ 1, s->condlabel);
7662 }
7663
7664
7665 /*
7666  * Constant expanders for the decoders.
7667  */
7668
7669 static int negate(DisasContext *s, int x)
7670 {
7671     return -x;
7672 }
7673
7674 static int plus_2(DisasContext *s, int x)
7675 {
7676     return x + 2;
7677 }
7678
7679 static int times_2(DisasContext *s, int x)
7680 {
7681     return x * 2;
7682 }
7683
7684 static int times_4(DisasContext *s, int x)
7685 {
7686     return x * 4;
7687 }
7688
7689 /* Return only the rotation part of T32ExpandImm.  */
7690 static int t32_expandimm_rot(DisasContext *s, int x)
7691 {
7692     return x & 0xc00 ? extract32(x, 7, 5) : 0;
7693 }
7694
7695 /* Return the unrotated immediate from T32ExpandImm.  */
7696 static int t32_expandimm_imm(DisasContext *s, int x)
7697 {
7698     int imm = extract32(x, 0, 8);
7699
7700     switch (extract32(x, 8, 4)) {
7701     case 0: /* XY */
7702         /* Nothing to do.  */
7703         break;
7704     case 1: /* 00XY00XY */
7705         imm *= 0x00010001;
7706         break;
7707     case 2: /* XY00XY00 */
7708         imm *= 0x01000100;
7709         break;
7710     case 3: /* XYXYXYXY */
7711         imm *= 0x01010101;
7712         break;
7713     default:
7714         /* Rotated constant.  */
7715         imm |= 0x80;
7716         break;
7717     }
7718     return imm;
7719 }
7720
7721 static int t32_branch24(DisasContext *s, int x)
7722 {
7723     /* Convert J1:J2 at x[22:21] to I2:I1, which involves I=J^~S.  */
7724     x ^= !(x < 0) * (3 << 21);
7725     /* Append the final zero.  */
7726     return x << 1;
7727 }
7728
7729 static int t16_setflags(DisasContext *s)
7730 {
7731     return s->condexec_mask == 0;
7732 }
7733
7734 static int t16_push_list(DisasContext *s, int x)
7735 {
7736     return (x & 0xff) | (x & 0x100) << (14 - 8);
7737 }
7738
7739 static int t16_pop_list(DisasContext *s, int x)
7740 {
7741     return (x & 0xff) | (x & 0x100) << (15 - 8);
7742 }
7743
7744 /*
7745  * Include the generated decoders.
7746  */
7747
7748 #include "decode-a32.inc.c"
7749 #include "decode-a32-uncond.inc.c"
7750 #include "decode-t32.inc.c"
7751 #include "decode-t16.inc.c"
7752
7753 /* Helpers to swap operands for reverse-subtract.  */
7754 static void gen_rsb(TCGv_i32 dst, TCGv_i32 a, TCGv_i32 b)
7755 {
7756     tcg_gen_sub_i32(dst, b, a);
7757 }
7758
7759 static void gen_rsb_CC(TCGv_i32 dst, TCGv_i32 a, TCGv_i32 b)
7760 {
7761     gen_sub_CC(dst, b, a);
7762 }
7763
7764 static void gen_rsc(TCGv_i32 dest, TCGv_i32 a, TCGv_i32 b)
7765 {
7766     gen_sub_carry(dest, b, a);
7767 }
7768
7769 static void gen_rsc_CC(TCGv_i32 dest, TCGv_i32 a, TCGv_i32 b)
7770 {
7771     gen_sbc_CC(dest, b, a);
7772 }
7773
7774 /*
7775  * Helpers for the data processing routines.
7776  *
7777  * After the computation store the results back.
7778  * This may be suppressed altogether (STREG_NONE), require a runtime
7779  * check against the stack limits (STREG_SP_CHECK), or generate an
7780  * exception return.  Oh, or store into a register.
7781  *
7782  * Always return true, indicating success for a trans_* function.
7783  */
7784 typedef enum {
7785    STREG_NONE,
7786    STREG_NORMAL,
7787    STREG_SP_CHECK,
7788    STREG_EXC_RET,
7789 } StoreRegKind;
7790
7791 static bool store_reg_kind(DisasContext *s, int rd,
7792                             TCGv_i32 val, StoreRegKind kind)
7793 {
7794     switch (kind) {
7795     case STREG_NONE:
7796         tcg_temp_free_i32(val);
7797         return true;
7798     case STREG_NORMAL:
7799         /* See ALUWritePC: Interworking only from a32 mode. */
7800         if (s->thumb) {
7801             store_reg(s, rd, val);
7802         } else {
7803             store_reg_bx(s, rd, val);
7804         }
7805         return true;
7806     case STREG_SP_CHECK:
7807         store_sp_checked(s, val);
7808         return true;
7809     case STREG_EXC_RET:
7810         gen_exception_return(s, val);
7811         return true;
7812     }
7813     g_assert_not_reached();
7814 }
7815
7816 /*
7817  * Data Processing (register)
7818  *
7819  * Operate, with set flags, one register source,
7820  * one immediate shifted register source, and a destination.
7821  */
7822 static bool op_s_rrr_shi(DisasContext *s, arg_s_rrr_shi *a,
7823                          void (*gen)(TCGv_i32, TCGv_i32, TCGv_i32),
7824                          int logic_cc, StoreRegKind kind)
7825 {
7826     TCGv_i32 tmp1, tmp2;
7827
7828     tmp2 = load_reg(s, a->rm);
7829     gen_arm_shift_im(tmp2, a->shty, a->shim, logic_cc);
7830     tmp1 = load_reg(s, a->rn);
7831
7832     gen(tmp1, tmp1, tmp2);
7833     tcg_temp_free_i32(tmp2);
7834
7835     if (logic_cc) {
7836         gen_logic_CC(tmp1);
7837     }
7838     return store_reg_kind(s, a->rd, tmp1, kind);
7839 }
7840
7841 static bool op_s_rxr_shi(DisasContext *s, arg_s_rrr_shi *a,
7842                          void (*gen)(TCGv_i32, TCGv_i32),
7843                          int logic_cc, StoreRegKind kind)
7844 {
7845     TCGv_i32 tmp;
7846
7847     tmp = load_reg(s, a->rm);
7848     gen_arm_shift_im(tmp, a->shty, a->shim, logic_cc);
7849
7850     gen(tmp, tmp);
7851     if (logic_cc) {
7852         gen_logic_CC(tmp);
7853     }
7854     return store_reg_kind(s, a->rd, tmp, kind);
7855 }
7856
7857 /*
7858  * Data-processing (register-shifted register)
7859  *
7860  * Operate, with set flags, one register source,
7861  * one register shifted register source, and a destination.
7862  */
7863 static bool op_s_rrr_shr(DisasContext *s, arg_s_rrr_shr *a,
7864                          void (*gen)(TCGv_i32, TCGv_i32, TCGv_i32),
7865                          int logic_cc, StoreRegKind kind)
7866 {
7867     TCGv_i32 tmp1, tmp2;
7868
7869     tmp1 = load_reg(s, a->rs);
7870     tmp2 = load_reg(s, a->rm);
7871     gen_arm_shift_reg(tmp2, a->shty, tmp1, logic_cc);
7872     tmp1 = load_reg(s, a->rn);
7873
7874     gen(tmp1, tmp1, tmp2);
7875     tcg_temp_free_i32(tmp2);
7876
7877     if (logic_cc) {
7878         gen_logic_CC(tmp1);
7879     }
7880     return store_reg_kind(s, a->rd, tmp1, kind);
7881 }
7882
7883 static bool op_s_rxr_shr(DisasContext *s, arg_s_rrr_shr *a,
7884                          void (*gen)(TCGv_i32, TCGv_i32),
7885                          int logic_cc, StoreRegKind kind)
7886 {
7887     TCGv_i32 tmp1, tmp2;
7888
7889     tmp1 = load_reg(s, a->rs);
7890     tmp2 = load_reg(s, a->rm);
7891     gen_arm_shift_reg(tmp2, a->shty, tmp1, logic_cc);
7892
7893     gen(tmp2, tmp2);
7894     if (logic_cc) {
7895         gen_logic_CC(tmp2);
7896     }
7897     return store_reg_kind(s, a->rd, tmp2, kind);
7898 }
7899
7900 /*
7901  * Data-processing (immediate)
7902  *
7903  * Operate, with set flags, one register source,
7904  * one rotated immediate, and a destination.
7905  *
7906  * Note that logic_cc && a->rot setting CF based on the msb of the
7907  * immediate is the reason why we must pass in the unrotated form
7908  * of the immediate.
7909  */
7910 static bool op_s_rri_rot(DisasContext *s, arg_s_rri_rot *a,
7911                          void (*gen)(TCGv_i32, TCGv_i32, TCGv_i32),
7912                          int logic_cc, StoreRegKind kind)
7913 {
7914     TCGv_i32 tmp1, tmp2;
7915     uint32_t imm;
7916
7917     imm = ror32(a->imm, a->rot);
7918     if (logic_cc && a->rot) {
7919         tcg_gen_movi_i32(cpu_CF, imm >> 31);
7920     }
7921     tmp2 = tcg_const_i32(imm);
7922     tmp1 = load_reg(s, a->rn);
7923
7924     gen(tmp1, tmp1, tmp2);
7925     tcg_temp_free_i32(tmp2);
7926
7927     if (logic_cc) {
7928         gen_logic_CC(tmp1);
7929     }
7930     return store_reg_kind(s, a->rd, tmp1, kind);
7931 }
7932
7933 static bool op_s_rxi_rot(DisasContext *s, arg_s_rri_rot *a,
7934                          void (*gen)(TCGv_i32, TCGv_i32),
7935                          int logic_cc, StoreRegKind kind)
7936 {
7937     TCGv_i32 tmp;
7938     uint32_t imm;
7939
7940     imm = ror32(a->imm, a->rot);
7941     if (logic_cc && a->rot) {
7942         tcg_gen_movi_i32(cpu_CF, imm >> 31);
7943     }
7944     tmp = tcg_const_i32(imm);
7945
7946     gen(tmp, tmp);
7947     if (logic_cc) {
7948         gen_logic_CC(tmp);
7949     }
7950     return store_reg_kind(s, a->rd, tmp, kind);
7951 }
7952
7953 #define DO_ANY3(NAME, OP, L, K)                                         \
7954     static bool trans_##NAME##_rrri(DisasContext *s, arg_s_rrr_shi *a)  \
7955     { StoreRegKind k = (K); return op_s_rrr_shi(s, a, OP, L, k); }      \
7956     static bool trans_##NAME##_rrrr(DisasContext *s, arg_s_rrr_shr *a)  \
7957     { StoreRegKind k = (K); return op_s_rrr_shr(s, a, OP, L, k); }      \
7958     static bool trans_##NAME##_rri(DisasContext *s, arg_s_rri_rot *a)   \
7959     { StoreRegKind k = (K); return op_s_rri_rot(s, a, OP, L, k); }
7960
7961 #define DO_ANY2(NAME, OP, L, K)                                         \
7962     static bool trans_##NAME##_rxri(DisasContext *s, arg_s_rrr_shi *a)  \
7963     { StoreRegKind k = (K); return op_s_rxr_shi(s, a, OP, L, k); }      \
7964     static bool trans_##NAME##_rxrr(DisasContext *s, arg_s_rrr_shr *a)  \
7965     { StoreRegKind k = (K); return op_s_rxr_shr(s, a, OP, L, k); }      \
7966     static bool trans_##NAME##_rxi(DisasContext *s, arg_s_rri_rot *a)   \
7967     { StoreRegKind k = (K); return op_s_rxi_rot(s, a, OP, L, k); }
7968
7969 #define DO_CMP2(NAME, OP, L)                                            \
7970     static bool trans_##NAME##_xrri(DisasContext *s, arg_s_rrr_shi *a)  \
7971     { return op_s_rrr_shi(s, a, OP, L, STREG_NONE); }                   \
7972     static bool trans_##NAME##_xrrr(DisasContext *s, arg_s_rrr_shr *a)  \
7973     { return op_s_rrr_shr(s, a, OP, L, STREG_NONE); }                   \
7974     static bool trans_##NAME##_xri(DisasContext *s, arg_s_rri_rot *a)   \
7975     { return op_s_rri_rot(s, a, OP, L, STREG_NONE); }
7976
7977 DO_ANY3(AND, tcg_gen_and_i32, a->s, STREG_NORMAL)
7978 DO_ANY3(EOR, tcg_gen_xor_i32, a->s, STREG_NORMAL)
7979 DO_ANY3(ORR, tcg_gen_or_i32, a->s, STREG_NORMAL)
7980 DO_ANY3(BIC, tcg_gen_andc_i32, a->s, STREG_NORMAL)
7981
7982 DO_ANY3(RSB, a->s ? gen_rsb_CC : gen_rsb, false, STREG_NORMAL)
7983 DO_ANY3(ADC, a->s ? gen_adc_CC : gen_add_carry, false, STREG_NORMAL)
7984 DO_ANY3(SBC, a->s ? gen_sbc_CC : gen_sub_carry, false, STREG_NORMAL)
7985 DO_ANY3(RSC, a->s ? gen_rsc_CC : gen_rsc, false, STREG_NORMAL)
7986
7987 DO_CMP2(TST, tcg_gen_and_i32, true)
7988 DO_CMP2(TEQ, tcg_gen_xor_i32, true)
7989 DO_CMP2(CMN, gen_add_CC, false)
7990 DO_CMP2(CMP, gen_sub_CC, false)
7991
7992 DO_ANY3(ADD, a->s ? gen_add_CC : tcg_gen_add_i32, false,
7993         a->rd == 13 && a->rn == 13 ? STREG_SP_CHECK : STREG_NORMAL)
7994
7995 /*
7996  * Note for the computation of StoreRegKind we return out of the
7997  * middle of the functions that are expanded by DO_ANY3, and that
7998  * we modify a->s via that parameter before it is used by OP.
7999  */
8000 DO_ANY3(SUB, a->s ? gen_sub_CC : tcg_gen_sub_i32, false,
8001         ({
8002             StoreRegKind ret = STREG_NORMAL;
8003             if (a->rd == 15 && a->s) {
8004                 /*
8005                  * See ALUExceptionReturn:
8006                  * In User mode, UNPREDICTABLE; we choose UNDEF.
8007                  * In Hyp mode, UNDEFINED.
8008                  */
8009                 if (IS_USER(s) || s->current_el == 2) {
8010                     unallocated_encoding(s);
8011                     return true;
8012                 }
8013                 /* There is no writeback of nzcv to PSTATE.  */
8014                 a->s = 0;
8015                 ret = STREG_EXC_RET;
8016             } else if (a->rd == 13 && a->rn == 13) {
8017                 ret = STREG_SP_CHECK;
8018             }
8019             ret;
8020         }))
8021
8022 DO_ANY2(MOV, tcg_gen_mov_i32, a->s,
8023         ({
8024             StoreRegKind ret = STREG_NORMAL;
8025             if (a->rd == 15 && a->s) {
8026                 /*
8027                  * See ALUExceptionReturn:
8028                  * In User mode, UNPREDICTABLE; we choose UNDEF.
8029                  * In Hyp mode, UNDEFINED.
8030                  */
8031                 if (IS_USER(s) || s->current_el == 2) {
8032                     unallocated_encoding(s);
8033                     return true;
8034                 }
8035                 /* There is no writeback of nzcv to PSTATE.  */
8036                 a->s = 0;
8037                 ret = STREG_EXC_RET;
8038             } else if (a->rd == 13) {
8039                 ret = STREG_SP_CHECK;
8040             }
8041             ret;
8042         }))
8043
8044 DO_ANY2(MVN, tcg_gen_not_i32, a->s, STREG_NORMAL)
8045
8046 /*
8047  * ORN is only available with T32, so there is no register-shifted-register
8048  * form of the insn.  Using the DO_ANY3 macro would create an unused function.
8049  */
8050 static bool trans_ORN_rrri(DisasContext *s, arg_s_rrr_shi *a)
8051 {
8052     return op_s_rrr_shi(s, a, tcg_gen_orc_i32, a->s, STREG_NORMAL);
8053 }
8054
8055 static bool trans_ORN_rri(DisasContext *s, arg_s_rri_rot *a)
8056 {
8057     return op_s_rri_rot(s, a, tcg_gen_orc_i32, a->s, STREG_NORMAL);
8058 }
8059
8060 #undef DO_ANY3
8061 #undef DO_ANY2
8062 #undef DO_CMP2
8063
8064 static bool trans_ADR(DisasContext *s, arg_ri *a)
8065 {
8066     store_reg_bx(s, a->rd, add_reg_for_lit(s, 15, a->imm));
8067     return true;
8068 }
8069
8070 static bool trans_MOVW(DisasContext *s, arg_MOVW *a)
8071 {
8072     TCGv_i32 tmp;
8073
8074     if (!ENABLE_ARCH_6T2) {
8075         return false;
8076     }
8077
8078     tmp = tcg_const_i32(a->imm);
8079     store_reg(s, a->rd, tmp);
8080     return true;
8081 }
8082
8083 static bool trans_MOVT(DisasContext *s, arg_MOVW *a)
8084 {
8085     TCGv_i32 tmp;
8086
8087     if (!ENABLE_ARCH_6T2) {
8088         return false;
8089     }
8090
8091     tmp = load_reg(s, a->rd);
8092     tcg_gen_ext16u_i32(tmp, tmp);
8093     tcg_gen_ori_i32(tmp, tmp, a->imm << 16);
8094     store_reg(s, a->rd, tmp);
8095     return true;
8096 }
8097
8098 /*
8099  * Multiply and multiply accumulate
8100  */
8101
8102 static bool op_mla(DisasContext *s, arg_s_rrrr *a, bool add)
8103 {
8104     TCGv_i32 t1, t2;
8105
8106     t1 = load_reg(s, a->rn);
8107     t2 = load_reg(s, a->rm);
8108     tcg_gen_mul_i32(t1, t1, t2);
8109     tcg_temp_free_i32(t2);
8110     if (add) {
8111         t2 = load_reg(s, a->ra);
8112         tcg_gen_add_i32(t1, t1, t2);
8113         tcg_temp_free_i32(t2);
8114     }
8115     if (a->s) {
8116         gen_logic_CC(t1);
8117     }
8118     store_reg(s, a->rd, t1);
8119     return true;
8120 }
8121
8122 static bool trans_MUL(DisasContext *s, arg_MUL *a)
8123 {
8124     return op_mla(s, a, false);
8125 }
8126
8127 static bool trans_MLA(DisasContext *s, arg_MLA *a)
8128 {
8129     return op_mla(s, a, true);
8130 }
8131
8132 static bool trans_MLS(DisasContext *s, arg_MLS *a)
8133 {
8134     TCGv_i32 t1, t2;
8135
8136     if (!ENABLE_ARCH_6T2) {
8137         return false;
8138     }
8139     t1 = load_reg(s, a->rn);
8140     t2 = load_reg(s, a->rm);
8141     tcg_gen_mul_i32(t1, t1, t2);
8142     tcg_temp_free_i32(t2);
8143     t2 = load_reg(s, a->ra);
8144     tcg_gen_sub_i32(t1, t2, t1);
8145     tcg_temp_free_i32(t2);
8146     store_reg(s, a->rd, t1);
8147     return true;
8148 }
8149
8150 static bool op_mlal(DisasContext *s, arg_s_rrrr *a, bool uns, bool add)
8151 {
8152     TCGv_i32 t0, t1, t2, t3;
8153
8154     t0 = load_reg(s, a->rm);
8155     t1 = load_reg(s, a->rn);
8156     if (uns) {
8157         tcg_gen_mulu2_i32(t0, t1, t0, t1);
8158     } else {
8159         tcg_gen_muls2_i32(t0, t1, t0, t1);
8160     }
8161     if (add) {
8162         t2 = load_reg(s, a->ra);
8163         t3 = load_reg(s, a->rd);
8164         tcg_gen_add2_i32(t0, t1, t0, t1, t2, t3);
8165         tcg_temp_free_i32(t2);
8166         tcg_temp_free_i32(t3);
8167     }
8168     if (a->s) {
8169         gen_logicq_cc(t0, t1);
8170     }
8171     store_reg(s, a->ra, t0);
8172     store_reg(s, a->rd, t1);
8173     return true;
8174 }
8175
8176 static bool trans_UMULL(DisasContext *s, arg_UMULL *a)
8177 {
8178     return op_mlal(s, a, true, false);
8179 }
8180
8181 static bool trans_SMULL(DisasContext *s, arg_SMULL *a)
8182 {
8183     return op_mlal(s, a, false, false);
8184 }
8185
8186 static bool trans_UMLAL(DisasContext *s, arg_UMLAL *a)
8187 {
8188     return op_mlal(s, a, true, true);
8189 }
8190
8191 static bool trans_SMLAL(DisasContext *s, arg_SMLAL *a)
8192 {
8193     return op_mlal(s, a, false, true);
8194 }
8195
8196 static bool trans_UMAAL(DisasContext *s, arg_UMAAL *a)
8197 {
8198     TCGv_i32 t0, t1, t2, zero;
8199
8200     if (s->thumb
8201         ? !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)
8202         : !ENABLE_ARCH_6) {
8203         return false;
8204     }
8205
8206     t0 = load_reg(s, a->rm);
8207     t1 = load_reg(s, a->rn);
8208     tcg_gen_mulu2_i32(t0, t1, t0, t1);
8209     zero = tcg_const_i32(0);
8210     t2 = load_reg(s, a->ra);
8211     tcg_gen_add2_i32(t0, t1, t0, t1, t2, zero);
8212     tcg_temp_free_i32(t2);
8213     t2 = load_reg(s, a->rd);
8214     tcg_gen_add2_i32(t0, t1, t0, t1, t2, zero);
8215     tcg_temp_free_i32(t2);
8216     tcg_temp_free_i32(zero);
8217     store_reg(s, a->ra, t0);
8218     store_reg(s, a->rd, t1);
8219     return true;
8220 }
8221
8222 /*
8223  * Saturating addition and subtraction
8224  */
8225
8226 static bool op_qaddsub(DisasContext *s, arg_rrr *a, bool add, bool doub)
8227 {
8228     TCGv_i32 t0, t1;
8229
8230     if (s->thumb
8231         ? !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)
8232         : !ENABLE_ARCH_5TE) {
8233         return false;
8234     }
8235
8236     t0 = load_reg(s, a->rm);
8237     t1 = load_reg(s, a->rn);
8238     if (doub) {
8239         gen_helper_add_saturate(t1, cpu_env, t1, t1);
8240     }
8241     if (add) {
8242         gen_helper_add_saturate(t0, cpu_env, t0, t1);
8243     } else {
8244         gen_helper_sub_saturate(t0, cpu_env, t0, t1);
8245     }
8246     tcg_temp_free_i32(t1);
8247     store_reg(s, a->rd, t0);
8248     return true;
8249 }
8250
8251 #define DO_QADDSUB(NAME, ADD, DOUB) \
8252 static bool trans_##NAME(DisasContext *s, arg_rrr *a)    \
8253 {                                                        \
8254     return op_qaddsub(s, a, ADD, DOUB);                  \
8255 }
8256
8257 DO_QADDSUB(QADD, true, false)
8258 DO_QADDSUB(QSUB, false, false)
8259 DO_QADDSUB(QDADD, true, true)
8260 DO_QADDSUB(QDSUB, false, true)
8261
8262 #undef DO_QADDSUB
8263
8264 /*
8265  * Halfword multiply and multiply accumulate
8266  */
8267
8268 static bool op_smlaxxx(DisasContext *s, arg_rrrr *a,
8269                        int add_long, bool nt, bool mt)
8270 {
8271     TCGv_i32 t0, t1, tl, th;
8272
8273     if (s->thumb
8274         ? !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)
8275         : !ENABLE_ARCH_5TE) {
8276         return false;
8277     }
8278
8279     t0 = load_reg(s, a->rn);
8280     t1 = load_reg(s, a->rm);
8281     gen_mulxy(t0, t1, nt, mt);
8282     tcg_temp_free_i32(t1);
8283
8284     switch (add_long) {
8285     case 0:
8286         store_reg(s, a->rd, t0);
8287         break;
8288     case 1:
8289         t1 = load_reg(s, a->ra);
8290         gen_helper_add_setq(t0, cpu_env, t0, t1);
8291         tcg_temp_free_i32(t1);
8292         store_reg(s, a->rd, t0);
8293         break;
8294     case 2:
8295         tl = load_reg(s, a->ra);
8296         th = load_reg(s, a->rd);
8297         /* Sign-extend the 32-bit product to 64 bits.  */
8298         t1 = tcg_temp_new_i32();
8299         tcg_gen_sari_i32(t1, t0, 31);
8300         tcg_gen_add2_i32(tl, th, tl, th, t0, t1);
8301         tcg_temp_free_i32(t0);
8302         tcg_temp_free_i32(t1);
8303         store_reg(s, a->ra, tl);
8304         store_reg(s, a->rd, th);
8305         break;
8306     default:
8307         g_assert_not_reached();
8308     }
8309     return true;
8310 }
8311
8312 #define DO_SMLAX(NAME, add, nt, mt) \
8313 static bool trans_##NAME(DisasContext *s, arg_rrrr *a)     \
8314 {                                                          \
8315     return op_smlaxxx(s, a, add, nt, mt);                  \
8316 }
8317
8318 DO_SMLAX(SMULBB, 0, 0, 0)
8319 DO_SMLAX(SMULBT, 0, 0, 1)
8320 DO_SMLAX(SMULTB, 0, 1, 0)
8321 DO_SMLAX(SMULTT, 0, 1, 1)
8322
8323 DO_SMLAX(SMLABB, 1, 0, 0)
8324 DO_SMLAX(SMLABT, 1, 0, 1)
8325 DO_SMLAX(SMLATB, 1, 1, 0)
8326 DO_SMLAX(SMLATT, 1, 1, 1)
8327
8328 DO_SMLAX(SMLALBB, 2, 0, 0)
8329 DO_SMLAX(SMLALBT, 2, 0, 1)
8330 DO_SMLAX(SMLALTB, 2, 1, 0)
8331 DO_SMLAX(SMLALTT, 2, 1, 1)
8332
8333 #undef DO_SMLAX
8334
8335 static bool op_smlawx(DisasContext *s, arg_rrrr *a, bool add, bool mt)
8336 {
8337     TCGv_i32 t0, t1;
8338
8339     if (!ENABLE_ARCH_5TE) {
8340         return false;
8341     }
8342
8343     t0 = load_reg(s, a->rn);
8344     t1 = load_reg(s, a->rm);
8345     /*
8346      * Since the nominal result is product<47:16>, shift the 16-bit
8347      * input up by 16 bits, so that the result is at product<63:32>.
8348      */
8349     if (mt) {
8350         tcg_gen_andi_i32(t1, t1, 0xffff0000);
8351     } else {
8352         tcg_gen_shli_i32(t1, t1, 16);
8353     }
8354     tcg_gen_muls2_i32(t0, t1, t0, t1);
8355     tcg_temp_free_i32(t0);
8356     if (add) {
8357         t0 = load_reg(s, a->ra);
8358         gen_helper_add_setq(t1, cpu_env, t1, t0);
8359         tcg_temp_free_i32(t0);
8360     }
8361     store_reg(s, a->rd, t1);
8362     return true;
8363 }
8364
8365 #define DO_SMLAWX(NAME, add, mt) \
8366 static bool trans_##NAME(DisasContext *s, arg_rrrr *a)     \
8367 {                                                          \
8368     return op_smlawx(s, a, add, mt);                       \
8369 }
8370
8371 DO_SMLAWX(SMULWB, 0, 0)
8372 DO_SMLAWX(SMULWT, 0, 1)
8373 DO_SMLAWX(SMLAWB, 1, 0)
8374 DO_SMLAWX(SMLAWT, 1, 1)
8375
8376 #undef DO_SMLAWX
8377
8378 /*
8379  * MSR (immediate) and hints
8380  */
8381
8382 static bool trans_YIELD(DisasContext *s, arg_YIELD *a)
8383 {
8384     /*
8385      * When running single-threaded TCG code, use the helper to ensure that
8386      * the next round-robin scheduled vCPU gets a crack.  When running in
8387      * MTTCG we don't generate jumps to the helper as it won't affect the
8388      * scheduling of other vCPUs.
8389      */
8390     if (!(tb_cflags(s->base.tb) & CF_PARALLEL)) {
8391         gen_set_pc_im(s, s->base.pc_next);
8392         s->base.is_jmp = DISAS_YIELD;
8393     }
8394     return true;
8395 }
8396
8397 static bool trans_WFE(DisasContext *s, arg_WFE *a)
8398 {
8399     /*
8400      * When running single-threaded TCG code, use the helper to ensure that
8401      * the next round-robin scheduled vCPU gets a crack.  In MTTCG mode we
8402      * just skip this instruction.  Currently the SEV/SEVL instructions,
8403      * which are *one* of many ways to wake the CPU from WFE, are not
8404      * implemented so we can't sleep like WFI does.
8405      */
8406     if (!(tb_cflags(s->base.tb) & CF_PARALLEL)) {
8407         gen_set_pc_im(s, s->base.pc_next);
8408         s->base.is_jmp = DISAS_WFE;
8409     }
8410     return true;
8411 }
8412
8413 static bool trans_WFI(DisasContext *s, arg_WFI *a)
8414 {
8415     /* For WFI, halt the vCPU until an IRQ. */
8416     gen_set_pc_im(s, s->base.pc_next);
8417     s->base.is_jmp = DISAS_WFI;
8418     return true;
8419 }
8420
8421 static bool trans_NOP(DisasContext *s, arg_NOP *a)
8422 {
8423     return true;
8424 }
8425
8426 static bool trans_MSR_imm(DisasContext *s, arg_MSR_imm *a)
8427 {
8428     uint32_t val = ror32(a->imm, a->rot * 2);
8429     uint32_t mask = msr_mask(s, a->mask, a->r);
8430
8431     if (gen_set_psr_im(s, mask, a->r, val)) {
8432         unallocated_encoding(s);
8433     }
8434     return true;
8435 }
8436
8437 /*
8438  * Cyclic Redundancy Check
8439  */
8440
8441 static bool op_crc32(DisasContext *s, arg_rrr *a, bool c, MemOp sz)
8442 {
8443     TCGv_i32 t1, t2, t3;
8444
8445     if (!dc_isar_feature(aa32_crc32, s)) {
8446         return false;
8447     }
8448
8449     t1 = load_reg(s, a->rn);
8450     t2 = load_reg(s, a->rm);
8451     switch (sz) {
8452     case MO_8:
8453         gen_uxtb(t2);
8454         break;
8455     case MO_16:
8456         gen_uxth(t2);
8457         break;
8458     case MO_32:
8459         break;
8460     default:
8461         g_assert_not_reached();
8462     }
8463     t3 = tcg_const_i32(1 << sz);
8464     if (c) {
8465         gen_helper_crc32c(t1, t1, t2, t3);
8466     } else {
8467         gen_helper_crc32(t1, t1, t2, t3);
8468     }
8469     tcg_temp_free_i32(t2);
8470     tcg_temp_free_i32(t3);
8471     store_reg(s, a->rd, t1);
8472     return true;
8473 }
8474
8475 #define DO_CRC32(NAME, c, sz) \
8476 static bool trans_##NAME(DisasContext *s, arg_rrr *a)  \
8477     { return op_crc32(s, a, c, sz); }
8478
8479 DO_CRC32(CRC32B, false, MO_8)
8480 DO_CRC32(CRC32H, false, MO_16)
8481 DO_CRC32(CRC32W, false, MO_32)
8482 DO_CRC32(CRC32CB, true, MO_8)
8483 DO_CRC32(CRC32CH, true, MO_16)
8484 DO_CRC32(CRC32CW, true, MO_32)
8485
8486 #undef DO_CRC32
8487
8488 /*
8489  * Miscellaneous instructions
8490  */
8491
8492 static bool trans_MRS_bank(DisasContext *s, arg_MRS_bank *a)
8493 {
8494     if (arm_dc_feature(s, ARM_FEATURE_M)) {
8495         return false;
8496     }
8497     gen_mrs_banked(s, a->r, a->sysm, a->rd);
8498     return true;
8499 }
8500
8501 static bool trans_MSR_bank(DisasContext *s, arg_MSR_bank *a)
8502 {
8503     if (arm_dc_feature(s, ARM_FEATURE_M)) {
8504         return false;
8505     }
8506     gen_msr_banked(s, a->r, a->sysm, a->rn);
8507     return true;
8508 }
8509
8510 static bool trans_MRS_reg(DisasContext *s, arg_MRS_reg *a)
8511 {
8512     TCGv_i32 tmp;
8513
8514     if (arm_dc_feature(s, ARM_FEATURE_M)) {
8515         return false;
8516     }
8517     if (a->r) {
8518         if (IS_USER(s)) {
8519             unallocated_encoding(s);
8520             return true;
8521         }
8522         tmp = load_cpu_field(spsr);
8523     } else {
8524         tmp = tcg_temp_new_i32();
8525         gen_helper_cpsr_read(tmp, cpu_env);
8526     }
8527     store_reg(s, a->rd, tmp);
8528     return true;
8529 }
8530
8531 static bool trans_MSR_reg(DisasContext *s, arg_MSR_reg *a)
8532 {
8533     TCGv_i32 tmp;
8534     uint32_t mask = msr_mask(s, a->mask, a->r);
8535
8536     if (arm_dc_feature(s, ARM_FEATURE_M)) {
8537         return false;
8538     }
8539     tmp = load_reg(s, a->rn);
8540     if (gen_set_psr(s, mask, a->r, tmp)) {
8541         unallocated_encoding(s);
8542     }
8543     return true;
8544 }
8545
8546 static bool trans_MRS_v7m(DisasContext *s, arg_MRS_v7m *a)
8547 {
8548     TCGv_i32 tmp;
8549
8550     if (!arm_dc_feature(s, ARM_FEATURE_M)) {
8551         return false;
8552     }
8553     tmp = tcg_const_i32(a->sysm);
8554     gen_helper_v7m_mrs(tmp, cpu_env, tmp);
8555     store_reg(s, a->rd, tmp);
8556     return true;
8557 }
8558
8559 static bool trans_MSR_v7m(DisasContext *s, arg_MSR_v7m *a)
8560 {
8561     TCGv_i32 addr, reg;
8562
8563     if (!arm_dc_feature(s, ARM_FEATURE_M)) {
8564         return false;
8565     }
8566     addr = tcg_const_i32((a->mask << 10) | a->sysm);
8567     reg = load_reg(s, a->rn);
8568     gen_helper_v7m_msr(cpu_env, addr, reg);
8569     tcg_temp_free_i32(addr);
8570     tcg_temp_free_i32(reg);
8571     /* If we wrote to CONTROL, the EL might have changed */
8572     gen_helper_rebuild_hflags_m32_newel(cpu_env);
8573     gen_lookup_tb(s);
8574     return true;
8575 }
8576
8577 static bool trans_BX(DisasContext *s, arg_BX *a)
8578 {
8579     if (!ENABLE_ARCH_4T) {
8580         return false;
8581     }
8582     gen_bx_excret(s, load_reg(s, a->rm));
8583     return true;
8584 }
8585
8586 static bool trans_BXJ(DisasContext *s, arg_BXJ *a)
8587 {
8588     if (!ENABLE_ARCH_5J || arm_dc_feature(s, ARM_FEATURE_M)) {
8589         return false;
8590     }
8591     /* Trivial implementation equivalent to bx.  */
8592     gen_bx(s, load_reg(s, a->rm));
8593     return true;
8594 }
8595
8596 static bool trans_BLX_r(DisasContext *s, arg_BLX_r *a)
8597 {
8598     TCGv_i32 tmp;
8599
8600     if (!ENABLE_ARCH_5) {
8601         return false;
8602     }
8603     tmp = load_reg(s, a->rm);
8604     tcg_gen_movi_i32(cpu_R[14], s->base.pc_next | s->thumb);
8605     gen_bx(s, tmp);
8606     return true;
8607 }
8608
8609 /*
8610  * BXNS/BLXNS: only exist for v8M with the security extensions,
8611  * and always UNDEF if NonSecure.  We don't implement these in
8612  * the user-only mode either (in theory you can use them from
8613  * Secure User mode but they are too tied in to system emulation).
8614  */
8615 static bool trans_BXNS(DisasContext *s, arg_BXNS *a)
8616 {
8617     if (!s->v8m_secure || IS_USER_ONLY) {
8618         unallocated_encoding(s);
8619     } else {
8620         gen_bxns(s, a->rm);
8621     }
8622     return true;
8623 }
8624
8625 static bool trans_BLXNS(DisasContext *s, arg_BLXNS *a)
8626 {
8627     if (!s->v8m_secure || IS_USER_ONLY) {
8628         unallocated_encoding(s);
8629     } else {
8630         gen_blxns(s, a->rm);
8631     }
8632     return true;
8633 }
8634
8635 static bool trans_CLZ(DisasContext *s, arg_CLZ *a)
8636 {
8637     TCGv_i32 tmp;
8638
8639     if (!ENABLE_ARCH_5) {
8640         return false;
8641     }
8642     tmp = load_reg(s, a->rm);
8643     tcg_gen_clzi_i32(tmp, tmp, 32);
8644     store_reg(s, a->rd, tmp);
8645     return true;
8646 }
8647
8648 static bool trans_ERET(DisasContext *s, arg_ERET *a)
8649 {
8650     TCGv_i32 tmp;
8651
8652     if (!arm_dc_feature(s, ARM_FEATURE_V7VE)) {
8653         return false;
8654     }
8655     if (IS_USER(s)) {
8656         unallocated_encoding(s);
8657         return true;
8658     }
8659     if (s->current_el == 2) {
8660         /* ERET from Hyp uses ELR_Hyp, not LR */
8661         tmp = load_cpu_field(elr_el[2]);
8662     } else {
8663         tmp = load_reg(s, 14);
8664     }
8665     gen_exception_return(s, tmp);
8666     return true;
8667 }
8668
8669 static bool trans_HLT(DisasContext *s, arg_HLT *a)
8670 {
8671     gen_hlt(s, a->imm);
8672     return true;
8673 }
8674
8675 static bool trans_BKPT(DisasContext *s, arg_BKPT *a)
8676 {
8677     if (!ENABLE_ARCH_5) {
8678         return false;
8679     }
8680     if (arm_dc_feature(s, ARM_FEATURE_M) &&
8681         semihosting_enabled() &&
8682 #ifndef CONFIG_USER_ONLY
8683         !IS_USER(s) &&
8684 #endif
8685         (a->imm == 0xab)) {
8686         gen_exception_internal_insn(s, s->pc_curr, EXCP_SEMIHOST);
8687     } else {
8688         gen_exception_bkpt_insn(s, syn_aa32_bkpt(a->imm, false));
8689     }
8690     return true;
8691 }
8692
8693 static bool trans_HVC(DisasContext *s, arg_HVC *a)
8694 {
8695     if (!ENABLE_ARCH_7 || arm_dc_feature(s, ARM_FEATURE_M)) {
8696         return false;
8697     }
8698     if (IS_USER(s)) {
8699         unallocated_encoding(s);
8700     } else {
8701         gen_hvc(s, a->imm);
8702     }
8703     return true;
8704 }
8705
8706 static bool trans_SMC(DisasContext *s, arg_SMC *a)
8707 {
8708     if (!ENABLE_ARCH_6K || arm_dc_feature(s, ARM_FEATURE_M)) {
8709         return false;
8710     }
8711     if (IS_USER(s)) {
8712         unallocated_encoding(s);
8713     } else {
8714         gen_smc(s);
8715     }
8716     return true;
8717 }
8718
8719 static bool trans_SG(DisasContext *s, arg_SG *a)
8720 {
8721     if (!arm_dc_feature(s, ARM_FEATURE_M) ||
8722         !arm_dc_feature(s, ARM_FEATURE_V8)) {
8723         return false;
8724     }
8725     /*
8726      * SG (v8M only)
8727      * The bulk of the behaviour for this instruction is implemented
8728      * in v7m_handle_execute_nsc(), which deals with the insn when
8729      * it is executed by a CPU in non-secure state from memory
8730      * which is Secure & NonSecure-Callable.
8731      * Here we only need to handle the remaining cases:
8732      *  * in NS memory (including the "security extension not
8733      *    implemented" case) : NOP
8734      *  * in S memory but CPU already secure (clear IT bits)
8735      * We know that the attribute for the memory this insn is
8736      * in must match the current CPU state, because otherwise
8737      * get_phys_addr_pmsav8 would have generated an exception.
8738      */
8739     if (s->v8m_secure) {
8740         /* Like the IT insn, we don't need to generate any code */
8741         s->condexec_cond = 0;
8742         s->condexec_mask = 0;
8743     }
8744     return true;
8745 }
8746
8747 static bool trans_TT(DisasContext *s, arg_TT *a)
8748 {
8749     TCGv_i32 addr, tmp;
8750
8751     if (!arm_dc_feature(s, ARM_FEATURE_M) ||
8752         !arm_dc_feature(s, ARM_FEATURE_V8)) {
8753         return false;
8754     }
8755     if (a->rd == 13 || a->rd == 15 || a->rn == 15) {
8756         /* We UNDEF for these UNPREDICTABLE cases */
8757         unallocated_encoding(s);
8758         return true;
8759     }
8760     if (a->A && !s->v8m_secure) {
8761         /* This case is UNDEFINED.  */
8762         unallocated_encoding(s);
8763         return true;
8764     }
8765
8766     addr = load_reg(s, a->rn);
8767     tmp = tcg_const_i32((a->A << 1) | a->T);
8768     gen_helper_v7m_tt(tmp, cpu_env, addr, tmp);
8769     tcg_temp_free_i32(addr);
8770     store_reg(s, a->rd, tmp);
8771     return true;
8772 }
8773
8774 /*
8775  * Load/store register index
8776  */
8777
8778 static ISSInfo make_issinfo(DisasContext *s, int rd, bool p, bool w)
8779 {
8780     ISSInfo ret;
8781
8782     /* ISS not valid if writeback */
8783     if (p && !w) {
8784         ret = rd;
8785         if (s->base.pc_next - s->pc_curr == 2) {
8786             ret |= ISSIs16Bit;
8787         }
8788     } else {
8789         ret = ISSInvalid;
8790     }
8791     return ret;
8792 }
8793
8794 static TCGv_i32 op_addr_rr_pre(DisasContext *s, arg_ldst_rr *a)
8795 {
8796     TCGv_i32 addr = load_reg(s, a->rn);
8797
8798     if (s->v8m_stackcheck && a->rn == 13 && a->w) {
8799         gen_helper_v8m_stackcheck(cpu_env, addr);
8800     }
8801
8802     if (a->p) {
8803         TCGv_i32 ofs = load_reg(s, a->rm);
8804         gen_arm_shift_im(ofs, a->shtype, a->shimm, 0);
8805         if (a->u) {
8806             tcg_gen_add_i32(addr, addr, ofs);
8807         } else {
8808             tcg_gen_sub_i32(addr, addr, ofs);
8809         }
8810         tcg_temp_free_i32(ofs);
8811     }
8812     return addr;
8813 }
8814
8815 static void op_addr_rr_post(DisasContext *s, arg_ldst_rr *a,
8816                             TCGv_i32 addr, int address_offset)
8817 {
8818     if (!a->p) {
8819         TCGv_i32 ofs = load_reg(s, a->rm);
8820         gen_arm_shift_im(ofs, a->shtype, a->shimm, 0);
8821         if (a->u) {
8822             tcg_gen_add_i32(addr, addr, ofs);
8823         } else {
8824             tcg_gen_sub_i32(addr, addr, ofs);
8825         }
8826         tcg_temp_free_i32(ofs);
8827     } else if (!a->w) {
8828         tcg_temp_free_i32(addr);
8829         return;
8830     }
8831     tcg_gen_addi_i32(addr, addr, address_offset);
8832     store_reg(s, a->rn, addr);
8833 }
8834
8835 static bool op_load_rr(DisasContext *s, arg_ldst_rr *a,
8836                        MemOp mop, int mem_idx)
8837 {
8838     ISSInfo issinfo = make_issinfo(s, a->rt, a->p, a->w);
8839     TCGv_i32 addr, tmp;
8840
8841     addr = op_addr_rr_pre(s, a);
8842
8843     tmp = tcg_temp_new_i32();
8844     gen_aa32_ld_i32(s, tmp, addr, mem_idx, mop | s->be_data);
8845     disas_set_da_iss(s, mop, issinfo);
8846
8847     /*
8848      * Perform base writeback before the loaded value to
8849      * ensure correct behavior with overlapping index registers.
8850      */
8851     op_addr_rr_post(s, a, addr, 0);
8852     store_reg_from_load(s, a->rt, tmp);
8853     return true;
8854 }
8855
8856 static bool op_store_rr(DisasContext *s, arg_ldst_rr *a,
8857                         MemOp mop, int mem_idx)
8858 {
8859     ISSInfo issinfo = make_issinfo(s, a->rt, a->p, a->w) | ISSIsWrite;
8860     TCGv_i32 addr, tmp;
8861
8862     addr = op_addr_rr_pre(s, a);
8863
8864     tmp = load_reg(s, a->rt);
8865     gen_aa32_st_i32(s, tmp, addr, mem_idx, mop | s->be_data);
8866     disas_set_da_iss(s, mop, issinfo);
8867     tcg_temp_free_i32(tmp);
8868
8869     op_addr_rr_post(s, a, addr, 0);
8870     return true;
8871 }
8872
8873 static bool trans_LDRD_rr(DisasContext *s, arg_ldst_rr *a)
8874 {
8875     int mem_idx = get_mem_index(s);
8876     TCGv_i32 addr, tmp;
8877
8878     if (!ENABLE_ARCH_5TE) {
8879         return false;
8880     }
8881     if (a->rt & 1) {
8882         unallocated_encoding(s);
8883         return true;
8884     }
8885     addr = op_addr_rr_pre(s, a);
8886
8887     tmp = tcg_temp_new_i32();
8888     gen_aa32_ld_i32(s, tmp, addr, mem_idx, MO_UL | s->be_data);
8889     store_reg(s, a->rt, tmp);
8890
8891     tcg_gen_addi_i32(addr, addr, 4);
8892
8893     tmp = tcg_temp_new_i32();
8894     gen_aa32_ld_i32(s, tmp, addr, mem_idx, MO_UL | s->be_data);
8895     store_reg(s, a->rt + 1, tmp);
8896
8897     /* LDRD w/ base writeback is undefined if the registers overlap.  */
8898     op_addr_rr_post(s, a, addr, -4);
8899     return true;
8900 }
8901
8902 static bool trans_STRD_rr(DisasContext *s, arg_ldst_rr *a)
8903 {
8904     int mem_idx = get_mem_index(s);
8905     TCGv_i32 addr, tmp;
8906
8907     if (!ENABLE_ARCH_5TE) {
8908         return false;
8909     }
8910     if (a->rt & 1) {
8911         unallocated_encoding(s);
8912         return true;
8913     }
8914     addr = op_addr_rr_pre(s, a);
8915
8916     tmp = load_reg(s, a->rt);
8917     gen_aa32_st_i32(s, tmp, addr, mem_idx, MO_UL | s->be_data);
8918     tcg_temp_free_i32(tmp);
8919
8920     tcg_gen_addi_i32(addr, addr, 4);
8921
8922     tmp = load_reg(s, a->rt + 1);
8923     gen_aa32_st_i32(s, tmp, addr, mem_idx, MO_UL | s->be_data);
8924     tcg_temp_free_i32(tmp);
8925
8926     op_addr_rr_post(s, a, addr, -4);
8927     return true;
8928 }
8929
8930 /*
8931  * Load/store immediate index
8932  */
8933
8934 static TCGv_i32 op_addr_ri_pre(DisasContext *s, arg_ldst_ri *a)
8935 {
8936     int ofs = a->imm;
8937
8938     if (!a->u) {
8939         ofs = -ofs;
8940     }
8941
8942     if (s->v8m_stackcheck && a->rn == 13 && a->w) {
8943         /*
8944          * Stackcheck. Here we know 'addr' is the current SP;
8945          * U is set if we're moving SP up, else down. It is
8946          * UNKNOWN whether the limit check triggers when SP starts
8947          * below the limit and ends up above it; we chose to do so.
8948          */
8949         if (!a->u) {
8950             TCGv_i32 newsp = tcg_temp_new_i32();
8951             tcg_gen_addi_i32(newsp, cpu_R[13], ofs);
8952             gen_helper_v8m_stackcheck(cpu_env, newsp);
8953             tcg_temp_free_i32(newsp);
8954         } else {
8955             gen_helper_v8m_stackcheck(cpu_env, cpu_R[13]);
8956         }
8957     }
8958
8959     return add_reg_for_lit(s, a->rn, a->p ? ofs : 0);
8960 }
8961
8962 static void op_addr_ri_post(DisasContext *s, arg_ldst_ri *a,
8963                             TCGv_i32 addr, int address_offset)
8964 {
8965     if (!a->p) {
8966         if (a->u) {
8967             address_offset += a->imm;
8968         } else {
8969             address_offset -= a->imm;
8970         }
8971     } else if (!a->w) {
8972         tcg_temp_free_i32(addr);
8973         return;
8974     }
8975     tcg_gen_addi_i32(addr, addr, address_offset);
8976     store_reg(s, a->rn, addr);
8977 }
8978
8979 static bool op_load_ri(DisasContext *s, arg_ldst_ri *a,
8980                        MemOp mop, int mem_idx)
8981 {
8982     ISSInfo issinfo = make_issinfo(s, a->rt, a->p, a->w);
8983     TCGv_i32 addr, tmp;
8984
8985     addr = op_addr_ri_pre(s, a);
8986
8987     tmp = tcg_temp_new_i32();
8988     gen_aa32_ld_i32(s, tmp, addr, mem_idx, mop | s->be_data);
8989     disas_set_da_iss(s, mop, issinfo);
8990
8991     /*
8992      * Perform base writeback before the loaded value to
8993      * ensure correct behavior with overlapping index registers.
8994      */
8995     op_addr_ri_post(s, a, addr, 0);
8996     store_reg_from_load(s, a->rt, tmp);
8997     return true;
8998 }
8999
9000 static bool op_store_ri(DisasContext *s, arg_ldst_ri *a,
9001                         MemOp mop, int mem_idx)
9002 {
9003     ISSInfo issinfo = make_issinfo(s, a->rt, a->p, a->w) | ISSIsWrite;
9004     TCGv_i32 addr, tmp;
9005
9006     addr = op_addr_ri_pre(s, a);
9007
9008     tmp = load_reg(s, a->rt);
9009     gen_aa32_st_i32(s, tmp, addr, mem_idx, mop | s->be_data);
9010     disas_set_da_iss(s, mop, issinfo);
9011     tcg_temp_free_i32(tmp);
9012
9013     op_addr_ri_post(s, a, addr, 0);
9014     return true;
9015 }
9016
9017 static bool op_ldrd_ri(DisasContext *s, arg_ldst_ri *a, int rt2)
9018 {
9019     int mem_idx = get_mem_index(s);
9020     TCGv_i32 addr, tmp;
9021
9022     addr = op_addr_ri_pre(s, a);
9023
9024     tmp = tcg_temp_new_i32();
9025     gen_aa32_ld_i32(s, tmp, addr, mem_idx, MO_UL | s->be_data);
9026     store_reg(s, a->rt, tmp);
9027
9028     tcg_gen_addi_i32(addr, addr, 4);
9029
9030     tmp = tcg_temp_new_i32();
9031     gen_aa32_ld_i32(s, tmp, addr, mem_idx, MO_UL | s->be_data);
9032     store_reg(s, rt2, tmp);
9033
9034     /* LDRD w/ base writeback is undefined if the registers overlap.  */
9035     op_addr_ri_post(s, a, addr, -4);
9036     return true;
9037 }
9038
9039 static bool trans_LDRD_ri_a32(DisasContext *s, arg_ldst_ri *a)
9040 {
9041     if (!ENABLE_ARCH_5TE || (a->rt & 1)) {
9042         return false;
9043     }
9044     return op_ldrd_ri(s, a, a->rt + 1);
9045 }
9046
9047 static bool trans_LDRD_ri_t32(DisasContext *s, arg_ldst_ri2 *a)
9048 {
9049     arg_ldst_ri b = {
9050         .u = a->u, .w = a->w, .p = a->p,
9051         .rn = a->rn, .rt = a->rt, .imm = a->imm
9052     };
9053     return op_ldrd_ri(s, &b, a->rt2);
9054 }
9055
9056 static bool op_strd_ri(DisasContext *s, arg_ldst_ri *a, int rt2)
9057 {
9058     int mem_idx = get_mem_index(s);
9059     TCGv_i32 addr, tmp;
9060
9061     addr = op_addr_ri_pre(s, a);
9062
9063     tmp = load_reg(s, a->rt);
9064     gen_aa32_st_i32(s, tmp, addr, mem_idx, MO_UL | s->be_data);
9065     tcg_temp_free_i32(tmp);
9066
9067     tcg_gen_addi_i32(addr, addr, 4);
9068
9069     tmp = load_reg(s, rt2);
9070     gen_aa32_st_i32(s, tmp, addr, mem_idx, MO_UL | s->be_data);
9071     tcg_temp_free_i32(tmp);
9072
9073     op_addr_ri_post(s, a, addr, -4);
9074     return true;
9075 }
9076
9077 static bool trans_STRD_ri_a32(DisasContext *s, arg_ldst_ri *a)
9078 {
9079     if (!ENABLE_ARCH_5TE || (a->rt & 1)) {
9080         return false;
9081     }
9082     return op_strd_ri(s, a, a->rt + 1);
9083 }
9084
9085 static bool trans_STRD_ri_t32(DisasContext *s, arg_ldst_ri2 *a)
9086 {
9087     arg_ldst_ri b = {
9088         .u = a->u, .w = a->w, .p = a->p,
9089         .rn = a->rn, .rt = a->rt, .imm = a->imm
9090     };
9091     return op_strd_ri(s, &b, a->rt2);
9092 }
9093
9094 #define DO_LDST(NAME, WHICH, MEMOP) \
9095 static bool trans_##NAME##_ri(DisasContext *s, arg_ldst_ri *a)        \
9096 {                                                                     \
9097     return op_##WHICH##_ri(s, a, MEMOP, get_mem_index(s));            \
9098 }                                                                     \
9099 static bool trans_##NAME##T_ri(DisasContext *s, arg_ldst_ri *a)       \
9100 {                                                                     \
9101     return op_##WHICH##_ri(s, a, MEMOP, get_a32_user_mem_index(s));   \
9102 }                                                                     \
9103 static bool trans_##NAME##_rr(DisasContext *s, arg_ldst_rr *a)        \
9104 {                                                                     \
9105     return op_##WHICH##_rr(s, a, MEMOP, get_mem_index(s));            \
9106 }                                                                     \
9107 static bool trans_##NAME##T_rr(DisasContext *s, arg_ldst_rr *a)       \
9108 {                                                                     \
9109     return op_##WHICH##_rr(s, a, MEMOP, get_a32_user_mem_index(s));   \
9110 }
9111
9112 DO_LDST(LDR, load, MO_UL)
9113 DO_LDST(LDRB, load, MO_UB)
9114 DO_LDST(LDRH, load, MO_UW)
9115 DO_LDST(LDRSB, load, MO_SB)
9116 DO_LDST(LDRSH, load, MO_SW)
9117
9118 DO_LDST(STR, store, MO_UL)
9119 DO_LDST(STRB, store, MO_UB)
9120 DO_LDST(STRH, store, MO_UW)
9121
9122 #undef DO_LDST
9123
9124 /*
9125  * Synchronization primitives
9126  */
9127
9128 static bool op_swp(DisasContext *s, arg_SWP *a, MemOp opc)
9129 {
9130     TCGv_i32 addr, tmp;
9131     TCGv taddr;
9132
9133     opc |= s->be_data;
9134     addr = load_reg(s, a->rn);
9135     taddr = gen_aa32_addr(s, addr, opc);
9136     tcg_temp_free_i32(addr);
9137
9138     tmp = load_reg(s, a->rt2);
9139     tcg_gen_atomic_xchg_i32(tmp, taddr, tmp, get_mem_index(s), opc);
9140     tcg_temp_free(taddr);
9141
9142     store_reg(s, a->rt, tmp);
9143     return true;
9144 }
9145
9146 static bool trans_SWP(DisasContext *s, arg_SWP *a)
9147 {
9148     return op_swp(s, a, MO_UL | MO_ALIGN);
9149 }
9150
9151 static bool trans_SWPB(DisasContext *s, arg_SWP *a)
9152 {
9153     return op_swp(s, a, MO_UB);
9154 }
9155
9156 /*
9157  * Load/Store Exclusive and Load-Acquire/Store-Release
9158  */
9159
9160 static bool op_strex(DisasContext *s, arg_STREX *a, MemOp mop, bool rel)
9161 {
9162     TCGv_i32 addr;
9163     /* Some cases stopped being UNPREDICTABLE in v8A (but not v8M) */
9164     bool v8a = ENABLE_ARCH_8 && !arm_dc_feature(s, ARM_FEATURE_M);
9165
9166     /* We UNDEF for these UNPREDICTABLE cases.  */
9167     if (a->rd == 15 || a->rn == 15 || a->rt == 15
9168         || a->rd == a->rn || a->rd == a->rt
9169         || (!v8a && s->thumb && (a->rd == 13 || a->rt == 13))
9170         || (mop == MO_64
9171             && (a->rt2 == 15
9172                 || a->rd == a->rt2
9173                 || (!v8a && s->thumb && a->rt2 == 13)))) {
9174         unallocated_encoding(s);
9175         return true;
9176     }
9177
9178     if (rel) {
9179         tcg_gen_mb(TCG_MO_ALL | TCG_BAR_STRL);
9180     }
9181
9182     addr = tcg_temp_local_new_i32();
9183     load_reg_var(s, addr, a->rn);
9184     tcg_gen_addi_i32(addr, addr, a->imm);
9185
9186     gen_store_exclusive(s, a->rd, a->rt, a->rt2, addr, mop);
9187     tcg_temp_free_i32(addr);
9188     return true;
9189 }
9190
9191 static bool trans_STREX(DisasContext *s, arg_STREX *a)
9192 {
9193     if (!ENABLE_ARCH_6) {
9194         return false;
9195     }
9196     return op_strex(s, a, MO_32, false);
9197 }
9198
9199 static bool trans_STREXD_a32(DisasContext *s, arg_STREX *a)
9200 {
9201     if (!ENABLE_ARCH_6K) {
9202         return false;
9203     }
9204     /* We UNDEF for these UNPREDICTABLE cases.  */
9205     if (a->rt & 1) {
9206         unallocated_encoding(s);
9207         return true;
9208     }
9209     a->rt2 = a->rt + 1;
9210     return op_strex(s, a, MO_64, false);
9211 }
9212
9213 static bool trans_STREXD_t32(DisasContext *s, arg_STREX *a)
9214 {
9215     return op_strex(s, a, MO_64, false);
9216 }
9217
9218 static bool trans_STREXB(DisasContext *s, arg_STREX *a)
9219 {
9220     if (s->thumb ? !ENABLE_ARCH_7 : !ENABLE_ARCH_6K) {
9221         return false;
9222     }
9223     return op_strex(s, a, MO_8, false);
9224 }
9225
9226 static bool trans_STREXH(DisasContext *s, arg_STREX *a)
9227 {
9228     if (s->thumb ? !ENABLE_ARCH_7 : !ENABLE_ARCH_6K) {
9229         return false;
9230     }
9231     return op_strex(s, a, MO_16, false);
9232 }
9233
9234 static bool trans_STLEX(DisasContext *s, arg_STREX *a)
9235 {
9236     if (!ENABLE_ARCH_8) {
9237         return false;
9238     }
9239     return op_strex(s, a, MO_32, true);
9240 }
9241
9242 static bool trans_STLEXD_a32(DisasContext *s, arg_STREX *a)
9243 {
9244     if (!ENABLE_ARCH_8) {
9245         return false;
9246     }
9247     /* We UNDEF for these UNPREDICTABLE cases.  */
9248     if (a->rt & 1) {
9249         unallocated_encoding(s);
9250         return true;
9251     }
9252     a->rt2 = a->rt + 1;
9253     return op_strex(s, a, MO_64, true);
9254 }
9255
9256 static bool trans_STLEXD_t32(DisasContext *s, arg_STREX *a)
9257 {
9258     if (!ENABLE_ARCH_8) {
9259         return false;
9260     }
9261     return op_strex(s, a, MO_64, true);
9262 }
9263
9264 static bool trans_STLEXB(DisasContext *s, arg_STREX *a)
9265 {
9266     if (!ENABLE_ARCH_8) {
9267         return false;
9268     }
9269     return op_strex(s, a, MO_8, true);
9270 }
9271
9272 static bool trans_STLEXH(DisasContext *s, arg_STREX *a)
9273 {
9274     if (!ENABLE_ARCH_8) {
9275         return false;
9276     }
9277     return op_strex(s, a, MO_16, true);
9278 }
9279
9280 static bool op_stl(DisasContext *s, arg_STL *a, MemOp mop)
9281 {
9282     TCGv_i32 addr, tmp;
9283
9284     if (!ENABLE_ARCH_8) {
9285         return false;
9286     }
9287     /* We UNDEF for these UNPREDICTABLE cases.  */
9288     if (a->rn == 15 || a->rt == 15) {
9289         unallocated_encoding(s);
9290         return true;
9291     }
9292
9293     addr = load_reg(s, a->rn);
9294     tmp = load_reg(s, a->rt);
9295     tcg_gen_mb(TCG_MO_ALL | TCG_BAR_STRL);
9296     gen_aa32_st_i32(s, tmp, addr, get_mem_index(s), mop | s->be_data);
9297     disas_set_da_iss(s, mop, a->rt | ISSIsAcqRel | ISSIsWrite);
9298
9299     tcg_temp_free_i32(tmp);
9300     tcg_temp_free_i32(addr);
9301     return true;
9302 }
9303
9304 static bool trans_STL(DisasContext *s, arg_STL *a)
9305 {
9306     return op_stl(s, a, MO_UL);
9307 }
9308
9309 static bool trans_STLB(DisasContext *s, arg_STL *a)
9310 {
9311     return op_stl(s, a, MO_UB);
9312 }
9313
9314 static bool trans_STLH(DisasContext *s, arg_STL *a)
9315 {
9316     return op_stl(s, a, MO_UW);
9317 }
9318
9319 static bool op_ldrex(DisasContext *s, arg_LDREX *a, MemOp mop, bool acq)
9320 {
9321     TCGv_i32 addr;
9322     /* Some cases stopped being UNPREDICTABLE in v8A (but not v8M) */
9323     bool v8a = ENABLE_ARCH_8 && !arm_dc_feature(s, ARM_FEATURE_M);
9324
9325     /* We UNDEF for these UNPREDICTABLE cases.  */
9326     if (a->rn == 15 || a->rt == 15
9327         || (!v8a && s->thumb && a->rt == 13)
9328         || (mop == MO_64
9329             && (a->rt2 == 15 || a->rt == a->rt2
9330                 || (!v8a && s->thumb && a->rt2 == 13)))) {
9331         unallocated_encoding(s);
9332         return true;
9333     }
9334
9335     addr = tcg_temp_local_new_i32();
9336     load_reg_var(s, addr, a->rn);
9337     tcg_gen_addi_i32(addr, addr, a->imm);
9338
9339     gen_load_exclusive(s, a->rt, a->rt2, addr, mop);
9340     tcg_temp_free_i32(addr);
9341
9342     if (acq) {
9343         tcg_gen_mb(TCG_MO_ALL | TCG_BAR_LDAQ);
9344     }
9345     return true;
9346 }
9347
9348 static bool trans_LDREX(DisasContext *s, arg_LDREX *a)
9349 {
9350     if (!ENABLE_ARCH_6) {
9351         return false;
9352     }
9353     return op_ldrex(s, a, MO_32, false);
9354 }
9355
9356 static bool trans_LDREXD_a32(DisasContext *s, arg_LDREX *a)
9357 {
9358     if (!ENABLE_ARCH_6K) {
9359         return false;
9360     }
9361     /* We UNDEF for these UNPREDICTABLE cases.  */
9362     if (a->rt & 1) {
9363         unallocated_encoding(s);
9364         return true;
9365     }
9366     a->rt2 = a->rt + 1;
9367     return op_ldrex(s, a, MO_64, false);
9368 }
9369
9370 static bool trans_LDREXD_t32(DisasContext *s, arg_LDREX *a)
9371 {
9372     return op_ldrex(s, a, MO_64, false);
9373 }
9374
9375 static bool trans_LDREXB(DisasContext *s, arg_LDREX *a)
9376 {
9377     if (s->thumb ? !ENABLE_ARCH_7 : !ENABLE_ARCH_6K) {
9378         return false;
9379     }
9380     return op_ldrex(s, a, MO_8, false);
9381 }
9382
9383 static bool trans_LDREXH(DisasContext *s, arg_LDREX *a)
9384 {
9385     if (s->thumb ? !ENABLE_ARCH_7 : !ENABLE_ARCH_6K) {
9386         return false;
9387     }
9388     return op_ldrex(s, a, MO_16, false);
9389 }
9390
9391 static bool trans_LDAEX(DisasContext *s, arg_LDREX *a)
9392 {
9393     if (!ENABLE_ARCH_8) {
9394         return false;
9395     }
9396     return op_ldrex(s, a, MO_32, true);
9397 }
9398
9399 static bool trans_LDAEXD_a32(DisasContext *s, arg_LDREX *a)
9400 {
9401     if (!ENABLE_ARCH_8) {
9402         return false;
9403     }
9404     /* We UNDEF for these UNPREDICTABLE cases.  */
9405     if (a->rt & 1) {
9406         unallocated_encoding(s);
9407         return true;
9408     }
9409     a->rt2 = a->rt + 1;
9410     return op_ldrex(s, a, MO_64, true);
9411 }
9412
9413 static bool trans_LDAEXD_t32(DisasContext *s, arg_LDREX *a)
9414 {
9415     if (!ENABLE_ARCH_8) {
9416         return false;
9417     }
9418     return op_ldrex(s, a, MO_64, true);
9419 }
9420
9421 static bool trans_LDAEXB(DisasContext *s, arg_LDREX *a)
9422 {
9423     if (!ENABLE_ARCH_8) {
9424         return false;
9425     }
9426     return op_ldrex(s, a, MO_8, true);
9427 }
9428
9429 static bool trans_LDAEXH(DisasContext *s, arg_LDREX *a)
9430 {
9431     if (!ENABLE_ARCH_8) {
9432         return false;
9433     }
9434     return op_ldrex(s, a, MO_16, true);
9435 }
9436
9437 static bool op_lda(DisasContext *s, arg_LDA *a, MemOp mop)
9438 {
9439     TCGv_i32 addr, tmp;
9440
9441     if (!ENABLE_ARCH_8) {
9442         return false;
9443     }
9444     /* We UNDEF for these UNPREDICTABLE cases.  */
9445     if (a->rn == 15 || a->rt == 15) {
9446         unallocated_encoding(s);
9447         return true;
9448     }
9449
9450     addr = load_reg(s, a->rn);
9451     tmp = tcg_temp_new_i32();
9452     gen_aa32_ld_i32(s, tmp, addr, get_mem_index(s), mop | s->be_data);
9453     disas_set_da_iss(s, mop, a->rt | ISSIsAcqRel);
9454     tcg_temp_free_i32(addr);
9455
9456     store_reg(s, a->rt, tmp);
9457     tcg_gen_mb(TCG_MO_ALL | TCG_BAR_STRL);
9458     return true;
9459 }
9460
9461 static bool trans_LDA(DisasContext *s, arg_LDA *a)
9462 {
9463     return op_lda(s, a, MO_UL);
9464 }
9465
9466 static bool trans_LDAB(DisasContext *s, arg_LDA *a)
9467 {
9468     return op_lda(s, a, MO_UB);
9469 }
9470
9471 static bool trans_LDAH(DisasContext *s, arg_LDA *a)
9472 {
9473     return op_lda(s, a, MO_UW);
9474 }
9475
9476 /*
9477  * Media instructions
9478  */
9479
9480 static bool trans_USADA8(DisasContext *s, arg_USADA8 *a)
9481 {
9482     TCGv_i32 t1, t2;
9483
9484     if (!ENABLE_ARCH_6) {
9485         return false;
9486     }
9487
9488     t1 = load_reg(s, a->rn);
9489     t2 = load_reg(s, a->rm);
9490     gen_helper_usad8(t1, t1, t2);
9491     tcg_temp_free_i32(t2);
9492     if (a->ra != 15) {
9493         t2 = load_reg(s, a->ra);
9494         tcg_gen_add_i32(t1, t1, t2);
9495         tcg_temp_free_i32(t2);
9496     }
9497     store_reg(s, a->rd, t1);
9498     return true;
9499 }
9500
9501 static bool op_bfx(DisasContext *s, arg_UBFX *a, bool u)
9502 {
9503     TCGv_i32 tmp;
9504     int width = a->widthm1 + 1;
9505     int shift = a->lsb;
9506
9507     if (!ENABLE_ARCH_6T2) {
9508         return false;
9509     }
9510     if (shift + width > 32) {
9511         /* UNPREDICTABLE; we choose to UNDEF */
9512         unallocated_encoding(s);
9513         return true;
9514     }
9515
9516     tmp = load_reg(s, a->rn);
9517     if (u) {
9518         tcg_gen_extract_i32(tmp, tmp, shift, width);
9519     } else {
9520         tcg_gen_sextract_i32(tmp, tmp, shift, width);
9521     }
9522     store_reg(s, a->rd, tmp);
9523     return true;
9524 }
9525
9526 static bool trans_SBFX(DisasContext *s, arg_SBFX *a)
9527 {
9528     return op_bfx(s, a, false);
9529 }
9530
9531 static bool trans_UBFX(DisasContext *s, arg_UBFX *a)
9532 {
9533     return op_bfx(s, a, true);
9534 }
9535
9536 static bool trans_BFCI(DisasContext *s, arg_BFCI *a)
9537 {
9538     TCGv_i32 tmp;
9539     int msb = a->msb, lsb = a->lsb;
9540     int width;
9541
9542     if (!ENABLE_ARCH_6T2) {
9543         return false;
9544     }
9545     if (msb < lsb) {
9546         /* UNPREDICTABLE; we choose to UNDEF */
9547         unallocated_encoding(s);
9548         return true;
9549     }
9550
9551     width = msb + 1 - lsb;
9552     if (a->rn == 15) {
9553         /* BFC */
9554         tmp = tcg_const_i32(0);
9555     } else {
9556         /* BFI */
9557         tmp = load_reg(s, a->rn);
9558     }
9559     if (width != 32) {
9560         TCGv_i32 tmp2 = load_reg(s, a->rd);
9561         tcg_gen_deposit_i32(tmp, tmp2, tmp, lsb, width);
9562         tcg_temp_free_i32(tmp2);
9563     }
9564     store_reg(s, a->rd, tmp);
9565     return true;
9566 }
9567
9568 static bool trans_UDF(DisasContext *s, arg_UDF *a)
9569 {
9570     unallocated_encoding(s);
9571     return true;
9572 }
9573
9574 /*
9575  * Parallel addition and subtraction
9576  */
9577
9578 static bool op_par_addsub(DisasContext *s, arg_rrr *a,
9579                           void (*gen)(TCGv_i32, TCGv_i32, TCGv_i32))
9580 {
9581     TCGv_i32 t0, t1;
9582
9583     if (s->thumb
9584         ? !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)
9585         : !ENABLE_ARCH_6) {
9586         return false;
9587     }
9588
9589     t0 = load_reg(s, a->rn);
9590     t1 = load_reg(s, a->rm);
9591
9592     gen(t0, t0, t1);
9593
9594     tcg_temp_free_i32(t1);
9595     store_reg(s, a->rd, t0);
9596     return true;
9597 }
9598
9599 static bool op_par_addsub_ge(DisasContext *s, arg_rrr *a,
9600                              void (*gen)(TCGv_i32, TCGv_i32,
9601                                          TCGv_i32, TCGv_ptr))
9602 {
9603     TCGv_i32 t0, t1;
9604     TCGv_ptr ge;
9605
9606     if (s->thumb
9607         ? !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)
9608         : !ENABLE_ARCH_6) {
9609         return false;
9610     }
9611
9612     t0 = load_reg(s, a->rn);
9613     t1 = load_reg(s, a->rm);
9614
9615     ge = tcg_temp_new_ptr();
9616     tcg_gen_addi_ptr(ge, cpu_env, offsetof(CPUARMState, GE));
9617     gen(t0, t0, t1, ge);
9618
9619     tcg_temp_free_ptr(ge);
9620     tcg_temp_free_i32(t1);
9621     store_reg(s, a->rd, t0);
9622     return true;
9623 }
9624
9625 #define DO_PAR_ADDSUB(NAME, helper) \
9626 static bool trans_##NAME(DisasContext *s, arg_rrr *a)   \
9627 {                                                       \
9628     return op_par_addsub(s, a, helper);                 \
9629 }
9630
9631 #define DO_PAR_ADDSUB_GE(NAME, helper) \
9632 static bool trans_##NAME(DisasContext *s, arg_rrr *a)   \
9633 {                                                       \
9634     return op_par_addsub_ge(s, a, helper);              \
9635 }
9636
9637 DO_PAR_ADDSUB_GE(SADD16, gen_helper_sadd16)
9638 DO_PAR_ADDSUB_GE(SASX, gen_helper_saddsubx)
9639 DO_PAR_ADDSUB_GE(SSAX, gen_helper_ssubaddx)
9640 DO_PAR_ADDSUB_GE(SSUB16, gen_helper_ssub16)
9641 DO_PAR_ADDSUB_GE(SADD8, gen_helper_sadd8)
9642 DO_PAR_ADDSUB_GE(SSUB8, gen_helper_ssub8)
9643
9644 DO_PAR_ADDSUB_GE(UADD16, gen_helper_uadd16)
9645 DO_PAR_ADDSUB_GE(UASX, gen_helper_uaddsubx)
9646 DO_PAR_ADDSUB_GE(USAX, gen_helper_usubaddx)
9647 DO_PAR_ADDSUB_GE(USUB16, gen_helper_usub16)
9648 DO_PAR_ADDSUB_GE(UADD8, gen_helper_uadd8)
9649 DO_PAR_ADDSUB_GE(USUB8, gen_helper_usub8)
9650
9651 DO_PAR_ADDSUB(QADD16, gen_helper_qadd16)
9652 DO_PAR_ADDSUB(QASX, gen_helper_qaddsubx)
9653 DO_PAR_ADDSUB(QSAX, gen_helper_qsubaddx)
9654 DO_PAR_ADDSUB(QSUB16, gen_helper_qsub16)
9655 DO_PAR_ADDSUB(QADD8, gen_helper_qadd8)
9656 DO_PAR_ADDSUB(QSUB8, gen_helper_qsub8)
9657
9658 DO_PAR_ADDSUB(UQADD16, gen_helper_uqadd16)
9659 DO_PAR_ADDSUB(UQASX, gen_helper_uqaddsubx)
9660 DO_PAR_ADDSUB(UQSAX, gen_helper_uqsubaddx)
9661 DO_PAR_ADDSUB(UQSUB16, gen_helper_uqsub16)
9662 DO_PAR_ADDSUB(UQADD8, gen_helper_uqadd8)
9663 DO_PAR_ADDSUB(UQSUB8, gen_helper_uqsub8)
9664
9665 DO_PAR_ADDSUB(SHADD16, gen_helper_shadd16)
9666 DO_PAR_ADDSUB(SHASX, gen_helper_shaddsubx)
9667 DO_PAR_ADDSUB(SHSAX, gen_helper_shsubaddx)
9668 DO_PAR_ADDSUB(SHSUB16, gen_helper_shsub16)
9669 DO_PAR_ADDSUB(SHADD8, gen_helper_shadd8)
9670 DO_PAR_ADDSUB(SHSUB8, gen_helper_shsub8)
9671
9672 DO_PAR_ADDSUB(UHADD16, gen_helper_uhadd16)
9673 DO_PAR_ADDSUB(UHASX, gen_helper_uhaddsubx)
9674 DO_PAR_ADDSUB(UHSAX, gen_helper_uhsubaddx)
9675 DO_PAR_ADDSUB(UHSUB16, gen_helper_uhsub16)
9676 DO_PAR_ADDSUB(UHADD8, gen_helper_uhadd8)
9677 DO_PAR_ADDSUB(UHSUB8, gen_helper_uhsub8)
9678
9679 #undef DO_PAR_ADDSUB
9680 #undef DO_PAR_ADDSUB_GE
9681
9682 /*
9683  * Packing, unpacking, saturation, and reversal
9684  */
9685
9686 static bool trans_PKH(DisasContext *s, arg_PKH *a)
9687 {
9688     TCGv_i32 tn, tm;
9689     int shift = a->imm;
9690
9691     if (s->thumb
9692         ? !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)
9693         : !ENABLE_ARCH_6) {
9694         return false;
9695     }
9696
9697     tn = load_reg(s, a->rn);
9698     tm = load_reg(s, a->rm);
9699     if (a->tb) {
9700         /* PKHTB */
9701         if (shift == 0) {
9702             shift = 31;
9703         }
9704         tcg_gen_sari_i32(tm, tm, shift);
9705         tcg_gen_deposit_i32(tn, tn, tm, 0, 16);
9706     } else {
9707         /* PKHBT */
9708         tcg_gen_shli_i32(tm, tm, shift);
9709         tcg_gen_deposit_i32(tn, tm, tn, 0, 16);
9710     }
9711     tcg_temp_free_i32(tm);
9712     store_reg(s, a->rd, tn);
9713     return true;
9714 }
9715
9716 static bool op_sat(DisasContext *s, arg_sat *a,
9717                    void (*gen)(TCGv_i32, TCGv_env, TCGv_i32, TCGv_i32))
9718 {
9719     TCGv_i32 tmp, satimm;
9720     int shift = a->imm;
9721
9722     if (!ENABLE_ARCH_6) {
9723         return false;
9724     }
9725
9726     tmp = load_reg(s, a->rn);
9727     if (a->sh) {
9728         tcg_gen_sari_i32(tmp, tmp, shift ? shift : 31);
9729     } else {
9730         tcg_gen_shli_i32(tmp, tmp, shift);
9731     }
9732
9733     satimm = tcg_const_i32(a->satimm);
9734     gen(tmp, cpu_env, tmp, satimm);
9735     tcg_temp_free_i32(satimm);
9736
9737     store_reg(s, a->rd, tmp);
9738     return true;
9739 }
9740
9741 static bool trans_SSAT(DisasContext *s, arg_sat *a)
9742 {
9743     return op_sat(s, a, gen_helper_ssat);
9744 }
9745
9746 static bool trans_USAT(DisasContext *s, arg_sat *a)
9747 {
9748     return op_sat(s, a, gen_helper_usat);
9749 }
9750
9751 static bool trans_SSAT16(DisasContext *s, arg_sat *a)
9752 {
9753     if (s->thumb && !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)) {
9754         return false;
9755     }
9756     return op_sat(s, a, gen_helper_ssat16);
9757 }
9758
9759 static bool trans_USAT16(DisasContext *s, arg_sat *a)
9760 {
9761     if (s->thumb && !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)) {
9762         return false;
9763     }
9764     return op_sat(s, a, gen_helper_usat16);
9765 }
9766
9767 static bool op_xta(DisasContext *s, arg_rrr_rot *a,
9768                    void (*gen_extract)(TCGv_i32, TCGv_i32),
9769                    void (*gen_add)(TCGv_i32, TCGv_i32, TCGv_i32))
9770 {
9771     TCGv_i32 tmp;
9772
9773     if (!ENABLE_ARCH_6) {
9774         return false;
9775     }
9776
9777     tmp = load_reg(s, a->rm);
9778     /*
9779      * TODO: In many cases we could do a shift instead of a rotate.
9780      * Combined with a simple extend, that becomes an extract.
9781      */
9782     tcg_gen_rotri_i32(tmp, tmp, a->rot * 8);
9783     gen_extract(tmp, tmp);
9784
9785     if (a->rn != 15) {
9786         TCGv_i32 tmp2 = load_reg(s, a->rn);
9787         gen_add(tmp, tmp, tmp2);
9788         tcg_temp_free_i32(tmp2);
9789     }
9790     store_reg(s, a->rd, tmp);
9791     return true;
9792 }
9793
9794 static bool trans_SXTAB(DisasContext *s, arg_rrr_rot *a)
9795 {
9796     return op_xta(s, a, tcg_gen_ext8s_i32, tcg_gen_add_i32);
9797 }
9798
9799 static bool trans_SXTAH(DisasContext *s, arg_rrr_rot *a)
9800 {
9801     return op_xta(s, a, tcg_gen_ext16s_i32, tcg_gen_add_i32);
9802 }
9803
9804 static bool trans_SXTAB16(DisasContext *s, arg_rrr_rot *a)
9805 {
9806     if (s->thumb && !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)) {
9807         return false;
9808     }
9809     return op_xta(s, a, gen_helper_sxtb16, gen_add16);
9810 }
9811
9812 static bool trans_UXTAB(DisasContext *s, arg_rrr_rot *a)
9813 {
9814     return op_xta(s, a, tcg_gen_ext8u_i32, tcg_gen_add_i32);
9815 }
9816
9817 static bool trans_UXTAH(DisasContext *s, arg_rrr_rot *a)
9818 {
9819     return op_xta(s, a, tcg_gen_ext16u_i32, tcg_gen_add_i32);
9820 }
9821
9822 static bool trans_UXTAB16(DisasContext *s, arg_rrr_rot *a)
9823 {
9824     if (s->thumb && !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)) {
9825         return false;
9826     }
9827     return op_xta(s, a, gen_helper_uxtb16, gen_add16);
9828 }
9829
9830 static bool trans_SEL(DisasContext *s, arg_rrr *a)
9831 {
9832     TCGv_i32 t1, t2, t3;
9833
9834     if (s->thumb
9835         ? !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)
9836         : !ENABLE_ARCH_6) {
9837         return false;
9838     }
9839
9840     t1 = load_reg(s, a->rn);
9841     t2 = load_reg(s, a->rm);
9842     t3 = tcg_temp_new_i32();
9843     tcg_gen_ld_i32(t3, cpu_env, offsetof(CPUARMState, GE));
9844     gen_helper_sel_flags(t1, t3, t1, t2);
9845     tcg_temp_free_i32(t3);
9846     tcg_temp_free_i32(t2);
9847     store_reg(s, a->rd, t1);
9848     return true;
9849 }
9850
9851 static bool op_rr(DisasContext *s, arg_rr *a,
9852                   void (*gen)(TCGv_i32, TCGv_i32))
9853 {
9854     TCGv_i32 tmp;
9855
9856     tmp = load_reg(s, a->rm);
9857     gen(tmp, tmp);
9858     store_reg(s, a->rd, tmp);
9859     return true;
9860 }
9861
9862 static bool trans_REV(DisasContext *s, arg_rr *a)
9863 {
9864     if (!ENABLE_ARCH_6) {
9865         return false;
9866     }
9867     return op_rr(s, a, tcg_gen_bswap32_i32);
9868 }
9869
9870 static bool trans_REV16(DisasContext *s, arg_rr *a)
9871 {
9872     if (!ENABLE_ARCH_6) {
9873         return false;
9874     }
9875     return op_rr(s, a, gen_rev16);
9876 }
9877
9878 static bool trans_REVSH(DisasContext *s, arg_rr *a)
9879 {
9880     if (!ENABLE_ARCH_6) {
9881         return false;
9882     }
9883     return op_rr(s, a, gen_revsh);
9884 }
9885
9886 static bool trans_RBIT(DisasContext *s, arg_rr *a)
9887 {
9888     if (!ENABLE_ARCH_6T2) {
9889         return false;
9890     }
9891     return op_rr(s, a, gen_helper_rbit);
9892 }
9893
9894 /*
9895  * Signed multiply, signed and unsigned divide
9896  */
9897
9898 static bool op_smlad(DisasContext *s, arg_rrrr *a, bool m_swap, bool sub)
9899 {
9900     TCGv_i32 t1, t2;
9901
9902     if (!ENABLE_ARCH_6) {
9903         return false;
9904     }
9905
9906     t1 = load_reg(s, a->rn);
9907     t2 = load_reg(s, a->rm);
9908     if (m_swap) {
9909         gen_swap_half(t2);
9910     }
9911     gen_smul_dual(t1, t2);
9912
9913     if (sub) {
9914         /* This subtraction cannot overflow. */
9915         tcg_gen_sub_i32(t1, t1, t2);
9916     } else {
9917         /*
9918          * This addition cannot overflow 32 bits; however it may
9919          * overflow considered as a signed operation, in which case
9920          * we must set the Q flag.
9921          */
9922         gen_helper_add_setq(t1, cpu_env, t1, t2);
9923     }
9924     tcg_temp_free_i32(t2);
9925
9926     if (a->ra != 15) {
9927         t2 = load_reg(s, a->ra);
9928         gen_helper_add_setq(t1, cpu_env, t1, t2);
9929         tcg_temp_free_i32(t2);
9930     }
9931     store_reg(s, a->rd, t1);
9932     return true;
9933 }
9934
9935 static bool trans_SMLAD(DisasContext *s, arg_rrrr *a)
9936 {
9937     return op_smlad(s, a, false, false);
9938 }
9939
9940 static bool trans_SMLADX(DisasContext *s, arg_rrrr *a)
9941 {
9942     return op_smlad(s, a, true, false);
9943 }
9944
9945 static bool trans_SMLSD(DisasContext *s, arg_rrrr *a)
9946 {
9947     return op_smlad(s, a, false, true);
9948 }
9949
9950 static bool trans_SMLSDX(DisasContext *s, arg_rrrr *a)
9951 {
9952     return op_smlad(s, a, true, true);
9953 }
9954
9955 static bool op_smlald(DisasContext *s, arg_rrrr *a, bool m_swap, bool sub)
9956 {
9957     TCGv_i32 t1, t2;
9958     TCGv_i64 l1, l2;
9959
9960     if (!ENABLE_ARCH_6) {
9961         return false;
9962     }
9963
9964     t1 = load_reg(s, a->rn);
9965     t2 = load_reg(s, a->rm);
9966     if (m_swap) {
9967         gen_swap_half(t2);
9968     }
9969     gen_smul_dual(t1, t2);
9970
9971     l1 = tcg_temp_new_i64();
9972     l2 = tcg_temp_new_i64();
9973     tcg_gen_ext_i32_i64(l1, t1);
9974     tcg_gen_ext_i32_i64(l2, t2);
9975     tcg_temp_free_i32(t1);
9976     tcg_temp_free_i32(t2);
9977
9978     if (sub) {
9979         tcg_gen_sub_i64(l1, l1, l2);
9980     } else {
9981         tcg_gen_add_i64(l1, l1, l2);
9982     }
9983     tcg_temp_free_i64(l2);
9984
9985     gen_addq(s, l1, a->ra, a->rd);
9986     gen_storeq_reg(s, a->ra, a->rd, l1);
9987     tcg_temp_free_i64(l1);
9988     return true;
9989 }
9990
9991 static bool trans_SMLALD(DisasContext *s, arg_rrrr *a)
9992 {
9993     return op_smlald(s, a, false, false);
9994 }
9995
9996 static bool trans_SMLALDX(DisasContext *s, arg_rrrr *a)
9997 {
9998     return op_smlald(s, a, true, false);
9999 }
10000
10001 static bool trans_SMLSLD(DisasContext *s, arg_rrrr *a)
10002 {
10003     return op_smlald(s, a, false, true);
10004 }
10005
10006 static bool trans_SMLSLDX(DisasContext *s, arg_rrrr *a)
10007 {
10008     return op_smlald(s, a, true, true);
10009 }
10010
10011 static bool op_smmla(DisasContext *s, arg_rrrr *a, bool round, bool sub)
10012 {
10013     TCGv_i32 t1, t2;
10014
10015     if (s->thumb
10016         ? !arm_dc_feature(s, ARM_FEATURE_THUMB_DSP)
10017         : !ENABLE_ARCH_6) {
10018         return false;
10019     }
10020
10021     t1 = load_reg(s, a->rn);
10022     t2 = load_reg(s, a->rm);
10023     tcg_gen_muls2_i32(t2, t1, t1, t2);
10024
10025     if (a->ra != 15) {
10026         TCGv_i32 t3 = load_reg(s, a->ra);
10027         if (sub) {
10028             /*
10029              * For SMMLS, we need a 64-bit subtract.  Borrow caused by
10030              * a non-zero multiplicand lowpart, and the correct result
10031              * lowpart for rounding.
10032              */
10033             TCGv_i32 zero = tcg_const_i32(0);
10034             tcg_gen_sub2_i32(t2, t1, zero, t3, t2, t1);
10035             tcg_temp_free_i32(zero);
10036         } else {
10037             tcg_gen_add_i32(t1, t1, t3);
10038         }
10039         tcg_temp_free_i32(t3);
10040     }
10041     if (round) {
10042         /*
10043          * Adding 0x80000000 to the 64-bit quantity means that we have
10044          * carry in to the high word when the low word has the msb set.
10045          */
10046         tcg_gen_shri_i32(t2, t2, 31);
10047         tcg_gen_add_i32(t1, t1, t2);
10048     }
10049     tcg_temp_free_i32(t2);
10050     store_reg(s, a->rd, t1);
10051     return true;
10052 }
10053
10054 static bool trans_SMMLA(DisasContext *s, arg_rrrr *a)
10055 {
10056     return op_smmla(s, a, false, false);
10057 }
10058
10059 static bool trans_SMMLAR(DisasContext *s, arg_rrrr *a)
10060 {
10061     return op_smmla(s, a, true, false);
10062 }
10063
10064 static bool trans_SMMLS(DisasContext *s, arg_rrrr *a)
10065 {
10066     return op_smmla(s, a, false, true);
10067 }
10068
10069 static bool trans_SMMLSR(DisasContext *s, arg_rrrr *a)
10070 {
10071     return op_smmla(s, a, true, true);
10072 }
10073
10074 static bool op_div(DisasContext *s, arg_rrr *a, bool u)
10075 {
10076     TCGv_i32 t1, t2;
10077
10078     if (s->thumb
10079         ? !dc_isar_feature(aa32_thumb_div, s)
10080         : !dc_isar_feature(aa32_arm_div, s)) {
10081         return false;
10082     }
10083
10084     t1 = load_reg(s, a->rn);
10085     t2 = load_reg(s, a->rm);
10086     if (u) {
10087         gen_helper_udiv(t1, t1, t2);
10088     } else {
10089         gen_helper_sdiv(t1, t1, t2);
10090     }
10091     tcg_temp_free_i32(t2);
10092     store_reg(s, a->rd, t1);
10093     return true;
10094 }
10095
10096 static bool trans_SDIV(DisasContext *s, arg_rrr *a)
10097 {
10098     return op_div(s, a, false);
10099 }
10100
10101 static bool trans_UDIV(DisasContext *s, arg_rrr *a)
10102 {
10103     return op_div(s, a, true);
10104 }
10105
10106 /*
10107  * Block data transfer
10108  */
10109
10110 static TCGv_i32 op_addr_block_pre(DisasContext *s, arg_ldst_block *a, int n)
10111 {
10112     TCGv_i32 addr = load_reg(s, a->rn);
10113
10114     if (a->b) {
10115         if (a->i) {
10116             /* pre increment */
10117             tcg_gen_addi_i32(addr, addr, 4);
10118         } else {
10119             /* pre decrement */
10120             tcg_gen_addi_i32(addr, addr, -(n * 4));
10121         }
10122     } else if (!a->i && n != 1) {
10123         /* post decrement */
10124         tcg_gen_addi_i32(addr, addr, -((n - 1) * 4));
10125     }
10126
10127     if (s->v8m_stackcheck && a->rn == 13 && a->w) {
10128         /*
10129          * If the writeback is incrementing SP rather than
10130          * decrementing it, and the initial SP is below the
10131          * stack limit but the final written-back SP would
10132          * be above, then then we must not perform any memory
10133          * accesses, but it is IMPDEF whether we generate
10134          * an exception. We choose to do so in this case.
10135          * At this point 'addr' is the lowest address, so
10136          * either the original SP (if incrementing) or our
10137          * final SP (if decrementing), so that's what we check.
10138          */
10139         gen_helper_v8m_stackcheck(cpu_env, addr);
10140     }
10141
10142     return addr;
10143 }
10144
10145 static void op_addr_block_post(DisasContext *s, arg_ldst_block *a,
10146                                TCGv_i32 addr, int n)
10147 {
10148     if (a->w) {
10149         /* write back */
10150         if (!a->b) {
10151             if (a->i) {
10152                 /* post increment */
10153                 tcg_gen_addi_i32(addr, addr, 4);
10154             } else {
10155                 /* post decrement */
10156                 tcg_gen_addi_i32(addr, addr, -(n * 4));
10157             }
10158         } else if (!a->i && n != 1) {
10159             /* pre decrement */
10160             tcg_gen_addi_i32(addr, addr, -((n - 1) * 4));
10161         }
10162         store_reg(s, a->rn, addr);
10163     } else {
10164         tcg_temp_free_i32(addr);
10165     }
10166 }
10167
10168 static bool op_stm(DisasContext *s, arg_ldst_block *a, int min_n)
10169 {
10170     int i, j, n, list, mem_idx;
10171     bool user = a->u;
10172     TCGv_i32 addr, tmp, tmp2;
10173
10174     if (user) {
10175         /* STM (user) */
10176         if (IS_USER(s)) {
10177             /* Only usable in supervisor mode.  */
10178             unallocated_encoding(s);
10179             return true;
10180         }
10181     }
10182
10183     list = a->list;
10184     n = ctpop16(list);
10185     if (n < min_n || a->rn == 15) {
10186         unallocated_encoding(s);
10187         return true;
10188     }
10189
10190     addr = op_addr_block_pre(s, a, n);
10191     mem_idx = get_mem_index(s);
10192
10193     for (i = j = 0; i < 16; i++) {
10194         if (!(list & (1 << i))) {
10195             continue;
10196         }
10197
10198         if (user && i != 15) {
10199             tmp = tcg_temp_new_i32();
10200             tmp2 = tcg_const_i32(i);
10201             gen_helper_get_user_reg(tmp, cpu_env, tmp2);
10202             tcg_temp_free_i32(tmp2);
10203         } else {
10204             tmp = load_reg(s, i);
10205         }
10206         gen_aa32_st32(s, tmp, addr, mem_idx);
10207         tcg_temp_free_i32(tmp);
10208
10209         /* No need to add after the last transfer.  */
10210         if (++j != n) {
10211             tcg_gen_addi_i32(addr, addr, 4);
10212         }
10213     }
10214
10215     op_addr_block_post(s, a, addr, n);
10216     return true;
10217 }
10218
10219 static bool trans_STM(DisasContext *s, arg_ldst_block *a)
10220 {
10221     /* BitCount(list) < 1 is UNPREDICTABLE */
10222     return op_stm(s, a, 1);
10223 }
10224
10225 static bool trans_STM_t32(DisasContext *s, arg_ldst_block *a)
10226 {
10227     /* Writeback register in register list is UNPREDICTABLE for T32.  */
10228     if (a->w && (a->list & (1 << a->rn))) {
10229         unallocated_encoding(s);
10230         return true;
10231     }
10232     /* BitCount(list) < 2 is UNPREDICTABLE */
10233     return op_stm(s, a, 2);
10234 }
10235
10236 static bool do_ldm(DisasContext *s, arg_ldst_block *a, int min_n)
10237 {
10238     int i, j, n, list, mem_idx;
10239     bool loaded_base;
10240     bool user = a->u;
10241     bool exc_return = false;
10242     TCGv_i32 addr, tmp, tmp2, loaded_var;
10243
10244     if (user) {
10245         /* LDM (user), LDM (exception return) */
10246         if (IS_USER(s)) {
10247             /* Only usable in supervisor mode.  */
10248             unallocated_encoding(s);
10249             return true;
10250         }
10251         if (extract32(a->list, 15, 1)) {
10252             exc_return = true;
10253             user = false;
10254         } else {
10255             /* LDM (user) does not allow writeback.  */
10256             if (a->w) {
10257                 unallocated_encoding(s);
10258                 return true;
10259             }
10260         }
10261     }
10262
10263     list = a->list;
10264     n = ctpop16(list);
10265     if (n < min_n || a->rn == 15) {
10266         unallocated_encoding(s);
10267         return true;
10268     }
10269
10270     addr = op_addr_block_pre(s, a, n);
10271     mem_idx = get_mem_index(s);
10272     loaded_base = false;
10273     loaded_var = NULL;
10274
10275     for (i = j = 0; i < 16; i++) {
10276         if (!(list & (1 << i))) {
10277             continue;
10278         }
10279
10280         tmp = tcg_temp_new_i32();
10281         gen_aa32_ld32u(s, tmp, addr, mem_idx);
10282         if (user) {
10283             tmp2 = tcg_const_i32(i);
10284             gen_helper_set_user_reg(cpu_env, tmp2, tmp);
10285             tcg_temp_free_i32(tmp2);
10286             tcg_temp_free_i32(tmp);
10287         } else if (i == a->rn) {
10288             loaded_var = tmp;
10289             loaded_base = true;
10290         } else if (i == 15 && exc_return) {
10291             store_pc_exc_ret(s, tmp);
10292         } else {
10293             store_reg_from_load(s, i, tmp);
10294         }
10295
10296         /* No need to add after the last transfer.  */
10297         if (++j != n) {
10298             tcg_gen_addi_i32(addr, addr, 4);
10299         }
10300     }
10301
10302     op_addr_block_post(s, a, addr, n);
10303
10304     if (loaded_base) {
10305         /* Note that we reject base == pc above.  */
10306         store_reg(s, a->rn, loaded_var);
10307     }
10308
10309     if (exc_return) {
10310         /* Restore CPSR from SPSR.  */
10311         tmp = load_cpu_field(spsr);
10312         if (tb_cflags(s->base.tb) & CF_USE_ICOUNT) {
10313             gen_io_start();
10314         }
10315         gen_helper_cpsr_write_eret(cpu_env, tmp);
10316         if (tb_cflags(s->base.tb) & CF_USE_ICOUNT) {
10317             gen_io_end();
10318         }
10319         tcg_temp_free_i32(tmp);
10320         /* Must exit loop to check un-masked IRQs */
10321         s->base.is_jmp = DISAS_EXIT;
10322     }
10323     return true;
10324 }
10325
10326 static bool trans_LDM_a32(DisasContext *s, arg_ldst_block *a)
10327 {
10328     /*
10329      * Writeback register in register list is UNPREDICTABLE
10330      * for ArchVersion() >= 7.  Prior to v7, A32 would write
10331      * an UNKNOWN value to the base register.
10332      */
10333     if (ENABLE_ARCH_7 && a->w && (a->list & (1 << a->rn))) {
10334         unallocated_encoding(s);
10335         return true;
10336     }
10337     /* BitCount(list) < 1 is UNPREDICTABLE */
10338     return do_ldm(s, a, 1);
10339 }
10340
10341 static bool trans_LDM_t32(DisasContext *s, arg_ldst_block *a)
10342 {
10343     /* Writeback register in register list is UNPREDICTABLE for T32. */
10344     if (a->w && (a->list & (1 << a->rn))) {
10345         unallocated_encoding(s);
10346         return true;
10347     }
10348     /* BitCount(list) < 2 is UNPREDICTABLE */
10349     return do_ldm(s, a, 2);
10350 }
10351
10352 static bool trans_LDM_t16(DisasContext *s, arg_ldst_block *a)
10353 {
10354     /* Writeback is conditional on the base register not being loaded.  */
10355     a->w = !(a->list & (1 << a->rn));
10356     /* BitCount(list) < 1 is UNPREDICTABLE */
10357     return do_ldm(s, a, 1);
10358 }
10359
10360 /*
10361  * Branch, branch with link
10362  */
10363
10364 static bool trans_B(DisasContext *s, arg_i *a)
10365 {
10366     gen_jmp(s, read_pc(s) + a->imm);
10367     return true;
10368 }
10369
10370 static bool trans_B_cond_thumb(DisasContext *s, arg_ci *a)
10371 {
10372     /* This has cond from encoding, required to be outside IT block.  */
10373     if (a->cond >= 0xe) {
10374         return false;
10375     }
10376     if (s->condexec_mask) {
10377         unallocated_encoding(s);
10378         return true;
10379     }
10380     arm_skip_unless(s, a->cond);
10381     gen_jmp(s, read_pc(s) + a->imm);
10382     return true;
10383 }
10384
10385 static bool trans_BL(DisasContext *s, arg_i *a)
10386 {
10387     tcg_gen_movi_i32(cpu_R[14], s->base.pc_next | s->thumb);
10388     gen_jmp(s, read_pc(s) + a->imm);
10389     return true;
10390 }
10391
10392 static bool trans_BLX_i(DisasContext *s, arg_BLX_i *a)
10393 {
10394     TCGv_i32 tmp;
10395
10396     /* For A32, ARCH(5) is checked near the start of the uncond block. */
10397     if (s->thumb && (a->imm & 2)) {
10398         return false;
10399     }
10400     tcg_gen_movi_i32(cpu_R[14], s->base.pc_next | s->thumb);
10401     tmp = tcg_const_i32(!s->thumb);
10402     store_cpu_field(tmp, thumb);
10403     gen_jmp(s, (read_pc(s) & ~3) + a->imm);
10404     return true;
10405 }
10406
10407 static bool trans_BL_BLX_prefix(DisasContext *s, arg_BL_BLX_prefix *a)
10408 {
10409     assert(!arm_dc_feature(s, ARM_FEATURE_THUMB2));
10410     tcg_gen_movi_i32(cpu_R[14], read_pc(s) + (a->imm << 12));
10411     return true;
10412 }
10413
10414 static bool trans_BL_suffix(DisasContext *s, arg_BL_suffix *a)
10415 {
10416     TCGv_i32 tmp = tcg_temp_new_i32();
10417
10418     assert(!arm_dc_feature(s, ARM_FEATURE_THUMB2));
10419     tcg_gen_addi_i32(tmp, cpu_R[14], (a->imm << 1) | 1);
10420     tcg_gen_movi_i32(cpu_R[14], s->base.pc_next | 1);
10421     gen_bx(s, tmp);
10422     return true;
10423 }
10424
10425 static bool trans_BLX_suffix(DisasContext *s, arg_BLX_suffix *a)
10426 {
10427     TCGv_i32 tmp;
10428
10429     assert(!arm_dc_feature(s, ARM_FEATURE_THUMB2));
10430     if (!ENABLE_ARCH_5) {
10431         return false;
10432     }
10433     tmp = tcg_temp_new_i32();
10434     tcg_gen_addi_i32(tmp, cpu_R[14], a->imm << 1);
10435     tcg_gen_andi_i32(tmp, tmp, 0xfffffffc);
10436     tcg_gen_movi_i32(cpu_R[14], s->base.pc_next | 1);
10437     gen_bx(s, tmp);
10438     return true;
10439 }
10440
10441 static bool op_tbranch(DisasContext *s, arg_tbranch *a, bool half)
10442 {
10443     TCGv_i32 addr, tmp;
10444
10445     tmp = load_reg(s, a->rm);
10446     if (half) {
10447         tcg_gen_add_i32(tmp, tmp, tmp);
10448     }
10449     addr = load_reg(s, a->rn);
10450     tcg_gen_add_i32(addr, addr, tmp);
10451
10452     gen_aa32_ld_i32(s, tmp, addr, get_mem_index(s),
10453                     half ? MO_UW | s->be_data : MO_UB);
10454     tcg_temp_free_i32(addr);
10455
10456     tcg_gen_add_i32(tmp, tmp, tmp);
10457     tcg_gen_addi_i32(tmp, tmp, read_pc(s));
10458     store_reg(s, 15, tmp);
10459     return true;
10460 }
10461
10462 static bool trans_TBB(DisasContext *s, arg_tbranch *a)
10463 {
10464     return op_tbranch(s, a, false);
10465 }
10466
10467 static bool trans_TBH(DisasContext *s, arg_tbranch *a)
10468 {
10469     return op_tbranch(s, a, true);
10470 }
10471
10472 static bool trans_CBZ(DisasContext *s, arg_CBZ *a)
10473 {
10474     TCGv_i32 tmp = load_reg(s, a->rn);
10475
10476     arm_gen_condlabel(s);
10477     tcg_gen_brcondi_i32(a->nz ? TCG_COND_EQ : TCG_COND_NE,
10478                         tmp, 0, s->condlabel);
10479     tcg_temp_free_i32(tmp);
10480     gen_jmp(s, read_pc(s) + a->imm);
10481     return true;
10482 }
10483
10484 /*
10485  * Supervisor call - both T32 & A32 come here so we need to check
10486  * which mode we are in when checking for semihosting.
10487  */
10488
10489 static bool trans_SVC(DisasContext *s, arg_SVC *a)
10490 {
10491     const uint32_t semihost_imm = s->thumb ? 0xab : 0x123456;
10492
10493     if (!arm_dc_feature(s, ARM_FEATURE_M) && semihosting_enabled() &&
10494 #ifndef CONFIG_USER_ONLY
10495         !IS_USER(s) &&
10496 #endif
10497         (a->imm == semihost_imm)) {
10498         gen_exception_internal_insn(s, s->pc_curr, EXCP_SEMIHOST);
10499     } else {
10500         gen_set_pc_im(s, s->base.pc_next);
10501         s->svc_imm = a->imm;
10502         s->base.is_jmp = DISAS_SWI;
10503     }
10504     return true;
10505 }
10506
10507 /*
10508  * Unconditional system instructions
10509  */
10510
10511 static bool trans_RFE(DisasContext *s, arg_RFE *a)
10512 {
10513     static const int8_t pre_offset[4] = {
10514         /* DA */ -4, /* IA */ 0, /* DB */ -8, /* IB */ 4
10515     };
10516     static const int8_t post_offset[4] = {
10517         /* DA */ -8, /* IA */ 4, /* DB */ -4, /* IB */ 0
10518     };
10519     TCGv_i32 addr, t1, t2;
10520
10521     if (!ENABLE_ARCH_6 || arm_dc_feature(s, ARM_FEATURE_M)) {
10522         return false;
10523     }
10524     if (IS_USER(s)) {
10525         unallocated_encoding(s);
10526         return true;
10527     }
10528
10529     addr = load_reg(s, a->rn);
10530     tcg_gen_addi_i32(addr, addr, pre_offset[a->pu]);
10531
10532     /* Load PC into tmp and CPSR into tmp2.  */
10533     t1 = tcg_temp_new_i32();
10534     gen_aa32_ld32u(s, t1, addr, get_mem_index(s));
10535     tcg_gen_addi_i32(addr, addr, 4);
10536     t2 = tcg_temp_new_i32();
10537     gen_aa32_ld32u(s, t2, addr, get_mem_index(s));
10538
10539     if (a->w) {
10540         /* Base writeback.  */
10541         tcg_gen_addi_i32(addr, addr, post_offset[a->pu]);
10542         store_reg(s, a->rn, addr);
10543     } else {
10544         tcg_temp_free_i32(addr);
10545     }
10546     gen_rfe(s, t1, t2);
10547     return true;
10548 }
10549
10550 static bool trans_SRS(DisasContext *s, arg_SRS *a)
10551 {
10552     if (!ENABLE_ARCH_6 || arm_dc_feature(s, ARM_FEATURE_M)) {
10553         return false;
10554     }
10555     gen_srs(s, a->mode, a->pu, a->w);
10556     return true;
10557 }
10558
10559 static bool trans_CPS(DisasContext *s, arg_CPS *a)
10560 {
10561     uint32_t mask, val;
10562
10563     if (!ENABLE_ARCH_6 || arm_dc_feature(s, ARM_FEATURE_M)) {
10564         return false;
10565     }
10566     if (IS_USER(s)) {
10567         /* Implemented as NOP in user mode.  */
10568         return true;
10569     }
10570     /* TODO: There are quite a lot of UNPREDICTABLE argument combinations. */
10571
10572     mask = val = 0;
10573     if (a->imod & 2) {
10574         if (a->A) {
10575             mask |= CPSR_A;
10576         }
10577         if (a->I) {
10578             mask |= CPSR_I;
10579         }
10580         if (a->F) {
10581             mask |= CPSR_F;
10582         }
10583         if (a->imod & 1) {
10584             val |= mask;
10585         }
10586     }
10587     if (a->M) {
10588         mask |= CPSR_M;
10589         val |= a->mode;
10590     }
10591     if (mask) {
10592         gen_set_psr_im(s, mask, 0, val);
10593     }
10594     return true;
10595 }
10596
10597 static bool trans_CPS_v7m(DisasContext *s, arg_CPS_v7m *a)
10598 {
10599     TCGv_i32 tmp, addr, el;
10600
10601     if (!arm_dc_feature(s, ARM_FEATURE_M)) {
10602         return false;
10603     }
10604     if (IS_USER(s)) {
10605         /* Implemented as NOP in user mode.  */
10606         return true;
10607     }
10608
10609     tmp = tcg_const_i32(a->im);
10610     /* FAULTMASK */
10611     if (a->F) {
10612         addr = tcg_const_i32(19);
10613         gen_helper_v7m_msr(cpu_env, addr, tmp);
10614         tcg_temp_free_i32(addr);
10615     }
10616     /* PRIMASK */
10617     if (a->I) {
10618         addr = tcg_const_i32(16);
10619         gen_helper_v7m_msr(cpu_env, addr, tmp);
10620         tcg_temp_free_i32(addr);
10621     }
10622     el = tcg_const_i32(s->current_el);
10623     gen_helper_rebuild_hflags_m32(cpu_env, el);
10624     tcg_temp_free_i32(el);
10625     tcg_temp_free_i32(tmp);
10626     gen_lookup_tb(s);
10627     return true;
10628 }
10629
10630 /*
10631  * Clear-Exclusive, Barriers
10632  */
10633
10634 static bool trans_CLREX(DisasContext *s, arg_CLREX *a)
10635 {
10636     if (s->thumb
10637         ? !ENABLE_ARCH_7 && !arm_dc_feature(s, ARM_FEATURE_M)
10638         : !ENABLE_ARCH_6K) {
10639         return false;
10640     }
10641     gen_clrex(s);
10642     return true;
10643 }
10644
10645 static bool trans_DSB(DisasContext *s, arg_DSB *a)
10646 {
10647     if (!ENABLE_ARCH_7 && !arm_dc_feature(s, ARM_FEATURE_M)) {
10648         return false;
10649     }
10650     tcg_gen_mb(TCG_MO_ALL | TCG_BAR_SC);
10651     return true;
10652 }
10653
10654 static bool trans_DMB(DisasContext *s, arg_DMB *a)
10655 {
10656     return trans_DSB(s, NULL);
10657 }
10658
10659 static bool trans_ISB(DisasContext *s, arg_ISB *a)
10660 {
10661     if (!ENABLE_ARCH_7 && !arm_dc_feature(s, ARM_FEATURE_M)) {
10662         return false;
10663     }
10664     /*
10665      * We need to break the TB after this insn to execute
10666      * self-modifying code correctly and also to take
10667      * any pending interrupts immediately.
10668      */
10669     gen_goto_tb(s, 0, s->base.pc_next);
10670     return true;
10671 }
10672
10673 static bool trans_SB(DisasContext *s, arg_SB *a)
10674 {
10675     if (!dc_isar_feature(aa32_sb, s)) {
10676         return false;
10677     }
10678     /*
10679      * TODO: There is no speculation barrier opcode
10680      * for TCG; MB and end the TB instead.
10681      */
10682     tcg_gen_mb(TCG_MO_ALL | TCG_BAR_SC);
10683     gen_goto_tb(s, 0, s->base.pc_next);
10684     return true;
10685 }
10686
10687 static bool trans_SETEND(DisasContext *s, arg_SETEND *a)
10688 {
10689     if (!ENABLE_ARCH_6) {
10690         return false;
10691     }
10692     if (a->E != (s->be_data == MO_BE)) {
10693         gen_helper_setend(cpu_env);
10694         s->base.is_jmp = DISAS_UPDATE;
10695     }
10696     return true;
10697 }
10698
10699 /*
10700  * Preload instructions
10701  * All are nops, contingent on the appropriate arch level.
10702  */
10703
10704 static bool trans_PLD(DisasContext *s, arg_PLD *a)
10705 {
10706     return ENABLE_ARCH_5TE;
10707 }
10708
10709 static bool trans_PLDW(DisasContext *s, arg_PLD *a)
10710 {
10711     return arm_dc_feature(s, ARM_FEATURE_V7MP);
10712 }
10713
10714 static bool trans_PLI(DisasContext *s, arg_PLD *a)
10715 {
10716     return ENABLE_ARCH_7;
10717 }
10718
10719 /*
10720  * If-then
10721  */
10722
10723 static bool trans_IT(DisasContext *s, arg_IT *a)
10724 {
10725     int cond_mask = a->cond_mask;
10726
10727     /*
10728      * No actual code generated for this insn, just setup state.
10729      *
10730      * Combinations of firstcond and mask which set up an 0b1111
10731      * condition are UNPREDICTABLE; we take the CONSTRAINED
10732      * UNPREDICTABLE choice to treat 0b1111 the same as 0b1110,
10733      * i.e. both meaning "execute always".
10734      */
10735     s->condexec_cond = (cond_mask >> 4) & 0xe;
10736     s->condexec_mask = cond_mask & 0x1f;
10737     return true;
10738 }
10739
10740 /*
10741  * Legacy decoder.
10742  */
10743
10744 static void disas_arm_insn(DisasContext *s, unsigned int insn)
10745 {
10746     unsigned int cond = insn >> 28;
10747
10748     /* M variants do not implement ARM mode; this must raise the INVSTATE
10749      * UsageFault exception.
10750      */
10751     if (arm_dc_feature(s, ARM_FEATURE_M)) {
10752         gen_exception_insn(s, s->pc_curr, EXCP_INVSTATE, syn_uncategorized(),
10753                            default_exception_el(s));
10754         return;
10755     }
10756
10757     if (cond == 0xf) {
10758         /* In ARMv3 and v4 the NV condition is UNPREDICTABLE; we
10759          * choose to UNDEF. In ARMv5 and above the space is used
10760          * for miscellaneous unconditional instructions.
10761          */
10762         ARCH(5);
10763
10764         /* Unconditional instructions.  */
10765         /* TODO: Perhaps merge these into one decodetree output file.  */
10766         if (disas_a32_uncond(s, insn) ||
10767             disas_vfp_uncond(s, insn) ||
10768             disas_neon_dp(s, insn) ||
10769             disas_neon_ls(s, insn) ||
10770             disas_neon_shared(s, insn)) {
10771             return;
10772         }
10773         /* fall back to legacy decoder */
10774
10775         if (((insn >> 25) & 7) == 1) {
10776             /* NEON Data processing.  */
10777             if (disas_neon_data_insn(s, insn)) {
10778                 goto illegal_op;
10779             }
10780             return;
10781         }
10782         if ((insn & 0x0e000f00) == 0x0c000100) {
10783             if (arm_dc_feature(s, ARM_FEATURE_IWMMXT)) {
10784                 /* iWMMXt register transfer.  */
10785                 if (extract32(s->c15_cpar, 1, 1)) {
10786                     if (!disas_iwmmxt_insn(s, insn)) {
10787                         return;
10788                     }
10789                 }
10790             }
10791         }
10792         goto illegal_op;
10793     }
10794     if (cond != 0xe) {
10795         /* if not always execute, we generate a conditional jump to
10796            next instruction */
10797         arm_skip_unless(s, cond);
10798     }
10799
10800     /* TODO: Perhaps merge these into one decodetree output file.  */
10801     if (disas_a32(s, insn) ||
10802         disas_vfp(s, insn)) {
10803         return;
10804     }
10805     /* fall back to legacy decoder */
10806
10807     switch ((insn >> 24) & 0xf) {
10808     case 0xc:
10809     case 0xd:
10810     case 0xe:
10811         if (((insn >> 8) & 0xe) == 10) {
10812             /* VFP, but failed disas_vfp.  */
10813             goto illegal_op;
10814         }
10815         if (disas_coproc_insn(s, insn)) {
10816             /* Coprocessor.  */
10817             goto illegal_op;
10818         }
10819         break;
10820     default:
10821     illegal_op:
10822         unallocated_encoding(s);
10823         break;
10824     }
10825 }
10826
10827 static bool thumb_insn_is_16bit(DisasContext *s, uint32_t pc, uint32_t insn)
10828 {
10829     /*
10830      * Return true if this is a 16 bit instruction. We must be precise
10831      * about this (matching the decode).
10832      */
10833     if ((insn >> 11) < 0x1d) {
10834         /* Definitely a 16-bit instruction */
10835         return true;
10836     }
10837
10838     /* Top five bits 0b11101 / 0b11110 / 0b11111 : this is the
10839      * first half of a 32-bit Thumb insn. Thumb-1 cores might
10840      * end up actually treating this as two 16-bit insns, though,
10841      * if it's half of a bl/blx pair that might span a page boundary.
10842      */
10843     if (arm_dc_feature(s, ARM_FEATURE_THUMB2) ||
10844         arm_dc_feature(s, ARM_FEATURE_M)) {
10845         /* Thumb2 cores (including all M profile ones) always treat
10846          * 32-bit insns as 32-bit.
10847          */
10848         return false;
10849     }
10850
10851     if ((insn >> 11) == 0x1e && pc - s->page_start < TARGET_PAGE_SIZE - 3) {
10852         /* 0b1111_0xxx_xxxx_xxxx : BL/BLX prefix, and the suffix
10853          * is not on the next page; we merge this into a 32-bit
10854          * insn.
10855          */
10856         return false;
10857     }
10858     /* 0b1110_1xxx_xxxx_xxxx : BLX suffix (or UNDEF);
10859      * 0b1111_1xxx_xxxx_xxxx : BL suffix;
10860      * 0b1111_0xxx_xxxx_xxxx : BL/BLX prefix on the end of a page
10861      *  -- handle as single 16 bit insn
10862      */
10863     return true;
10864 }
10865
10866 /* Translate a 32-bit thumb instruction. */
10867 static void disas_thumb2_insn(DisasContext *s, uint32_t insn)
10868 {
10869     /*
10870      * ARMv6-M supports a limited subset of Thumb2 instructions.
10871      * Other Thumb1 architectures allow only 32-bit
10872      * combined BL/BLX prefix and suffix.
10873      */
10874     if (arm_dc_feature(s, ARM_FEATURE_M) &&
10875         !arm_dc_feature(s, ARM_FEATURE_V7)) {
10876         int i;
10877         bool found = false;
10878         static const uint32_t armv6m_insn[] = {0xf3808000 /* msr */,
10879                                                0xf3b08040 /* dsb */,
10880                                                0xf3b08050 /* dmb */,
10881                                                0xf3b08060 /* isb */,
10882                                                0xf3e08000 /* mrs */,
10883                                                0xf000d000 /* bl */};
10884         static const uint32_t armv6m_mask[] = {0xffe0d000,
10885                                                0xfff0d0f0,
10886                                                0xfff0d0f0,
10887                                                0xfff0d0f0,
10888                                                0xffe0d000,
10889                                                0xf800d000};
10890
10891         for (i = 0; i < ARRAY_SIZE(armv6m_insn); i++) {
10892             if ((insn & armv6m_mask[i]) == armv6m_insn[i]) {
10893                 found = true;
10894                 break;
10895             }
10896         }
10897         if (!found) {
10898             goto illegal_op;
10899         }
10900     } else if ((insn & 0xf800e800) != 0xf000e800)  {
10901         ARCH(6T2);
10902     }
10903
10904     if ((insn & 0xef000000) == 0xef000000) {
10905         /*
10906          * T32 encodings 0b111p_1111_qqqq_qqqq_qqqq_qqqq_qqqq_qqqq
10907          * transform into
10908          * A32 encodings 0b1111_001p_qqqq_qqqq_qqqq_qqqq_qqqq_qqqq
10909          */
10910         uint32_t a32_insn = (insn & 0xe2ffffff) |
10911             ((insn & (1 << 28)) >> 4) | (1 << 28);
10912
10913         if (disas_neon_dp(s, a32_insn)) {
10914             return;
10915         }
10916     }
10917
10918     if ((insn & 0xff100000) == 0xf9000000) {
10919         /*
10920          * T32 encodings 0b1111_1001_ppp0_qqqq_qqqq_qqqq_qqqq_qqqq
10921          * transform into
10922          * A32 encodings 0b1111_0100_ppp0_qqqq_qqqq_qqqq_qqqq_qqqq
10923          */
10924         uint32_t a32_insn = (insn & 0x00ffffff) | 0xf4000000;
10925
10926         if (disas_neon_ls(s, a32_insn)) {
10927             return;
10928         }
10929     }
10930
10931     /*
10932      * TODO: Perhaps merge these into one decodetree output file.
10933      * Note disas_vfp is written for a32 with cond field in the
10934      * top nibble.  The t32 encoding requires 0xe in the top nibble.
10935      */
10936     if (disas_t32(s, insn) ||
10937         disas_vfp_uncond(s, insn) ||
10938         disas_neon_shared(s, insn) ||
10939         ((insn >> 28) == 0xe && disas_vfp(s, insn))) {
10940         return;
10941     }
10942     /* fall back to legacy decoder */
10943
10944     switch ((insn >> 25) & 0xf) {
10945     case 0: case 1: case 2: case 3:
10946         /* 16-bit instructions.  Should never happen.  */
10947         abort();
10948     case 6: case 7: case 14: case 15:
10949         /* Coprocessor.  */
10950         if (arm_dc_feature(s, ARM_FEATURE_M)) {
10951             /* 0b111x_11xx_xxxx_xxxx_xxxx_xxxx_xxxx_xxxx */
10952             if (extract32(insn, 24, 2) == 3) {
10953                 goto illegal_op; /* op0 = 0b11 : unallocated */
10954             }
10955
10956             if (((insn >> 8) & 0xe) == 10 &&
10957                 dc_isar_feature(aa32_fpsp_v2, s)) {
10958                 /* FP, and the CPU supports it */
10959                 goto illegal_op;
10960             } else {
10961                 /* All other insns: NOCP */
10962                 gen_exception_insn(s, s->pc_curr, EXCP_NOCP,
10963                                    syn_uncategorized(),
10964                                    default_exception_el(s));
10965             }
10966             break;
10967         }
10968         if (((insn >> 24) & 3) == 3) {
10969             /* Translate into the equivalent ARM encoding.  */
10970             insn = (insn & 0xe2ffffff) | ((insn & (1 << 28)) >> 4) | (1 << 28);
10971             if (disas_neon_data_insn(s, insn)) {
10972                 goto illegal_op;
10973             }
10974         } else if (((insn >> 8) & 0xe) == 10) {
10975             /* VFP, but failed disas_vfp.  */
10976             goto illegal_op;
10977         } else {
10978             if (insn & (1 << 28))
10979                 goto illegal_op;
10980             if (disas_coproc_insn(s, insn)) {
10981                 goto illegal_op;
10982             }
10983         }
10984         break;
10985     case 12:
10986         goto illegal_op;
10987     default:
10988     illegal_op:
10989         unallocated_encoding(s);
10990     }
10991 }
10992
10993 static void disas_thumb_insn(DisasContext *s, uint32_t insn)
10994 {
10995     if (!disas_t16(s, insn)) {
10996         unallocated_encoding(s);
10997     }
10998 }
10999
11000 static bool insn_crosses_page(CPUARMState *env, DisasContext *s)
11001 {
11002     /* Return true if the insn at dc->base.pc_next might cross a page boundary.
11003      * (False positives are OK, false negatives are not.)
11004      * We know this is a Thumb insn, and our caller ensures we are
11005      * only called if dc->base.pc_next is less than 4 bytes from the page
11006      * boundary, so we cross the page if the first 16 bits indicate
11007      * that this is a 32 bit insn.
11008      */
11009     uint16_t insn = arm_lduw_code(env, s->base.pc_next, s->sctlr_b);
11010
11011     return !thumb_insn_is_16bit(s, s->base.pc_next, insn);
11012 }
11013
11014 static void arm_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
11015 {
11016     DisasContext *dc = container_of(dcbase, DisasContext, base);
11017     CPUARMState *env = cs->env_ptr;
11018     ARMCPU *cpu = env_archcpu(env);
11019     uint32_t tb_flags = dc->base.tb->flags;
11020     uint32_t condexec, core_mmu_idx;
11021
11022     dc->isar = &cpu->isar;
11023     dc->condjmp = 0;
11024
11025     dc->aarch64 = 0;
11026     /* If we are coming from secure EL0 in a system with a 32-bit EL3, then
11027      * there is no secure EL1, so we route exceptions to EL3.
11028      */
11029     dc->secure_routed_to_el3 = arm_feature(env, ARM_FEATURE_EL3) &&
11030                                !arm_el_is_aa64(env, 3);
11031     dc->thumb = FIELD_EX32(tb_flags, TBFLAG_AM32, THUMB);
11032     dc->be_data = FIELD_EX32(tb_flags, TBFLAG_ANY, BE_DATA) ? MO_BE : MO_LE;
11033     condexec = FIELD_EX32(tb_flags, TBFLAG_AM32, CONDEXEC);
11034     dc->condexec_mask = (condexec & 0xf) << 1;
11035     dc->condexec_cond = condexec >> 4;
11036
11037     core_mmu_idx = FIELD_EX32(tb_flags, TBFLAG_ANY, MMUIDX);
11038     dc->mmu_idx = core_to_arm_mmu_idx(env, core_mmu_idx);
11039     dc->current_el = arm_mmu_idx_to_el(dc->mmu_idx);
11040 #if !defined(CONFIG_USER_ONLY)
11041     dc->user = (dc->current_el == 0);
11042 #endif
11043     dc->fp_excp_el = FIELD_EX32(tb_flags, TBFLAG_ANY, FPEXC_EL);
11044
11045     if (arm_feature(env, ARM_FEATURE_M)) {
11046         dc->vfp_enabled = 1;
11047         dc->be_data = MO_TE;
11048         dc->v7m_handler_mode = FIELD_EX32(tb_flags, TBFLAG_M32, HANDLER);
11049         dc->v8m_secure = arm_feature(env, ARM_FEATURE_M_SECURITY) &&
11050             regime_is_secure(env, dc->mmu_idx);
11051         dc->v8m_stackcheck = FIELD_EX32(tb_flags, TBFLAG_M32, STACKCHECK);
11052         dc->v8m_fpccr_s_wrong =
11053             FIELD_EX32(tb_flags, TBFLAG_M32, FPCCR_S_WRONG);
11054         dc->v7m_new_fp_ctxt_needed =
11055             FIELD_EX32(tb_flags, TBFLAG_M32, NEW_FP_CTXT_NEEDED);
11056         dc->v7m_lspact = FIELD_EX32(tb_flags, TBFLAG_M32, LSPACT);
11057     } else {
11058         dc->be_data =
11059             FIELD_EX32(tb_flags, TBFLAG_ANY, BE_DATA) ? MO_BE : MO_LE;
11060         dc->debug_target_el =
11061             FIELD_EX32(tb_flags, TBFLAG_ANY, DEBUG_TARGET_EL);
11062         dc->sctlr_b = FIELD_EX32(tb_flags, TBFLAG_A32, SCTLR_B);
11063         dc->hstr_active = FIELD_EX32(tb_flags, TBFLAG_A32, HSTR_ACTIVE);
11064         dc->ns = FIELD_EX32(tb_flags, TBFLAG_A32, NS);
11065         dc->vfp_enabled = FIELD_EX32(tb_flags, TBFLAG_A32, VFPEN);
11066         if (arm_feature(env, ARM_FEATURE_XSCALE)) {
11067             dc->c15_cpar = FIELD_EX32(tb_flags, TBFLAG_A32, XSCALE_CPAR);
11068         } else {
11069             dc->vec_len = FIELD_EX32(tb_flags, TBFLAG_A32, VECLEN);
11070             dc->vec_stride = FIELD_EX32(tb_flags, TBFLAG_A32, VECSTRIDE);
11071         }
11072     }
11073     dc->cp_regs = cpu->cp_regs;
11074     dc->features = env->features;
11075
11076     /* Single step state. The code-generation logic here is:
11077      *  SS_ACTIVE == 0:
11078      *   generate code with no special handling for single-stepping (except
11079      *   that anything that can make us go to SS_ACTIVE == 1 must end the TB;
11080      *   this happens anyway because those changes are all system register or
11081      *   PSTATE writes).
11082      *  SS_ACTIVE == 1, PSTATE.SS == 1: (active-not-pending)
11083      *   emit code for one insn
11084      *   emit code to clear PSTATE.SS
11085      *   emit code to generate software step exception for completed step
11086      *   end TB (as usual for having generated an exception)
11087      *  SS_ACTIVE == 1, PSTATE.SS == 0: (active-pending)
11088      *   emit code to generate a software step exception
11089      *   end the TB
11090      */
11091     dc->ss_active = FIELD_EX32(tb_flags, TBFLAG_ANY, SS_ACTIVE);
11092     dc->pstate_ss = FIELD_EX32(tb_flags, TBFLAG_ANY, PSTATE_SS);
11093     dc->is_ldex = false;
11094
11095     dc->page_start = dc->base.pc_first & TARGET_PAGE_MASK;
11096
11097     /* If architectural single step active, limit to 1.  */
11098     if (is_singlestepping(dc)) {
11099         dc->base.max_insns = 1;
11100     }
11101
11102     /* ARM is a fixed-length ISA.  Bound the number of insns to execute
11103        to those left on the page.  */
11104     if (!dc->thumb) {
11105         int bound = -(dc->base.pc_first | TARGET_PAGE_MASK) / 4;
11106         dc->base.max_insns = MIN(dc->base.max_insns, bound);
11107     }
11108
11109     cpu_V0 = tcg_temp_new_i64();
11110     cpu_V1 = tcg_temp_new_i64();
11111     /* FIXME: cpu_M0 can probably be the same as cpu_V0.  */
11112     cpu_M0 = tcg_temp_new_i64();
11113 }
11114
11115 static void arm_tr_tb_start(DisasContextBase *dcbase, CPUState *cpu)
11116 {
11117     DisasContext *dc = container_of(dcbase, DisasContext, base);
11118
11119     /* A note on handling of the condexec (IT) bits:
11120      *
11121      * We want to avoid the overhead of having to write the updated condexec
11122      * bits back to the CPUARMState for every instruction in an IT block. So:
11123      * (1) if the condexec bits are not already zero then we write
11124      * zero back into the CPUARMState now. This avoids complications trying
11125      * to do it at the end of the block. (For example if we don't do this
11126      * it's hard to identify whether we can safely skip writing condexec
11127      * at the end of the TB, which we definitely want to do for the case
11128      * where a TB doesn't do anything with the IT state at all.)
11129      * (2) if we are going to leave the TB then we call gen_set_condexec()
11130      * which will write the correct value into CPUARMState if zero is wrong.
11131      * This is done both for leaving the TB at the end, and for leaving
11132      * it because of an exception we know will happen, which is done in
11133      * gen_exception_insn(). The latter is necessary because we need to
11134      * leave the TB with the PC/IT state just prior to execution of the
11135      * instruction which caused the exception.
11136      * (3) if we leave the TB unexpectedly (eg a data abort on a load)
11137      * then the CPUARMState will be wrong and we need to reset it.
11138      * This is handled in the same way as restoration of the
11139      * PC in these situations; we save the value of the condexec bits
11140      * for each PC via tcg_gen_insn_start(), and restore_state_to_opc()
11141      * then uses this to restore them after an exception.
11142      *
11143      * Note that there are no instructions which can read the condexec
11144      * bits, and none which can write non-static values to them, so
11145      * we don't need to care about whether CPUARMState is correct in the
11146      * middle of a TB.
11147      */
11148
11149     /* Reset the conditional execution bits immediately. This avoids
11150        complications trying to do it at the end of the block.  */
11151     if (dc->condexec_mask || dc->condexec_cond) {
11152         TCGv_i32 tmp = tcg_temp_new_i32();
11153         tcg_gen_movi_i32(tmp, 0);
11154         store_cpu_field(tmp, condexec_bits);
11155     }
11156 }
11157
11158 static void arm_tr_insn_start(DisasContextBase *dcbase, CPUState *cpu)
11159 {
11160     DisasContext *dc = container_of(dcbase, DisasContext, base);
11161
11162     tcg_gen_insn_start(dc->base.pc_next,
11163                        (dc->condexec_cond << 4) | (dc->condexec_mask >> 1),
11164                        0);
11165     dc->insn_start = tcg_last_op();
11166 }
11167
11168 static bool arm_tr_breakpoint_check(DisasContextBase *dcbase, CPUState *cpu,
11169                                     const CPUBreakpoint *bp)
11170 {
11171     DisasContext *dc = container_of(dcbase, DisasContext, base);
11172
11173     if (bp->flags & BP_CPU) {
11174         gen_set_condexec(dc);
11175         gen_set_pc_im(dc, dc->base.pc_next);
11176         gen_helper_check_breakpoints(cpu_env);
11177         /* End the TB early; it's likely not going to be executed */
11178         dc->base.is_jmp = DISAS_TOO_MANY;
11179     } else {
11180         gen_exception_internal_insn(dc, dc->base.pc_next, EXCP_DEBUG);
11181         /* The address covered by the breakpoint must be
11182            included in [tb->pc, tb->pc + tb->size) in order
11183            to for it to be properly cleared -- thus we
11184            increment the PC here so that the logic setting
11185            tb->size below does the right thing.  */
11186         /* TODO: Advance PC by correct instruction length to
11187          * avoid disassembler error messages */
11188         dc->base.pc_next += 2;
11189         dc->base.is_jmp = DISAS_NORETURN;
11190     }
11191
11192     return true;
11193 }
11194
11195 static bool arm_pre_translate_insn(DisasContext *dc)
11196 {
11197 #ifdef CONFIG_USER_ONLY
11198     /* Intercept jump to the magic kernel page.  */
11199     if (dc->base.pc_next >= 0xffff0000) {
11200         /* We always get here via a jump, so know we are not in a
11201            conditional execution block.  */
11202         gen_exception_internal(EXCP_KERNEL_TRAP);
11203         dc->base.is_jmp = DISAS_NORETURN;
11204         return true;
11205     }
11206 #endif
11207
11208     if (dc->ss_active && !dc->pstate_ss) {
11209         /* Singlestep state is Active-pending.
11210          * If we're in this state at the start of a TB then either
11211          *  a) we just took an exception to an EL which is being debugged
11212          *     and this is the first insn in the exception handler
11213          *  b) debug exceptions were masked and we just unmasked them
11214          *     without changing EL (eg by clearing PSTATE.D)
11215          * In either case we're going to take a swstep exception in the
11216          * "did not step an insn" case, and so the syndrome ISV and EX
11217          * bits should be zero.
11218          */
11219         assert(dc->base.num_insns == 1);
11220         gen_swstep_exception(dc, 0, 0);
11221         dc->base.is_jmp = DISAS_NORETURN;
11222         return true;
11223     }
11224
11225     return false;
11226 }
11227
11228 static void arm_post_translate_insn(DisasContext *dc)
11229 {
11230     if (dc->condjmp && !dc->base.is_jmp) {
11231         gen_set_label(dc->condlabel);
11232         dc->condjmp = 0;
11233     }
11234     translator_loop_temp_check(&dc->base);
11235 }
11236
11237 static void arm_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
11238 {
11239     DisasContext *dc = container_of(dcbase, DisasContext, base);
11240     CPUARMState *env = cpu->env_ptr;
11241     unsigned int insn;
11242
11243     if (arm_pre_translate_insn(dc)) {
11244         return;
11245     }
11246
11247     dc->pc_curr = dc->base.pc_next;
11248     insn = arm_ldl_code(env, dc->base.pc_next, dc->sctlr_b);
11249     dc->insn = insn;
11250     dc->base.pc_next += 4;
11251     disas_arm_insn(dc, insn);
11252
11253     arm_post_translate_insn(dc);
11254
11255     /* ARM is a fixed-length ISA.  We performed the cross-page check
11256        in init_disas_context by adjusting max_insns.  */
11257 }
11258
11259 static bool thumb_insn_is_unconditional(DisasContext *s, uint32_t insn)
11260 {
11261     /* Return true if this Thumb insn is always unconditional,
11262      * even inside an IT block. This is true of only a very few
11263      * instructions: BKPT, HLT, and SG.
11264      *
11265      * A larger class of instructions are UNPREDICTABLE if used
11266      * inside an IT block; we do not need to detect those here, because
11267      * what we do by default (perform the cc check and update the IT
11268      * bits state machine) is a permitted CONSTRAINED UNPREDICTABLE
11269      * choice for those situations.
11270      *
11271      * insn is either a 16-bit or a 32-bit instruction; the two are
11272      * distinguishable because for the 16-bit case the top 16 bits
11273      * are zeroes, and that isn't a valid 32-bit encoding.
11274      */
11275     if ((insn & 0xffffff00) == 0xbe00) {
11276         /* BKPT */
11277         return true;
11278     }
11279
11280     if ((insn & 0xffffffc0) == 0xba80 && arm_dc_feature(s, ARM_FEATURE_V8) &&
11281         !arm_dc_feature(s, ARM_FEATURE_M)) {
11282         /* HLT: v8A only. This is unconditional even when it is going to
11283          * UNDEF; see the v8A ARM ARM DDI0487B.a H3.3.
11284          * For v7 cores this was a plain old undefined encoding and so
11285          * honours its cc check. (We might be using the encoding as
11286          * a semihosting trap, but we don't change the cc check behaviour
11287          * on that account, because a debugger connected to a real v7A
11288          * core and emulating semihosting traps by catching the UNDEF
11289          * exception would also only see cases where the cc check passed.
11290          * No guest code should be trying to do a HLT semihosting trap
11291          * in an IT block anyway.
11292          */
11293         return true;
11294     }
11295
11296     if (insn == 0xe97fe97f && arm_dc_feature(s, ARM_FEATURE_V8) &&
11297         arm_dc_feature(s, ARM_FEATURE_M)) {
11298         /* SG: v8M only */
11299         return true;
11300     }
11301
11302     return false;
11303 }
11304
11305 static void thumb_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
11306 {
11307     DisasContext *dc = container_of(dcbase, DisasContext, base);
11308     CPUARMState *env = cpu->env_ptr;
11309     uint32_t insn;
11310     bool is_16bit;
11311
11312     if (arm_pre_translate_insn(dc)) {
11313         return;
11314     }
11315
11316     dc->pc_curr = dc->base.pc_next;
11317     insn = arm_lduw_code(env, dc->base.pc_next, dc->sctlr_b);
11318     is_16bit = thumb_insn_is_16bit(dc, dc->base.pc_next, insn);
11319     dc->base.pc_next += 2;
11320     if (!is_16bit) {
11321         uint32_t insn2 = arm_lduw_code(env, dc->base.pc_next, dc->sctlr_b);
11322
11323         insn = insn << 16 | insn2;
11324         dc->base.pc_next += 2;
11325     }
11326     dc->insn = insn;
11327
11328     if (dc->condexec_mask && !thumb_insn_is_unconditional(dc, insn)) {
11329         uint32_t cond = dc->condexec_cond;
11330
11331         /*
11332          * Conditionally skip the insn. Note that both 0xe and 0xf mean
11333          * "always"; 0xf is not "never".
11334          */
11335         if (cond < 0x0e) {
11336             arm_skip_unless(dc, cond);
11337         }
11338     }
11339
11340     if (is_16bit) {
11341         disas_thumb_insn(dc, insn);
11342     } else {
11343         disas_thumb2_insn(dc, insn);
11344     }
11345
11346     /* Advance the Thumb condexec condition.  */
11347     if (dc->condexec_mask) {
11348         dc->condexec_cond = ((dc->condexec_cond & 0xe) |
11349                              ((dc->condexec_mask >> 4) & 1));
11350         dc->condexec_mask = (dc->condexec_mask << 1) & 0x1f;
11351         if (dc->condexec_mask == 0) {
11352             dc->condexec_cond = 0;
11353         }
11354     }
11355
11356     arm_post_translate_insn(dc);
11357
11358     /* Thumb is a variable-length ISA.  Stop translation when the next insn
11359      * will touch a new page.  This ensures that prefetch aborts occur at
11360      * the right place.
11361      *
11362      * We want to stop the TB if the next insn starts in a new page,
11363      * or if it spans between this page and the next. This means that
11364      * if we're looking at the last halfword in the page we need to
11365      * see if it's a 16-bit Thumb insn (which will fit in this TB)
11366      * or a 32-bit Thumb insn (which won't).
11367      * This is to avoid generating a silly TB with a single 16-bit insn
11368      * in it at the end of this page (which would execute correctly
11369      * but isn't very efficient).
11370      */
11371     if (dc->base.is_jmp == DISAS_NEXT
11372         && (dc->base.pc_next - dc->page_start >= TARGET_PAGE_SIZE
11373             || (dc->base.pc_next - dc->page_start >= TARGET_PAGE_SIZE - 3
11374                 && insn_crosses_page(env, dc)))) {
11375         dc->base.is_jmp = DISAS_TOO_MANY;
11376     }
11377 }
11378
11379 static void arm_tr_tb_stop(DisasContextBase *dcbase, CPUState *cpu)
11380 {
11381     DisasContext *dc = container_of(dcbase, DisasContext, base);
11382
11383     if (tb_cflags(dc->base.tb) & CF_LAST_IO && dc->condjmp) {
11384         /* FIXME: This can theoretically happen with self-modifying code. */
11385         cpu_abort(cpu, "IO on conditional branch instruction");
11386     }
11387
11388     /* At this stage dc->condjmp will only be set when the skipped
11389        instruction was a conditional branch or trap, and the PC has
11390        already been written.  */
11391     gen_set_condexec(dc);
11392     if (dc->base.is_jmp == DISAS_BX_EXCRET) {
11393         /* Exception return branches need some special case code at the
11394          * end of the TB, which is complex enough that it has to
11395          * handle the single-step vs not and the condition-failed
11396          * insn codepath itself.
11397          */
11398         gen_bx_excret_final_code(dc);
11399     } else if (unlikely(is_singlestepping(dc))) {
11400         /* Unconditional and "condition passed" instruction codepath. */
11401         switch (dc->base.is_jmp) {
11402         case DISAS_SWI:
11403             gen_ss_advance(dc);
11404             gen_exception(EXCP_SWI, syn_aa32_svc(dc->svc_imm, dc->thumb),
11405                           default_exception_el(dc));
11406             break;
11407         case DISAS_HVC:
11408             gen_ss_advance(dc);
11409             gen_exception(EXCP_HVC, syn_aa32_hvc(dc->svc_imm), 2);
11410             break;
11411         case DISAS_SMC:
11412             gen_ss_advance(dc);
11413             gen_exception(EXCP_SMC, syn_aa32_smc(), 3);
11414             break;
11415         case DISAS_NEXT:
11416         case DISAS_TOO_MANY:
11417         case DISAS_UPDATE:
11418             gen_set_pc_im(dc, dc->base.pc_next);
11419             /* fall through */
11420         default:
11421             /* FIXME: Single stepping a WFI insn will not halt the CPU. */
11422             gen_singlestep_exception(dc);
11423             break;
11424         case DISAS_NORETURN:
11425             break;
11426         }
11427     } else {
11428         /* While branches must always occur at the end of an IT block,
11429            there are a few other things that can cause us to terminate
11430            the TB in the middle of an IT block:
11431             - Exception generating instructions (bkpt, swi, undefined).
11432             - Page boundaries.
11433             - Hardware watchpoints.
11434            Hardware breakpoints have already been handled and skip this code.
11435          */
11436         switch(dc->base.is_jmp) {
11437         case DISAS_NEXT:
11438         case DISAS_TOO_MANY:
11439             gen_goto_tb(dc, 1, dc->base.pc_next);
11440             break;
11441         case DISAS_JUMP:
11442             gen_goto_ptr();
11443             break;
11444         case DISAS_UPDATE:
11445             gen_set_pc_im(dc, dc->base.pc_next);
11446             /* fall through */
11447         default:
11448             /* indicate that the hash table must be used to find the next TB */
11449             tcg_gen_exit_tb(NULL, 0);
11450             break;
11451         case DISAS_NORETURN:
11452             /* nothing more to generate */
11453             break;
11454         case DISAS_WFI:
11455         {
11456             TCGv_i32 tmp = tcg_const_i32((dc->thumb &&
11457                                           !(dc->insn & (1U << 31))) ? 2 : 4);
11458
11459             gen_helper_wfi(cpu_env, tmp);
11460             tcg_temp_free_i32(tmp);
11461             /* The helper doesn't necessarily throw an exception, but we
11462              * must go back to the main loop to check for interrupts anyway.
11463              */
11464             tcg_gen_exit_tb(NULL, 0);
11465             break;
11466         }
11467         case DISAS_WFE:
11468             gen_helper_wfe(cpu_env);
11469             break;
11470         case DISAS_YIELD:
11471             gen_helper_yield(cpu_env);
11472             break;
11473         case DISAS_SWI:
11474             gen_exception(EXCP_SWI, syn_aa32_svc(dc->svc_imm, dc->thumb),
11475                           default_exception_el(dc));
11476             break;
11477         case DISAS_HVC:
11478             gen_exception(EXCP_HVC, syn_aa32_hvc(dc->svc_imm), 2);
11479             break;
11480         case DISAS_SMC:
11481             gen_exception(EXCP_SMC, syn_aa32_smc(), 3);
11482             break;
11483         }
11484     }
11485
11486     if (dc->condjmp) {
11487         /* "Condition failed" instruction codepath for the branch/trap insn */
11488         gen_set_label(dc->condlabel);
11489         gen_set_condexec(dc);
11490         if (unlikely(is_singlestepping(dc))) {
11491             gen_set_pc_im(dc, dc->base.pc_next);
11492             gen_singlestep_exception(dc);
11493         } else {
11494             gen_goto_tb(dc, 1, dc->base.pc_next);
11495         }
11496     }
11497 }
11498
11499 static void arm_tr_disas_log(const DisasContextBase *dcbase, CPUState *cpu)
11500 {
11501     DisasContext *dc = container_of(dcbase, DisasContext, base);
11502
11503     qemu_log("IN: %s\n", lookup_symbol(dc->base.pc_first));
11504     log_target_disas(cpu, dc->base.pc_first, dc->base.tb->size);
11505 }
11506
11507 static const TranslatorOps arm_translator_ops = {
11508     .init_disas_context = arm_tr_init_disas_context,
11509     .tb_start           = arm_tr_tb_start,
11510     .insn_start         = arm_tr_insn_start,
11511     .breakpoint_check   = arm_tr_breakpoint_check,
11512     .translate_insn     = arm_tr_translate_insn,
11513     .tb_stop            = arm_tr_tb_stop,
11514     .disas_log          = arm_tr_disas_log,
11515 };
11516
11517 static const TranslatorOps thumb_translator_ops = {
11518     .init_disas_context = arm_tr_init_disas_context,
11519     .tb_start           = arm_tr_tb_start,
11520     .insn_start         = arm_tr_insn_start,
11521     .breakpoint_check   = arm_tr_breakpoint_check,
11522     .translate_insn     = thumb_tr_translate_insn,
11523     .tb_stop            = arm_tr_tb_stop,
11524     .disas_log          = arm_tr_disas_log,
11525 };
11526
11527 /* generate intermediate code for basic block 'tb'.  */
11528 void gen_intermediate_code(CPUState *cpu, TranslationBlock *tb, int max_insns)
11529 {
11530     DisasContext dc = { };
11531     const TranslatorOps *ops = &arm_translator_ops;
11532
11533     if (FIELD_EX32(tb->flags, TBFLAG_AM32, THUMB)) {
11534         ops = &thumb_translator_ops;
11535     }
11536 #ifdef TARGET_AARCH64
11537     if (FIELD_EX32(tb->flags, TBFLAG_ANY, AARCH64_STATE)) {
11538         ops = &aarch64_translator_ops;
11539     }
11540 #endif
11541
11542     translator_loop(ops, &dc.base, cpu, tb, max_insns);
11543 }
11544
11545 void restore_state_to_opc(CPUARMState *env, TranslationBlock *tb,
11546                           target_ulong *data)
11547 {
11548     if (is_a64(env)) {
11549         env->pc = data[0];
11550         env->condexec_bits = 0;
11551         env->exception.syndrome = data[2] << ARM_INSN_START_WORD2_SHIFT;
11552     } else {
11553         env->regs[15] = data[0];
11554         env->condexec_bits = data[1];
11555         env->exception.syndrome = data[2] << ARM_INSN_START_WORD2_SHIFT;
11556     }
11557 }