target-arm/translate.c

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