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