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