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