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