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