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