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