target-arm/translate-a64.c

   1 /*
   2  *  AArch64 translation
   3  *
   4  *  Copyright (c) 2013 Alexander Graf <agraf@suse.de>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include <stdarg.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <inttypes.h>
  24
  25 #include "cpu.h"
  26 #include "tcg-op.h"
  27 #include "qemu/log.h"
  28 #include "translate.h"
  29 #include "internals.h"
  30 #include "qemu/host-utils.h"
  31
  32 #include "exec/gen-icount.h"
  33
  34 #include "helper.h"
  35 #define GEN_HELPER 1
  36 #include "helper.h"
  37
  38 static TCGv_i64 cpu_X[32];
  39 static TCGv_i64 cpu_pc;
  40 static TCGv_i32 cpu_NF, cpu_ZF, cpu_CF, cpu_VF;
  41
  42 /* Load/store exclusive handling */
  43 static TCGv_i64 cpu_exclusive_addr;
  44 static TCGv_i64 cpu_exclusive_val;
  45 static TCGv_i64 cpu_exclusive_high;
  46 #ifdef CONFIG_USER_ONLY
  47 static TCGv_i64 cpu_exclusive_test;
  48 static TCGv_i32 cpu_exclusive_info;
  49 #endif
  50
  51 static const char *regnames[] = {
  52     "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
  53     "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
  54     "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
  55     "x24", "x25", "x26", "x27", "x28", "x29", "lr", "sp"
  56 };
  57
  58 enum a64_shift_type {
  59     A64_SHIFT_TYPE_LSL = 0,
  60     A64_SHIFT_TYPE_LSR = 1,
  61     A64_SHIFT_TYPE_ASR = 2,
  62     A64_SHIFT_TYPE_ROR = 3
  63 };
  64
  65 /* Table based decoder typedefs - used when the relevant bits for decode
  66  * are too awkwardly scattered across the instruction (eg SIMD).
  67  */
  68 typedef void AArch64DecodeFn(DisasContext *s, uint32_t insn);
  69
  70 typedef struct AArch64DecodeTable {
  71     uint32_t pattern;
  72     uint32_t mask;
  73     AArch64DecodeFn *disas_fn;
  74 } AArch64DecodeTable;
  75
  76 /* Function prototype for gen_ functions for calling Neon helpers */
  77 typedef void NeonGenOneOpEnvFn(TCGv_i32, TCGv_ptr, TCGv_i32);
  78 typedef void NeonGenTwoOpFn(TCGv_i32, TCGv_i32, TCGv_i32);
  79 typedef void NeonGenTwoOpEnvFn(TCGv_i32, TCGv_ptr, TCGv_i32, TCGv_i32);
  80 typedef void NeonGenTwo64OpFn(TCGv_i64, TCGv_i64, TCGv_i64);
  81 typedef void NeonGenTwo64OpEnvFn(TCGv_i64, TCGv_ptr, TCGv_i64, TCGv_i64);
  82 typedef void NeonGenNarrowFn(TCGv_i32, TCGv_i64);
  83 typedef void NeonGenNarrowEnvFn(TCGv_i32, TCGv_ptr, TCGv_i64);
  84 typedef void NeonGenWidenFn(TCGv_i64, TCGv_i32);
  85 typedef void NeonGenTwoSingleOPFn(TCGv_i32, TCGv_i32, TCGv_i32, TCGv_ptr);
  86 typedef void NeonGenTwoDoubleOPFn(TCGv_i64, TCGv_i64, TCGv_i64, TCGv_ptr);
  87 typedef void NeonGenOneOpFn(TCGv_i64, TCGv_i64);
  88
  89 /* initialize TCG globals.  */
  90 void a64_translate_init(void)
  91 {
  92     int i;
  93
  94     cpu_pc = tcg_global_mem_new_i64(TCG_AREG0,
  95                                     offsetof(CPUARMState, pc),
  96                                     "pc");
  97     for (i = 0; i < 32; i++) {
  98         cpu_X[i] = tcg_global_mem_new_i64(TCG_AREG0,
  99                                           offsetof(CPUARMState, xregs[i]),
 100                                           regnames[i]);
 101     }
 102
 103     cpu_NF = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUARMState, NF), "NF");
 104     cpu_ZF = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUARMState, ZF), "ZF");
 105     cpu_CF = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUARMState, CF), "CF");
 106     cpu_VF = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUARMState, VF), "VF");
 107
 108     cpu_exclusive_addr = tcg_global_mem_new_i64(TCG_AREG0,
 109         offsetof(CPUARMState, exclusive_addr), "exclusive_addr");
 110     cpu_exclusive_val = tcg_global_mem_new_i64(TCG_AREG0,
 111         offsetof(CPUARMState, exclusive_val), "exclusive_val");
 112     cpu_exclusive_high = tcg_global_mem_new_i64(TCG_AREG0,
 113         offsetof(CPUARMState, exclusive_high), "exclusive_high");
 114 #ifdef CONFIG_USER_ONLY
 115     cpu_exclusive_test = tcg_global_mem_new_i64(TCG_AREG0,
 116         offsetof(CPUARMState, exclusive_test), "exclusive_test");
 117     cpu_exclusive_info = tcg_global_mem_new_i32(TCG_AREG0,
 118         offsetof(CPUARMState, exclusive_info), "exclusive_info");
 119 #endif
 120 }
 121
 122 void aarch64_cpu_dump_state(CPUState *cs, FILE *f,
 123                             fprintf_function cpu_fprintf, int flags)
 124 {
 125     ARMCPU *cpu = ARM_CPU(cs);
 126     CPUARMState *env = &cpu->env;
 127     uint32_t psr = pstate_read(env);
 128     int i;
 129
 130     cpu_fprintf(f, "PC=%016"PRIx64"  SP=%016"PRIx64"\n",
 131             env->pc, env->xregs[31]);
 132     for (i = 0; i < 31; i++) {
 133         cpu_fprintf(f, "X%02d=%016"PRIx64, i, env->xregs[i]);
 134         if ((i % 4) == 3) {
 135             cpu_fprintf(f, "\n");
 136         } else {
 137             cpu_fprintf(f, " ");
 138         }
 139     }
 140     cpu_fprintf(f, "PSTATE=%08x (flags %c%c%c%c)\n",
 141                 psr,
 142                 psr & PSTATE_N ? 'N' : '-',
 143                 psr & PSTATE_Z ? 'Z' : '-',
 144                 psr & PSTATE_C ? 'C' : '-',
 145                 psr & PSTATE_V ? 'V' : '-');
 146     cpu_fprintf(f, "\n");
 147
 148     if (flags & CPU_DUMP_FPU) {
 149         int numvfpregs = 32;
 150         for (i = 0; i < numvfpregs; i += 2) {
 151             uint64_t vlo = float64_val(env->vfp.regs[i * 2]);
 152             uint64_t vhi = float64_val(env->vfp.regs[(i * 2) + 1]);
 153             cpu_fprintf(f, "q%02d=%016" PRIx64 ":%016" PRIx64 " ",
 154                         i, vhi, vlo);
 155             vlo = float64_val(env->vfp.regs[(i + 1) * 2]);
 156             vhi = float64_val(env->vfp.regs[((i + 1) * 2) + 1]);
 157             cpu_fprintf(f, "q%02d=%016" PRIx64 ":%016" PRIx64 "\n",
 158                         i + 1, vhi, vlo);
 159         }
 160         cpu_fprintf(f, "FPCR: %08x  FPSR: %08x\n",
 161                     vfp_get_fpcr(env), vfp_get_fpsr(env));
 162     }
 163 }
 164
 165 void gen_a64_set_pc_im(uint64_t val)
 166 {
 167     tcg_gen_movi_i64(cpu_pc, val);
 168 }
 169
 170 static void gen_exception_internal(int excp)
 171 {
 172     TCGv_i32 tcg_excp = tcg_const_i32(excp);
 173
 174     assert(excp_is_internal(excp));
 175     gen_helper_exception_internal(cpu_env, tcg_excp);
 176     tcg_temp_free_i32(tcg_excp);
 177 }
 178
 179 static void gen_exception(int excp, uint32_t syndrome)
 180 {
 181     TCGv_i32 tcg_excp = tcg_const_i32(excp);
 182     TCGv_i32 tcg_syn = tcg_const_i32(syndrome);
 183
 184     gen_helper_exception_with_syndrome(cpu_env, tcg_excp, tcg_syn);
 185     tcg_temp_free_i32(tcg_syn);
 186     tcg_temp_free_i32(tcg_excp);
 187 }
 188
 189 static void gen_exception_internal_insn(DisasContext *s, int offset, int excp)
 190 {
 191     gen_a64_set_pc_im(s->pc - offset);
 192     gen_exception_internal(excp);
 193     s->is_jmp = DISAS_EXC;
 194 }
 195
 196 static void gen_exception_insn(DisasContext *s, int offset, int excp,
 197                                uint32_t syndrome)
 198 {
 199     gen_a64_set_pc_im(s->pc - offset);
 200     gen_exception(excp, syndrome);
 201     s->is_jmp = DISAS_EXC;
 202 }
 203
 204 static inline bool use_goto_tb(DisasContext *s, int n, uint64_t dest)
 205 {
 206     /* No direct tb linking with singlestep or deterministic io */
 207     if (s->singlestep_enabled || (s->tb->cflags & CF_LAST_IO)) {
 208         return false;
 209     }
 210
 211     /* Only link tbs from inside the same guest page */
 212     if ((s->tb->pc & TARGET_PAGE_MASK) != (dest & TARGET_PAGE_MASK)) {
 213         return false;
 214     }
 215
 216     return true;
 217 }
 218
 219 static inline void gen_goto_tb(DisasContext *s, int n, uint64_t dest)
 220 {
 221     TranslationBlock *tb;
 222
 223     tb = s->tb;
 224     if (use_goto_tb(s, n, dest)) {
 225         tcg_gen_goto_tb(n);
 226         gen_a64_set_pc_im(dest);
 227         tcg_gen_exit_tb((intptr_t)tb + n);
 228         s->is_jmp = DISAS_TB_JUMP;
 229     } else {
 230         gen_a64_set_pc_im(dest);
 231         if (s->singlestep_enabled) {
 232             gen_exception_internal(EXCP_DEBUG);
 233         }
 234         tcg_gen_exit_tb(0);
 235         s->is_jmp = DISAS_JUMP;
 236     }
 237 }
 238
 239 static void unallocated_encoding(DisasContext *s)
 240 {
 241     /* Unallocated and reserved encodings are uncategorized */
 242     gen_exception_insn(s, 4, EXCP_UDEF, syn_uncategorized());
 243 }
 244
 245 #define unsupported_encoding(s, insn)                                    \
 246     do {                                                                 \
 247         qemu_log_mask(LOG_UNIMP,                                         \
 248                       "%s:%d: unsupported instruction encoding 0x%08x "  \
 249                       "at pc=%016" PRIx64 "\n",                          \
 250                       __FILE__, __LINE__, insn, s->pc - 4);              \
 251         unallocated_encoding(s);                                         \
 252     } while (0);
 253
 254 static void init_tmp_a64_array(DisasContext *s)
 255 {
 256 #ifdef CONFIG_DEBUG_TCG
 257     int i;
 258     for (i = 0; i < ARRAY_SIZE(s->tmp_a64); i++) {
 259         TCGV_UNUSED_I64(s->tmp_a64[i]);
 260     }
 261 #endif
 262     s->tmp_a64_count = 0;
 263 }
 264
 265 static void free_tmp_a64(DisasContext *s)
 266 {
 267     int i;
 268     for (i = 0; i < s->tmp_a64_count; i++) {
 269         tcg_temp_free_i64(s->tmp_a64[i]);
 270     }
 271     init_tmp_a64_array(s);
 272 }
 273
 274 static TCGv_i64 new_tmp_a64(DisasContext *s)
 275 {
 276     assert(s->tmp_a64_count < TMP_A64_MAX);
 277     return s->tmp_a64[s->tmp_a64_count++] = tcg_temp_new_i64();
 278 }
 279
 280 static TCGv_i64 new_tmp_a64_zero(DisasContext *s)
 281 {
 282     TCGv_i64 t = new_tmp_a64(s);
 283     tcg_gen_movi_i64(t, 0);
 284     return t;
 285 }
 286
 287 /*
 288  * Register access functions
 289  *
 290  * These functions are used for directly accessing a register in where
 291  * changes to the final register value are likely to be made. If you
 292  * need to use a register for temporary calculation (e.g. index type
 293  * operations) use the read_* form.
 294  *
 295  * B1.2.1 Register mappings
 296  *
 297  * In instruction register encoding 31 can refer to ZR (zero register) or
 298  * the SP (stack pointer) depending on context. In QEMU's case we map SP
 299  * to cpu_X[31] and ZR accesses to a temporary which can be discarded.
 300  * This is the point of the _sp forms.
 301  */
 302 static TCGv_i64 cpu_reg(DisasContext *s, int reg)
 303 {
 304     if (reg == 31) {
 305         return new_tmp_a64_zero(s);
 306     } else {
 307         return cpu_X[reg];
 308     }
 309 }
 310
 311 /* register access for when 31 == SP */
 312 static TCGv_i64 cpu_reg_sp(DisasContext *s, int reg)
 313 {
 314     return cpu_X[reg];
 315 }
 316
 317 /* read a cpu register in 32bit/64bit mode. Returns a TCGv_i64
 318  * representing the register contents. This TCGv is an auto-freed
 319  * temporary so it need not be explicitly freed, and may be modified.
 320  */
 321 static TCGv_i64 read_cpu_reg(DisasContext *s, int reg, int sf)
 322 {
 323     TCGv_i64 v = new_tmp_a64(s);
 324     if (reg != 31) {
 325         if (sf) {
 326             tcg_gen_mov_i64(v, cpu_X[reg]);
 327         } else {
 328             tcg_gen_ext32u_i64(v, cpu_X[reg]);
 329         }
 330     } else {
 331         tcg_gen_movi_i64(v, 0);
 332     }
 333     return v;
 334 }
 335
 336 static TCGv_i64 read_cpu_reg_sp(DisasContext *s, int reg, int sf)
 337 {
 338     TCGv_i64 v = new_tmp_a64(s);
 339     if (sf) {
 340         tcg_gen_mov_i64(v, cpu_X[reg]);
 341     } else {
 342         tcg_gen_ext32u_i64(v, cpu_X[reg]);
 343     }
 344     return v;
 345 }
 346
 347 /* We should have at some point before trying to access an FP register
 348  * done the necessary access check, so assert that
 349  * (a) we did the check and
 350  * (b) we didn't then just plough ahead anyway if it failed.
 351  * Print the instruction pattern in the abort message so we can figure
 352  * out what we need to fix if a user encounters this problem in the wild.
 353  */
 354 static inline void assert_fp_access_checked(DisasContext *s)
 355 {
 356 #ifdef CONFIG_DEBUG_TCG
 357     if (unlikely(!s->fp_access_checked || !s->cpacr_fpen)) {
 358         fprintf(stderr, "target-arm: FP access check missing for "
 359                 "instruction 0x%08x\n", s->insn);
 360         abort();
 361     }
 362 #endif
 363 }
 364
 365 /* Return the offset into CPUARMState of an element of specified
 366  * size, 'element' places in from the least significant end of
 367  * the FP/vector register Qn.
 368  */
 369 static inline int vec_reg_offset(DisasContext *s, int regno,
 370                                  int element, TCGMemOp size)
 371 {
 372     int offs = offsetof(CPUARMState, vfp.regs[regno * 2]);
 373 #ifdef HOST_WORDS_BIGENDIAN
 374     /* This is complicated slightly because vfp.regs[2n] is
 375      * still the low half and  vfp.regs[2n+1] the high half
 376      * of the 128 bit vector, even on big endian systems.
 377      * Calculate the offset assuming a fully bigendian 128 bits,
 378      * then XOR to account for the order of the two 64 bit halves.
 379      */
 380     offs += (16 - ((element + 1) * (1 << size)));
 381     offs ^= 8;
 382 #else
 383     offs += element * (1 << size);
 384 #endif
 385     assert_fp_access_checked(s);
 386     return offs;
 387 }
 388
 389 /* Return the offset into CPUARMState of a slice (from
 390  * the least significant end) of FP register Qn (ie
 391  * Dn, Sn, Hn or Bn).
 392  * (Note that this is not the same mapping as for A32; see cpu.h)
 393  */
 394 static inline int fp_reg_offset(DisasContext *s, int regno, TCGMemOp size)
 395 {
 396     int offs = offsetof(CPUARMState, vfp.regs[regno * 2]);
 397 #ifdef HOST_WORDS_BIGENDIAN
 398     offs += (8 - (1 << size));
 399 #endif
 400     assert_fp_access_checked(s);
 401     return offs;
 402 }
 403
 404 /* Offset of the high half of the 128 bit vector Qn */
 405 static inline int fp_reg_hi_offset(DisasContext *s, int regno)
 406 {
 407     assert_fp_access_checked(s);
 408     return offsetof(CPUARMState, vfp.regs[regno * 2 + 1]);
 409 }
 410
 411 /* Convenience accessors for reading and writing single and double
 412  * FP registers. Writing clears the upper parts of the associated
 413  * 128 bit vector register, as required by the architecture.
 414  * Note that unlike the GP register accessors, the values returned
 415  * by the read functions must be manually freed.
 416  */
 417 static TCGv_i64 read_fp_dreg(DisasContext *s, int reg)
 418 {
 419     TCGv_i64 v = tcg_temp_new_i64();
 420
 421     tcg_gen_ld_i64(v, cpu_env, fp_reg_offset(s, reg, MO_64));
 422     return v;
 423 }
 424
 425 static TCGv_i32 read_fp_sreg(DisasContext *s, int reg)
 426 {
 427     TCGv_i32 v = tcg_temp_new_i32();
 428
 429     tcg_gen_ld_i32(v, cpu_env, fp_reg_offset(s, reg, MO_32));
 430     return v;
 431 }
 432
 433 static void write_fp_dreg(DisasContext *s, int reg, TCGv_i64 v)
 434 {
 435     TCGv_i64 tcg_zero = tcg_const_i64(0);
 436
 437     tcg_gen_st_i64(v, cpu_env, fp_reg_offset(s, reg, MO_64));
 438     tcg_gen_st_i64(tcg_zero, cpu_env, fp_reg_hi_offset(s, reg));
 439     tcg_temp_free_i64(tcg_zero);
 440 }
 441
 442 static void write_fp_sreg(DisasContext *s, int reg, TCGv_i32 v)
 443 {
 444     TCGv_i64 tmp = tcg_temp_new_i64();
 445
 446     tcg_gen_extu_i32_i64(tmp, v);
 447     write_fp_dreg(s, reg, tmp);
 448     tcg_temp_free_i64(tmp);
 449 }
 450
 451 static TCGv_ptr get_fpstatus_ptr(void)
 452 {
 453     TCGv_ptr statusptr = tcg_temp_new_ptr();
 454     int offset;
 455
 456     /* In A64 all instructions (both FP and Neon) use the FPCR;
 457      * there is no equivalent of the A32 Neon "standard FPSCR value"
 458      * and all operations use vfp.fp_status.
 459      */
 460     offset = offsetof(CPUARMState, vfp.fp_status);
 461     tcg_gen_addi_ptr(statusptr, cpu_env, offset);
 462     return statusptr;
 463 }
 464
 465 /* Set ZF and NF based on a 64 bit result. This is alas fiddlier
 466  * than the 32 bit equivalent.
 467  */
 468 static inline void gen_set_NZ64(TCGv_i64 result)
 469 {
 470     TCGv_i64 flag = tcg_temp_new_i64();
 471
 472     tcg_gen_setcondi_i64(TCG_COND_NE, flag, result, 0);
 473     tcg_gen_trunc_i64_i32(cpu_ZF, flag);
 474     tcg_gen_shri_i64(flag, result, 32);
 475     tcg_gen_trunc_i64_i32(cpu_NF, flag);
 476     tcg_temp_free_i64(flag);
 477 }
 478
 479 /* Set NZCV as for a logical operation: NZ as per result, CV cleared. */
 480 static inline void gen_logic_CC(int sf, TCGv_i64 result)
 481 {
 482     if (sf) {
 483         gen_set_NZ64(result);
 484     } else {
 485         tcg_gen_trunc_i64_i32(cpu_ZF, result);
 486         tcg_gen_trunc_i64_i32(cpu_NF, result);
 487     }
 488     tcg_gen_movi_i32(cpu_CF, 0);
 489     tcg_gen_movi_i32(cpu_VF, 0);
 490 }
 491
 492 /* dest = T0 + T1; compute C, N, V and Z flags */
 493 static void gen_add_CC(int sf, TCGv_i64 dest, TCGv_i64 t0, TCGv_i64 t1)
 494 {
 495     if (sf) {
 496         TCGv_i64 result, flag, tmp;
 497         result = tcg_temp_new_i64();
 498         flag = tcg_temp_new_i64();
 499         tmp = tcg_temp_new_i64();
 500
 501         tcg_gen_movi_i64(tmp, 0);
 502         tcg_gen_add2_i64(result, flag, t0, tmp, t1, tmp);
 503
 504         tcg_gen_trunc_i64_i32(cpu_CF, flag);
 505
 506         gen_set_NZ64(result);
 507
 508         tcg_gen_xor_i64(flag, result, t0);
 509         tcg_gen_xor_i64(tmp, t0, t1);
 510         tcg_gen_andc_i64(flag, flag, tmp);
 511         tcg_temp_free_i64(tmp);
 512         tcg_gen_shri_i64(flag, flag, 32);
 513         tcg_gen_trunc_i64_i32(cpu_VF, flag);
 514
 515         tcg_gen_mov_i64(dest, result);
 516         tcg_temp_free_i64(result);
 517         tcg_temp_free_i64(flag);
 518     } else {
 519         /* 32 bit arithmetic */
 520         TCGv_i32 t0_32 = tcg_temp_new_i32();
 521         TCGv_i32 t1_32 = tcg_temp_new_i32();
 522         TCGv_i32 tmp = tcg_temp_new_i32();
 523
 524         tcg_gen_movi_i32(tmp, 0);
 525         tcg_gen_trunc_i64_i32(t0_32, t0);
 526         tcg_gen_trunc_i64_i32(t1_32, t1);
 527         tcg_gen_add2_i32(cpu_NF, cpu_CF, t0_32, tmp, t1_32, tmp);
 528         tcg_gen_mov_i32(cpu_ZF, cpu_NF);
 529         tcg_gen_xor_i32(cpu_VF, cpu_NF, t0_32);
 530         tcg_gen_xor_i32(tmp, t0_32, t1_32);
 531         tcg_gen_andc_i32(cpu_VF, cpu_VF, tmp);
 532         tcg_gen_extu_i32_i64(dest, cpu_NF);
 533
 534         tcg_temp_free_i32(tmp);
 535         tcg_temp_free_i32(t0_32);
 536         tcg_temp_free_i32(t1_32);
 537     }
 538 }
 539
 540 /* dest = T0 - T1; compute C, N, V and Z flags */
 541 static void gen_sub_CC(int sf, TCGv_i64 dest, TCGv_i64 t0, TCGv_i64 t1)
 542 {
 543     if (sf) {
 544         /* 64 bit arithmetic */
 545         TCGv_i64 result, flag, tmp;
 546
 547         result = tcg_temp_new_i64();
 548         flag = tcg_temp_new_i64();
 549         tcg_gen_sub_i64(result, t0, t1);
 550
 551         gen_set_NZ64(result);
 552
 553         tcg_gen_setcond_i64(TCG_COND_GEU, flag, t0, t1);
 554         tcg_gen_trunc_i64_i32(cpu_CF, flag);
 555
 556         tcg_gen_xor_i64(flag, result, t0);
 557         tmp = tcg_temp_new_i64();
 558         tcg_gen_xor_i64(tmp, t0, t1);
 559         tcg_gen_and_i64(flag, flag, tmp);
 560         tcg_temp_free_i64(tmp);
 561         tcg_gen_shri_i64(flag, flag, 32);
 562         tcg_gen_trunc_i64_i32(cpu_VF, flag);
 563         tcg_gen_mov_i64(dest, result);
 564         tcg_temp_free_i64(flag);
 565         tcg_temp_free_i64(result);
 566     } else {
 567         /* 32 bit arithmetic */
 568         TCGv_i32 t0_32 = tcg_temp_new_i32();
 569         TCGv_i32 t1_32 = tcg_temp_new_i32();
 570         TCGv_i32 tmp;
 571
 572         tcg_gen_trunc_i64_i32(t0_32, t0);
 573         tcg_gen_trunc_i64_i32(t1_32, t1);
 574         tcg_gen_sub_i32(cpu_NF, t0_32, t1_32);
 575         tcg_gen_mov_i32(cpu_ZF, cpu_NF);
 576         tcg_gen_setcond_i32(TCG_COND_GEU, cpu_CF, t0_32, t1_32);
 577         tcg_gen_xor_i32(cpu_VF, cpu_NF, t0_32);
 578         tmp = tcg_temp_new_i32();
 579         tcg_gen_xor_i32(tmp, t0_32, t1_32);
 580         tcg_temp_free_i32(t0_32);
 581         tcg_temp_free_i32(t1_32);
 582         tcg_gen_and_i32(cpu_VF, cpu_VF, tmp);
 583         tcg_temp_free_i32(tmp);
 584         tcg_gen_extu_i32_i64(dest, cpu_NF);
 585     }
 586 }
 587
 588 /* dest = T0 + T1 + CF; do not compute flags. */
 589 static void gen_adc(int sf, TCGv_i64 dest, TCGv_i64 t0, TCGv_i64 t1)
 590 {
 591     TCGv_i64 flag = tcg_temp_new_i64();
 592     tcg_gen_extu_i32_i64(flag, cpu_CF);
 593     tcg_gen_add_i64(dest, t0, t1);
 594     tcg_gen_add_i64(dest, dest, flag);
 595     tcg_temp_free_i64(flag);
 596
 597     if (!sf) {
 598         tcg_gen_ext32u_i64(dest, dest);
 599     }
 600 }
 601
 602 /* dest = T0 + T1 + CF; compute C, N, V and Z flags. */
 603 static void gen_adc_CC(int sf, TCGv_i64 dest, TCGv_i64 t0, TCGv_i64 t1)
 604 {
 605     if (sf) {
 606         TCGv_i64 result, cf_64, vf_64, tmp;
 607         result = tcg_temp_new_i64();
 608         cf_64 = tcg_temp_new_i64();
 609         vf_64 = tcg_temp_new_i64();
 610         tmp = tcg_const_i64(0);
 611
 612         tcg_gen_extu_i32_i64(cf_64, cpu_CF);
 613         tcg_gen_add2_i64(result, cf_64, t0, tmp, cf_64, tmp);
 614         tcg_gen_add2_i64(result, cf_64, result, cf_64, t1, tmp);
 615         tcg_gen_trunc_i64_i32(cpu_CF, cf_64);
 616         gen_set_NZ64(result);
 617
 618         tcg_gen_xor_i64(vf_64, result, t0);
 619         tcg_gen_xor_i64(tmp, t0, t1);
 620         tcg_gen_andc_i64(vf_64, vf_64, tmp);
 621         tcg_gen_shri_i64(vf_64, vf_64, 32);
 622         tcg_gen_trunc_i64_i32(cpu_VF, vf_64);
 623
 624         tcg_gen_mov_i64(dest, result);
 625
 626         tcg_temp_free_i64(tmp);
 627         tcg_temp_free_i64(vf_64);
 628         tcg_temp_free_i64(cf_64);
 629         tcg_temp_free_i64(result);
 630     } else {
 631         TCGv_i32 t0_32, t1_32, tmp;
 632         t0_32 = tcg_temp_new_i32();
 633         t1_32 = tcg_temp_new_i32();
 634         tmp = tcg_const_i32(0);
 635
 636         tcg_gen_trunc_i64_i32(t0_32, t0);
 637         tcg_gen_trunc_i64_i32(t1_32, t1);
 638         tcg_gen_add2_i32(cpu_NF, cpu_CF, t0_32, tmp, cpu_CF, tmp);
 639         tcg_gen_add2_i32(cpu_NF, cpu_CF, cpu_NF, cpu_CF, t1_32, tmp);
 640
 641         tcg_gen_mov_i32(cpu_ZF, cpu_NF);
 642         tcg_gen_xor_i32(cpu_VF, cpu_NF, t0_32);
 643         tcg_gen_xor_i32(tmp, t0_32, t1_32);
 644         tcg_gen_andc_i32(cpu_VF, cpu_VF, tmp);
 645         tcg_gen_extu_i32_i64(dest, cpu_NF);
 646
 647         tcg_temp_free_i32(tmp);
 648         tcg_temp_free_i32(t1_32);
 649         tcg_temp_free_i32(t0_32);
 650     }
 651 }
 652
 653 /*
 654  * Load/Store generators
 655  */
 656
 657 /*
 658  * Store from GPR register to memory.
 659  */
 660 static void do_gpr_st_memidx(DisasContext *s, TCGv_i64 source,
 661                              TCGv_i64 tcg_addr, int size, int memidx)
 662 {
 663     g_assert(size <= 3);
 664     tcg_gen_qemu_st_i64(source, tcg_addr, memidx, MO_TE + size);
 665 }
 666
 667 static void do_gpr_st(DisasContext *s, TCGv_i64 source,
 668                       TCGv_i64 tcg_addr, int size)
 669 {
 670     do_gpr_st_memidx(s, source, tcg_addr, size, get_mem_index(s));
 671 }
 672
 673 /*
 674  * Load from memory to GPR register
 675  */
 676 static void do_gpr_ld_memidx(DisasContext *s, TCGv_i64 dest, TCGv_i64 tcg_addr,
 677                              int size, bool is_signed, bool extend, int memidx)
 678 {
 679     TCGMemOp memop = MO_TE + size;
 680
 681     g_assert(size <= 3);
 682
 683     if (is_signed) {
 684         memop += MO_SIGN;
 685     }
 686
 687     tcg_gen_qemu_ld_i64(dest, tcg_addr, memidx, memop);
 688
 689     if (extend && is_signed) {
 690         g_assert(size < 3);
 691         tcg_gen_ext32u_i64(dest, dest);
 692     }
 693 }
 694
 695 static void do_gpr_ld(DisasContext *s, TCGv_i64 dest, TCGv_i64 tcg_addr,
 696                       int size, bool is_signed, bool extend)
 697 {
 698     do_gpr_ld_memidx(s, dest, tcg_addr, size, is_signed, extend,
 699                      get_mem_index(s));
 700 }
 701
 702 /*
 703  * Store from FP register to memory
 704  */
 705 static void do_fp_st(DisasContext *s, int srcidx, TCGv_i64 tcg_addr, int size)
 706 {
 707     /* This writes the bottom N bits of a 128 bit wide vector to memory */
 708     TCGv_i64 tmp = tcg_temp_new_i64();
 709     tcg_gen_ld_i64(tmp, cpu_env, fp_reg_offset(s, srcidx, MO_64));
 710     if (size < 4) {
 711         tcg_gen_qemu_st_i64(tmp, tcg_addr, get_mem_index(s), MO_TE + size);
 712     } else {
 713         TCGv_i64 tcg_hiaddr = tcg_temp_new_i64();
 714         tcg_gen_qemu_st_i64(tmp, tcg_addr, get_mem_index(s), MO_TEQ);
 715         tcg_gen_qemu_st64(tmp, tcg_addr, get_mem_index(s));
 716         tcg_gen_ld_i64(tmp, cpu_env, fp_reg_hi_offset(s, srcidx));
 717         tcg_gen_addi_i64(tcg_hiaddr, tcg_addr, 8);
 718         tcg_gen_qemu_st_i64(tmp, tcg_hiaddr, get_mem_index(s), MO_TEQ);
 719         tcg_temp_free_i64(tcg_hiaddr);
 720     }
 721
 722     tcg_temp_free_i64(tmp);
 723 }
 724
 725 /*
 726  * Load from memory to FP register
 727  */
 728 static void do_fp_ld(DisasContext *s, int destidx, TCGv_i64 tcg_addr, int size)
 729 {
 730     /* This always zero-extends and writes to a full 128 bit wide vector */
 731     TCGv_i64 tmplo = tcg_temp_new_i64();
 732     TCGv_i64 tmphi;
 733
 734     if (size < 4) {
 735         TCGMemOp memop = MO_TE + size;
 736         tmphi = tcg_const_i64(0);
 737         tcg_gen_qemu_ld_i64(tmplo, tcg_addr, get_mem_index(s), memop);
 738     } else {
 739         TCGv_i64 tcg_hiaddr;
 740         tmphi = tcg_temp_new_i64();
 741         tcg_hiaddr = tcg_temp_new_i64();
 742
 743         tcg_gen_qemu_ld_i64(tmplo, tcg_addr, get_mem_index(s), MO_TEQ);
 744         tcg_gen_addi_i64(tcg_hiaddr, tcg_addr, 8);
 745         tcg_gen_qemu_ld_i64(tmphi, tcg_hiaddr, get_mem_index(s), MO_TEQ);
 746         tcg_temp_free_i64(tcg_hiaddr);
 747     }
 748
 749     tcg_gen_st_i64(tmplo, cpu_env, fp_reg_offset(s, destidx, MO_64));
 750     tcg_gen_st_i64(tmphi, cpu_env, fp_reg_hi_offset(s, destidx));
 751
 752     tcg_temp_free_i64(tmplo);
 753     tcg_temp_free_i64(tmphi);
 754 }
 755
 756 /*
 757  * Vector load/store helpers.
 758  *
 759  * The principal difference between this and a FP load is that we don't
 760  * zero extend as we are filling a partial chunk of the vector register.
 761  * These functions don't support 128 bit loads/stores, which would be
 762  * normal load/store operations.
 763  *
 764  * The _i32 versions are useful when operating on 32 bit quantities
 765  * (eg for floating point single or using Neon helper functions).
 766  */
 767
 768 /* Get value of an element within a vector register */
 769 static void read_vec_element(DisasContext *s, TCGv_i64 tcg_dest, int srcidx,
 770                              int element, TCGMemOp memop)
 771 {
 772     int vect_off = vec_reg_offset(s, srcidx, element, memop & MO_SIZE);
 773     switch (memop) {
 774     case MO_8:
 775         tcg_gen_ld8u_i64(tcg_dest, cpu_env, vect_off);
 776         break;
 777     case MO_16:
 778         tcg_gen_ld16u_i64(tcg_dest, cpu_env, vect_off);
 779         break;
 780     case MO_32:
 781         tcg_gen_ld32u_i64(tcg_dest, cpu_env, vect_off);
 782         break;
 783     case MO_8|MO_SIGN:
 784         tcg_gen_ld8s_i64(tcg_dest, cpu_env, vect_off);
 785         break;
 786     case MO_16|MO_SIGN:
 787         tcg_gen_ld16s_i64(tcg_dest, cpu_env, vect_off);
 788         break;
 789     case MO_32|MO_SIGN:
 790         tcg_gen_ld32s_i64(tcg_dest, cpu_env, vect_off);
 791         break;
 792     case MO_64:
 793     case MO_64|MO_SIGN:
 794         tcg_gen_ld_i64(tcg_dest, cpu_env, vect_off);
 795         break;
 796     default:
 797         g_assert_not_reached();
 798     }
 799 }
 800
 801 static void read_vec_element_i32(DisasContext *s, TCGv_i32 tcg_dest, int srcidx,
 802                                  int element, TCGMemOp memop)
 803 {
 804     int vect_off = vec_reg_offset(s, srcidx, element, memop & MO_SIZE);
 805     switch (memop) {
 806     case MO_8:
 807         tcg_gen_ld8u_i32(tcg_dest, cpu_env, vect_off);
 808         break;
 809     case MO_16:
 810         tcg_gen_ld16u_i32(tcg_dest, cpu_env, vect_off);
 811         break;
 812     case MO_8|MO_SIGN:
 813         tcg_gen_ld8s_i32(tcg_dest, cpu_env, vect_off);
 814         break;
 815     case MO_16|MO_SIGN:
 816         tcg_gen_ld16s_i32(tcg_dest, cpu_env, vect_off);
 817         break;
 818     case MO_32:
 819     case MO_32|MO_SIGN:
 820         tcg_gen_ld_i32(tcg_dest, cpu_env, vect_off);
 821         break;
 822     default:
 823         g_assert_not_reached();
 824     }
 825 }
 826
 827 /* Set value of an element within a vector register */
 828 static void write_vec_element(DisasContext *s, TCGv_i64 tcg_src, int destidx,
 829                               int element, TCGMemOp memop)
 830 {
 831     int vect_off = vec_reg_offset(s, destidx, element, memop & MO_SIZE);
 832     switch (memop) {
 833     case MO_8:
 834         tcg_gen_st8_i64(tcg_src, cpu_env, vect_off);
 835         break;
 836     case MO_16:
 837         tcg_gen_st16_i64(tcg_src, cpu_env, vect_off);
 838         break;
 839     case MO_32:
 840         tcg_gen_st32_i64(tcg_src, cpu_env, vect_off);
 841         break;
 842     case MO_64:
 843         tcg_gen_st_i64(tcg_src, cpu_env, vect_off);
 844         break;
 845     default:
 846         g_assert_not_reached();
 847     }
 848 }
 849
 850 static void write_vec_element_i32(DisasContext *s, TCGv_i32 tcg_src,
 851                                   int destidx, int element, TCGMemOp memop)
 852 {
 853     int vect_off = vec_reg_offset(s, destidx, element, memop & MO_SIZE);
 854     switch (memop) {
 855     case MO_8:
 856         tcg_gen_st8_i32(tcg_src, cpu_env, vect_off);
 857         break;
 858     case MO_16:
 859         tcg_gen_st16_i32(tcg_src, cpu_env, vect_off);
 860         break;
 861     case MO_32:
 862         tcg_gen_st_i32(tcg_src, cpu_env, vect_off);
 863         break;
 864     default:
 865         g_assert_not_reached();
 866     }
 867 }
 868
 869 /* Clear the high 64 bits of a 128 bit vector (in general non-quad
 870  * vector ops all need to do this).
 871  */
 872 static void clear_vec_high(DisasContext *s, int rd)
 873 {
 874     TCGv_i64 tcg_zero = tcg_const_i64(0);
 875
 876     write_vec_element(s, tcg_zero, rd, 1, MO_64);
 877     tcg_temp_free_i64(tcg_zero);
 878 }
 879
 880 /* Store from vector register to memory */
 881 static void do_vec_st(DisasContext *s, int srcidx, int element,
 882                       TCGv_i64 tcg_addr, int size)
 883 {
 884     TCGMemOp memop = MO_TE + size;
 885     TCGv_i64 tcg_tmp = tcg_temp_new_i64();
 886
 887     read_vec_element(s, tcg_tmp, srcidx, element, size);
 888     tcg_gen_qemu_st_i64(tcg_tmp, tcg_addr, get_mem_index(s), memop);
 889
 890     tcg_temp_free_i64(tcg_tmp);
 891 }
 892
 893 /* Load from memory to vector register */
 894 static void do_vec_ld(DisasContext *s, int destidx, int element,
 895                       TCGv_i64 tcg_addr, int size)
 896 {
 897     TCGMemOp memop = MO_TE + size;
 898     TCGv_i64 tcg_tmp = tcg_temp_new_i64();
 899
 900     tcg_gen_qemu_ld_i64(tcg_tmp, tcg_addr, get_mem_index(s), memop);
 901     write_vec_element(s, tcg_tmp, destidx, element, size);
 902
 903     tcg_temp_free_i64(tcg_tmp);
 904 }
 905
 906 /* Check that FP/Neon access is enabled. If it is, return
 907  * true. If not, emit code to generate an appropriate exception,
 908  * and return false; the caller should not emit any code for
 909  * the instruction. Note that this check must happen after all
 910  * unallocated-encoding checks (otherwise the syndrome information
 911  * for the resulting exception will be incorrect).
 912  */
 913 static inline bool fp_access_check(DisasContext *s)
 914 {
 915     assert(!s->fp_access_checked);
 916     s->fp_access_checked = true;
 917
 918     if (s->cpacr_fpen) {
 919         return true;
 920     }
 921
 922     gen_exception_insn(s, 4, EXCP_UDEF, syn_fp_access_trap(1, 0xe, false));
 923     return false;
 924 }
 925
 926 /*
 927  * This utility function is for doing register extension with an
 928  * optional shift. You will likely want to pass a temporary for the
 929  * destination register. See DecodeRegExtend() in the ARM ARM.
 930  */
 931 static void ext_and_shift_reg(TCGv_i64 tcg_out, TCGv_i64 tcg_in,
 932                               int option, unsigned int shift)
 933 {
 934     int extsize = extract32(option, 0, 2);
 935     bool is_signed = extract32(option, 2, 1);
 936
 937     if (is_signed) {
 938         switch (extsize) {
 939         case 0:
 940             tcg_gen_ext8s_i64(tcg_out, tcg_in);
 941             break;
 942         case 1:
 943             tcg_gen_ext16s_i64(tcg_out, tcg_in);
 944             break;
 945         case 2:
 946             tcg_gen_ext32s_i64(tcg_out, tcg_in);
 947             break;
 948         case 3:
 949             tcg_gen_mov_i64(tcg_out, tcg_in);
 950             break;
 951         }
 952     } else {
 953         switch (extsize) {
 954         case 0:
 955             tcg_gen_ext8u_i64(tcg_out, tcg_in);
 956             break;
 957         case 1:
 958             tcg_gen_ext16u_i64(tcg_out, tcg_in);
 959             break;
 960         case 2:
 961             tcg_gen_ext32u_i64(tcg_out, tcg_in);
 962             break;
 963         case 3:
 964             tcg_gen_mov_i64(tcg_out, tcg_in);
 965             break;
 966         }
 967     }
 968
 969     if (shift) {
 970         tcg_gen_shli_i64(tcg_out, tcg_out, shift);
 971     }
 972 }
 973
 974 static inline void gen_check_sp_alignment(DisasContext *s)
 975 {
 976     /* The AArch64 architecture mandates that (if enabled via PSTATE
 977      * or SCTLR bits) there is a check that SP is 16-aligned on every
 978      * SP-relative load or store (with an exception generated if it is not).
 979      * In line with general QEMU practice regarding misaligned accesses,
 980      * we omit these checks for the sake of guest program performance.
 981      * This function is provided as a hook so we can more easily add these
 982      * checks in future (possibly as a "favour catching guest program bugs
 983      * over speed" user selectable option).
 984      */
 985 }
 986
 987 /*
 988  * This provides a simple table based table lookup decoder. It is
 989  * intended to be used when the relevant bits for decode are too
 990  * awkwardly placed and switch/if based logic would be confusing and
 991  * deeply nested. Since it's a linear search through the table, tables
 992  * should be kept small.
 993  *
 994  * It returns the first handler where insn & mask == pattern, or
 995  * NULL if there is no match.
 996  * The table is terminated by an empty mask (i.e. 0)
 997  */
 998 static inline AArch64DecodeFn *lookup_disas_fn(const AArch64DecodeTable *table,
 999                                                uint32_t insn)
1000 {
1001     const AArch64DecodeTable *tptr = table;
1002
1003     while (tptr->mask) {
1004         if ((insn & tptr->mask) == tptr->pattern) {
1005             return tptr->disas_fn;
1006         }
1007         tptr++;
1008     }
1009     return NULL;
1010 }
1011
1012 /*
1013  * the instruction disassembly implemented here matches
1014  * the instruction encoding classifications in chapter 3 (C3)
1015  * of the ARM Architecture Reference Manual (DDI0487A_a)
1016  */
1017
1018 /* C3.2.7 Unconditional branch (immediate)
1019  *   31  30       26 25                                  0
1020  * +----+-----------+-------------------------------------+
1021  * | op | 0 0 1 0 1 |                 imm26               |
1022  * +----+-----------+-------------------------------------+
1023  */
1024 static void disas_uncond_b_imm(DisasContext *s, uint32_t insn)
1025 {
1026     uint64_t addr = s->pc + sextract32(insn, 0, 26) * 4 - 4;
1027
1028     if (insn & (1 << 31)) {
1029         /* C5.6.26 BL Branch with link */
1030         tcg_gen_movi_i64(cpu_reg(s, 30), s->pc);
1031     }
1032
1033     /* C5.6.20 B Branch / C5.6.26 BL Branch with link */
1034     gen_goto_tb(s, 0, addr);
1035 }
1036
1037 /* C3.2.1 Compare & branch (immediate)
1038  *   31  30         25  24  23                  5 4      0
1039  * +----+-------------+----+---------------------+--------+
1040  * | sf | 0 1 1 0 1 0 | op |         imm19       |   Rt   |
1041  * +----+-------------+----+---------------------+--------+
1042  */
1043 static void disas_comp_b_imm(DisasContext *s, uint32_t insn)
1044 {
1045     unsigned int sf, op, rt;
1046     uint64_t addr;
1047     int label_match;
1048     TCGv_i64 tcg_cmp;
1049
1050     sf = extract32(insn, 31, 1);
1051     op = extract32(insn, 24, 1); /* 0: CBZ; 1: CBNZ */
1052     rt = extract32(insn, 0, 5);
1053     addr = s->pc + sextract32(insn, 5, 19) * 4 - 4;
1054
1055     tcg_cmp = read_cpu_reg(s, rt, sf);
1056     label_match = gen_new_label();
1057
1058     tcg_gen_brcondi_i64(op ? TCG_COND_NE : TCG_COND_EQ,
1059                         tcg_cmp, 0, label_match);
1060
1061     gen_goto_tb(s, 0, s->pc);
1062     gen_set_label(label_match);
1063     gen_goto_tb(s, 1, addr);
1064 }
1065
1066 /* C3.2.5 Test & branch (immediate)
1067  *   31  30         25  24  23   19 18          5 4    0
1068  * +----+-------------+----+-------+-------------+------+
1069  * | b5 | 0 1 1 0 1 1 | op |  b40  |    imm14    |  Rt  |
1070  * +----+-------------+----+-------+-------------+------+
1071  */
1072 static void disas_test_b_imm(DisasContext *s, uint32_t insn)
1073 {
1074     unsigned int bit_pos, op, rt;
1075     uint64_t addr;
1076     int label_match;
1077     TCGv_i64 tcg_cmp;
1078
1079     bit_pos = (extract32(insn, 31, 1) << 5) | extract32(insn, 19, 5);
1080     op = extract32(insn, 24, 1); /* 0: TBZ; 1: TBNZ */
1081     addr = s->pc + sextract32(insn, 5, 14) * 4 - 4;
1082     rt = extract32(insn, 0, 5);
1083
1084     tcg_cmp = tcg_temp_new_i64();
1085     tcg_gen_andi_i64(tcg_cmp, cpu_reg(s, rt), (1ULL << bit_pos));
1086     label_match = gen_new_label();
1087     tcg_gen_brcondi_i64(op ? TCG_COND_NE : TCG_COND_EQ,
1088                         tcg_cmp, 0, label_match);
1089     tcg_temp_free_i64(tcg_cmp);
1090     gen_goto_tb(s, 0, s->pc);
1091     gen_set_label(label_match);
1092     gen_goto_tb(s, 1, addr);
1093 }
1094
1095 /* C3.2.2 / C5.6.19 Conditional branch (immediate)
1096  *  31           25  24  23                  5   4  3    0
1097  * +---------------+----+---------------------+----+------+
1098  * | 0 1 0 1 0 1 0 | o1 |         imm19       | o0 | cond |
1099  * +---------------+----+---------------------+----+------+
1100  */
1101 static void disas_cond_b_imm(DisasContext *s, uint32_t insn)
1102 {
1103     unsigned int cond;
1104     uint64_t addr;
1105
1106     if ((insn & (1 << 4)) || (insn & (1 << 24))) {
1107         unallocated_encoding(s);
1108         return;
1109     }
1110     addr = s->pc + sextract32(insn, 5, 19) * 4 - 4;
1111     cond = extract32(insn, 0, 4);
1112
1113     if (cond < 0x0e) {
1114         /* genuinely conditional branches */
1115         int label_match = gen_new_label();
1116         arm_gen_test_cc(cond, label_match);
1117         gen_goto_tb(s, 0, s->pc);
1118         gen_set_label(label_match);
1119         gen_goto_tb(s, 1, addr);
1120     } else {
1121         /* 0xe and 0xf are both "always" conditions */
1122         gen_goto_tb(s, 0, addr);
1123     }
1124 }
1125
1126 /* C5.6.68 HINT */
1127 static void handle_hint(DisasContext *s, uint32_t insn,
1128                         unsigned int op1, unsigned int op2, unsigned int crm)
1129 {
1130     unsigned int selector = crm << 3 | op2;
1131
1132     if (op1 != 3) {
1133         unallocated_encoding(s);
1134         return;
1135     }
1136
1137     switch (selector) {
1138     case 0: /* NOP */
1139         return;
1140     case 3: /* WFI */
1141         s->is_jmp = DISAS_WFI;
1142         return;
1143     case 1: /* YIELD */
1144     case 2: /* WFE */
1145         s->is_jmp = DISAS_WFE;
1146         return;
1147     case 4: /* SEV */
1148     case 5: /* SEVL */
1149         /* we treat all as NOP at least for now */
1150         return;
1151     default:
1152         /* default specified as NOP equivalent */
1153         return;
1154     }
1155 }
1156
1157 static void gen_clrex(DisasContext *s, uint32_t insn)
1158 {
1159     tcg_gen_movi_i64(cpu_exclusive_addr, -1);
1160 }
1161
1162 /* CLREX, DSB, DMB, ISB */
1163 static void handle_sync(DisasContext *s, uint32_t insn,
1164                         unsigned int op1, unsigned int op2, unsigned int crm)
1165 {
1166     if (op1 != 3) {
1167         unallocated_encoding(s);
1168         return;
1169     }
1170
1171     switch (op2) {
1172     case 2: /* CLREX */
1173         gen_clrex(s, insn);
1174         return;
1175     case 4: /* DSB */
1176     case 5: /* DMB */
1177     case 6: /* ISB */
1178         /* We don't emulate caches so barriers are no-ops */
1179         return;
1180     default:
1181         unallocated_encoding(s);
1182         return;
1183     }
1184 }
1185
1186 /* C5.6.130 MSR (immediate) - move immediate to processor state field */
1187 static void handle_msr_i(DisasContext *s, uint32_t insn,
1188                          unsigned int op1, unsigned int op2, unsigned int crm)
1189 {
1190     int op = op1 << 3 | op2;
1191     switch (op) {
1192     case 0x05: /* SPSel */
1193         if (s->current_pl == 0) {
1194             unallocated_encoding(s);
1195             return;
1196         }
1197         /* fall through */
1198     case 0x1e: /* DAIFSet */
1199     case 0x1f: /* DAIFClear */
1200     {
1201         TCGv_i32 tcg_imm = tcg_const_i32(crm);
1202         TCGv_i32 tcg_op = tcg_const_i32(op);
1203         gen_a64_set_pc_im(s->pc - 4);
1204         gen_helper_msr_i_pstate(cpu_env, tcg_op, tcg_imm);
1205         tcg_temp_free_i32(tcg_imm);
1206         tcg_temp_free_i32(tcg_op);
1207         s->is_jmp = DISAS_UPDATE;
1208         break;
1209     }
1210     default:
1211         unallocated_encoding(s);
1212         return;
1213     }
1214 }
1215
1216 static void gen_get_nzcv(TCGv_i64 tcg_rt)
1217 {
1218     TCGv_i32 tmp = tcg_temp_new_i32();
1219     TCGv_i32 nzcv = tcg_temp_new_i32();
1220
1221     /* build bit 31, N */
1222     tcg_gen_andi_i32(nzcv, cpu_NF, (1 << 31));
1223     /* build bit 30, Z */
1224     tcg_gen_setcondi_i32(TCG_COND_EQ, tmp, cpu_ZF, 0);
1225     tcg_gen_deposit_i32(nzcv, nzcv, tmp, 30, 1);
1226     /* build bit 29, C */
1227     tcg_gen_deposit_i32(nzcv, nzcv, cpu_CF, 29, 1);
1228     /* build bit 28, V */
1229     tcg_gen_shri_i32(tmp, cpu_VF, 31);
1230     tcg_gen_deposit_i32(nzcv, nzcv, tmp, 28, 1);
1231     /* generate result */
1232     tcg_gen_extu_i32_i64(tcg_rt, nzcv);
1233
1234     tcg_temp_free_i32(nzcv);
1235     tcg_temp_free_i32(tmp);
1236 }
1237
1238 static void gen_set_nzcv(TCGv_i64 tcg_rt)
1239
1240 {
1241     TCGv_i32 nzcv = tcg_temp_new_i32();
1242
1243     /* take NZCV from R[t] */
1244     tcg_gen_trunc_i64_i32(nzcv, tcg_rt);
1245
1246     /* bit 31, N */
1247     tcg_gen_andi_i32(cpu_NF, nzcv, (1 << 31));
1248     /* bit 30, Z */
1249     tcg_gen_andi_i32(cpu_ZF, nzcv, (1 << 30));
1250     tcg_gen_setcondi_i32(TCG_COND_EQ, cpu_ZF, cpu_ZF, 0);
1251     /* bit 29, C */
1252     tcg_gen_andi_i32(cpu_CF, nzcv, (1 << 29));
1253     tcg_gen_shri_i32(cpu_CF, cpu_CF, 29);
1254     /* bit 28, V */
1255     tcg_gen_andi_i32(cpu_VF, nzcv, (1 << 28));
1256     tcg_gen_shli_i32(cpu_VF, cpu_VF, 3);
1257     tcg_temp_free_i32(nzcv);
1258 }
1259
1260 /* C5.6.129 MRS - move from system register
1261  * C5.6.131 MSR (register) - move to system register
1262  * C5.6.204 SYS
1263  * C5.6.205 SYSL
1264  * These are all essentially the same insn in 'read' and 'write'
1265  * versions, with varying op0 fields.
1266  */
1267 static void handle_sys(DisasContext *s, uint32_t insn, bool isread,
1268                        unsigned int op0, unsigned int op1, unsigned int op2,
1269                        unsigned int crn, unsigned int crm, unsigned int rt)
1270 {
1271     const ARMCPRegInfo *ri;
1272     TCGv_i64 tcg_rt;
1273
1274     ri = get_arm_cp_reginfo(s->cp_regs,
1275                             ENCODE_AA64_CP_REG(CP_REG_ARM64_SYSREG_CP,
1276                                                crn, crm, op0, op1, op2));
1277
1278     if (!ri) {
1279         /* Unknown register; this might be a guest error or a QEMU
1280          * unimplemented feature.
1281          */
1282         qemu_log_mask(LOG_UNIMP, "%s access to unsupported AArch64 "
1283                       "system register op0:%d op1:%d crn:%d crm:%d op2:%d\n",
1284                       isread ? "read" : "write", op0, op1, crn, crm, op2);
1285         unallocated_encoding(s);
1286         return;
1287     }
1288
1289     /* Check access permissions */
1290     if (!cp_access_ok(s->current_pl, ri, isread)) {
1291         unallocated_encoding(s);
1292         return;
1293     }
1294
1295     if (ri->accessfn) {
1296         /* Emit code to perform further access permissions checks at
1297          * runtime; this may result in an exception.
1298          */
1299         TCGv_ptr tmpptr;
1300         TCGv_i32 tcg_syn;
1301         uint32_t syndrome;
1302
1303         gen_a64_set_pc_im(s->pc - 4);
1304         tmpptr = tcg_const_ptr(ri);
1305         syndrome = syn_aa64_sysregtrap(op0, op1, op2, crn, crm, rt, isread);
1306         tcg_syn = tcg_const_i32(syndrome);
1307         gen_helper_access_check_cp_reg(cpu_env, tmpptr, tcg_syn);
1308         tcg_temp_free_ptr(tmpptr);
1309         tcg_temp_free_i32(tcg_syn);
1310     }
1311
1312     /* Handle special cases first */
1313     switch (ri->type & ~(ARM_CP_FLAG_MASK & ~ARM_CP_SPECIAL)) {
1314     case ARM_CP_NOP:
1315         return;
1316     case ARM_CP_NZCV:
1317         tcg_rt = cpu_reg(s, rt);
1318         if (isread) {
1319             gen_get_nzcv(tcg_rt);
1320         } else {
1321             gen_set_nzcv(tcg_rt);
1322         }
1323         return;
1324     case ARM_CP_CURRENTEL:
1325         /* Reads as current EL value from pstate, which is
1326          * guaranteed to be constant by the tb flags.
1327          */
1328         tcg_rt = cpu_reg(s, rt);
1329         tcg_gen_movi_i64(tcg_rt, s->current_pl << 2);
1330         return;
1331     case ARM_CP_DC_ZVA:
1332         /* Writes clear the aligned block of memory which rt points into. */
1333         tcg_rt = cpu_reg(s, rt);
1334         gen_helper_dc_zva(cpu_env, tcg_rt);
1335         return;
1336     default:
1337         break;
1338     }
1339
1340     if (use_icount && (ri->type & ARM_CP_IO)) {
1341         gen_io_start();
1342     }
1343
1344     tcg_rt = cpu_reg(s, rt);
1345
1346     if (isread) {
1347         if (ri->type & ARM_CP_CONST) {
1348             tcg_gen_movi_i64(tcg_rt, ri->resetvalue);
1349         } else if (ri->readfn) {
1350             TCGv_ptr tmpptr;
1351             tmpptr = tcg_const_ptr(ri);
1352             gen_helper_get_cp_reg64(tcg_rt, cpu_env, tmpptr);
1353             tcg_temp_free_ptr(tmpptr);
1354         } else {
1355             tcg_gen_ld_i64(tcg_rt, cpu_env, ri->fieldoffset);
1356         }
1357     } else {
1358         if (ri->type & ARM_CP_CONST) {
1359             /* If not forbidden by access permissions, treat as WI */
1360             return;
1361         } else if (ri->writefn) {
1362             TCGv_ptr tmpptr;
1363             tmpptr = tcg_const_ptr(ri);
1364             gen_helper_set_cp_reg64(cpu_env, tmpptr, tcg_rt);
1365             tcg_temp_free_ptr(tmpptr);
1366         } else {
1367             tcg_gen_st_i64(tcg_rt, cpu_env, ri->fieldoffset);
1368         }
1369     }
1370
1371     if (use_icount && (ri->type & ARM_CP_IO)) {
1372         /* I/O operations must end the TB here (whether read or write) */
1373         gen_io_end();
1374         s->is_jmp = DISAS_UPDATE;
1375     } else if (!isread && !(ri->type & ARM_CP_SUPPRESS_TB_END)) {
1376         /* We default to ending the TB on a coprocessor register write,
1377          * but allow this to be suppressed by the register definition
1378          * (usually only necessary to work around guest bugs).
1379          */
1380         s->is_jmp = DISAS_UPDATE;
1381     }
1382 }
1383
1384 /* C3.2.4 System
1385  *  31                 22 21  20 19 18 16 15   12 11    8 7   5 4    0
1386  * +---------------------+---+-----+-----+-------+-------+-----+------+
1387  * | 1 1 0 1 0 1 0 1 0 0 | L | op0 | op1 |  CRn  |  CRm  | op2 |  Rt  |
1388  * +---------------------+---+-----+-----+-------+-------+-----+------+
1389  */
1390 static void disas_system(DisasContext *s, uint32_t insn)
1391 {
1392     unsigned int l, op0, op1, crn, crm, op2, rt;
1393     l = extract32(insn, 21, 1);
1394     op0 = extract32(insn, 19, 2);
1395     op1 = extract32(insn, 16, 3);
1396     crn = extract32(insn, 12, 4);
1397     crm = extract32(insn, 8, 4);
1398     op2 = extract32(insn, 5, 3);
1399     rt = extract32(insn, 0, 5);
1400
1401     if (op0 == 0) {
1402         if (l || rt != 31) {
1403             unallocated_encoding(s);
1404             return;
1405         }
1406         switch (crn) {
1407         case 2: /* C5.6.68 HINT */
1408             handle_hint(s, insn, op1, op2, crm);
1409             break;
1410         case 3: /* CLREX, DSB, DMB, ISB */
1411             handle_sync(s, insn, op1, op2, crm);
1412             break;
1413         case 4: /* C5.6.130 MSR (immediate) */
1414             handle_msr_i(s, insn, op1, op2, crm);
1415             break;
1416         default:
1417             unallocated_encoding(s);
1418             break;
1419         }
1420         return;
1421     }
1422     handle_sys(s, insn, l, op0, op1, op2, crn, crm, rt);
1423 }
1424
1425 /* C3.2.3 Exception generation
1426  *
1427  *  31             24 23 21 20                     5 4   2 1  0
1428  * +-----------------+-----+------------------------+-----+----+
1429  * | 1 1 0 1 0 1 0 0 | opc |          imm16         | op2 | LL |
1430  * +-----------------------+------------------------+----------+
1431  */
1432 static void disas_exc(DisasContext *s, uint32_t insn)
1433 {
1434     int opc = extract32(insn, 21, 3);
1435     int op2_ll = extract32(insn, 0, 5);
1436     int imm16 = extract32(insn, 5, 16);
1437
1438     switch (opc) {
1439     case 0:
1440         /* SVC, HVC, SMC; since we don't support the Virtualization
1441          * or TrustZone extensions these all UNDEF except SVC.
1442          */
1443         if (op2_ll != 1) {
1444             unallocated_encoding(s);
1445             break;
1446         }
1447         gen_exception_insn(s, 0, EXCP_SWI, syn_aa64_svc(imm16));
1448         break;
1449     case 1:
1450         if (op2_ll != 0) {
1451             unallocated_encoding(s);
1452             break;
1453         }
1454         /* BRK */
1455         gen_exception_insn(s, 0, EXCP_BKPT, syn_aa64_bkpt(imm16));
1456         break;
1457     case 2:
1458         if (op2_ll != 0) {
1459             unallocated_encoding(s);
1460             break;
1461         }
1462         /* HLT */
1463         unsupported_encoding(s, insn);
1464         break;
1465     case 5:
1466         if (op2_ll < 1 || op2_ll > 3) {
1467             unallocated_encoding(s);
1468             break;
1469         }
1470         /* DCPS1, DCPS2, DCPS3 */
1471         unsupported_encoding(s, insn);
1472         break;
1473     default:
1474         unallocated_encoding(s);
1475         break;
1476     }
1477 }
1478
1479 /* C3.2.7 Unconditional branch (register)
1480  *  31           25 24   21 20   16 15   10 9    5 4     0
1481  * +---------------+-------+-------+-------+------+-------+
1482  * | 1 1 0 1 0 1 1 |  opc  |  op2  |  op3  |  Rn  |  op4  |
1483  * +---------------+-------+-------+-------+------+-------+
1484  */
1485 static void disas_uncond_b_reg(DisasContext *s, uint32_t insn)
1486 {
1487     unsigned int opc, op2, op3, rn, op4;
1488
1489     opc = extract32(insn, 21, 4);
1490     op2 = extract32(insn, 16, 5);
1491     op3 = extract32(insn, 10, 6);
1492     rn = extract32(insn, 5, 5);
1493     op4 = extract32(insn, 0, 5);
1494
1495     if (op4 != 0x0 || op3 != 0x0 || op2 != 0x1f) {
1496         unallocated_encoding(s);
1497         return;
1498     }
1499
1500     switch (opc) {
1501     case 0: /* BR */
1502     case 2: /* RET */
1503         tcg_gen_mov_i64(cpu_pc, cpu_reg(s, rn));
1504         break;
1505     case 1: /* BLR */
1506         tcg_gen_mov_i64(cpu_pc, cpu_reg(s, rn));
1507         tcg_gen_movi_i64(cpu_reg(s, 30), s->pc);
1508         break;
1509     case 4: /* ERET */
1510         gen_helper_exception_return(cpu_env);
1511         s->is_jmp = DISAS_JUMP;
1512         return;
1513     case 5: /* DRPS */
1514         if (rn != 0x1f) {
1515             unallocated_encoding(s);
1516         } else {
1517             unsupported_encoding(s, insn);
1518         }
1519         return;
1520     default:
1521         unallocated_encoding(s);
1522         return;
1523     }
1524
1525     s->is_jmp = DISAS_JUMP;
1526 }
1527
1528 /* C3.2 Branches, exception generating and system instructions */
1529 static void disas_b_exc_sys(DisasContext *s, uint32_t insn)
1530 {
1531     switch (extract32(insn, 25, 7)) {
1532     case 0x0a: case 0x0b:
1533     case 0x4a: case 0x4b: /* Unconditional branch (immediate) */
1534         disas_uncond_b_imm(s, insn);
1535         break;
1536     case 0x1a: case 0x5a: /* Compare & branch (immediate) */
1537         disas_comp_b_imm(s, insn);
1538         break;
1539     case 0x1b: case 0x5b: /* Test & branch (immediate) */
1540         disas_test_b_imm(s, insn);
1541         break;
1542     case 0x2a: /* Conditional branch (immediate) */
1543         disas_cond_b_imm(s, insn);
1544         break;
1545     case 0x6a: /* Exception generation / System */
1546         if (insn & (1 << 24)) {
1547             disas_system(s, insn);
1548         } else {
1549             disas_exc(s, insn);
1550         }
1551         break;
1552     case 0x6b: /* Unconditional branch (register) */
1553         disas_uncond_b_reg(s, insn);
1554         break;
1555     default:
1556         unallocated_encoding(s);
1557         break;
1558     }
1559 }
1560
1561 /*
1562  * Load/Store exclusive instructions are implemented by remembering
1563  * the value/address loaded, and seeing if these are the same
1564  * when the store is performed. This is not actually the architecturally
1565  * mandated semantics, but it works for typical guest code sequences
1566  * and avoids having to monitor regular stores.
1567  *
1568  * In system emulation mode only one CPU will be running at once, so
1569  * this sequence is effectively atomic.  In user emulation mode we
1570  * throw an exception and handle the atomic operation elsewhere.
1571  */
1572 static void gen_load_exclusive(DisasContext *s, int rt, int rt2,
1573                                TCGv_i64 addr, int size, bool is_pair)
1574 {
1575     TCGv_i64 tmp = tcg_temp_new_i64();
1576     TCGMemOp memop = MO_TE + size;
1577
1578     g_assert(size <= 3);
1579     tcg_gen_qemu_ld_i64(tmp, addr, get_mem_index(s), memop);
1580
1581     if (is_pair) {
1582         TCGv_i64 addr2 = tcg_temp_new_i64();
1583         TCGv_i64 hitmp = tcg_temp_new_i64();
1584
1585         g_assert(size >= 2);
1586         tcg_gen_addi_i64(addr2, addr, 1 << size);
1587         tcg_gen_qemu_ld_i64(hitmp, addr2, get_mem_index(s), memop);
1588         tcg_temp_free_i64(addr2);
1589         tcg_gen_mov_i64(cpu_exclusive_high, hitmp);
1590         tcg_gen_mov_i64(cpu_reg(s, rt2), hitmp);
1591         tcg_temp_free_i64(hitmp);
1592     }
1593
1594     tcg_gen_mov_i64(cpu_exclusive_val, tmp);
1595     tcg_gen_mov_i64(cpu_reg(s, rt), tmp);
1596
1597     tcg_temp_free_i64(tmp);
1598     tcg_gen_mov_i64(cpu_exclusive_addr, addr);
1599 }
1600
1601 #ifdef CONFIG_USER_ONLY
1602 static void gen_store_exclusive(DisasContext *s, int rd, int rt, int rt2,
1603                                 TCGv_i64 addr, int size, int is_pair)
1604 {
1605     tcg_gen_mov_i64(cpu_exclusive_test, addr);
1606     tcg_gen_movi_i32(cpu_exclusive_info,
1607                      size | is_pair << 2 | (rd << 4) | (rt << 9) | (rt2 << 14));
1608     gen_exception_internal_insn(s, 4, EXCP_STREX);
1609 }
1610 #else
1611 static void gen_store_exclusive(DisasContext *s, int rd, int rt, int rt2,
1612                                 TCGv_i64 inaddr, int size, int is_pair)
1613 {
1614     /* if (env->exclusive_addr == addr && env->exclusive_val == [addr]
1615      *     && (!is_pair || env->exclusive_high == [addr + datasize])) {
1616      *     [addr] = {Rt};
1617      *     if (is_pair) {
1618      *         [addr + datasize] = {Rt2};
1619      *     }
1620      *     {Rd} = 0;
1621      * } else {
1622      *     {Rd} = 1;
1623      * }
1624      * env->exclusive_addr = -1;
1625      */
1626     int fail_label = gen_new_label();
1627     int done_label = gen_new_label();
1628     TCGv_i64 addr = tcg_temp_local_new_i64();
1629     TCGv_i64 tmp;
1630
1631     /* Copy input into a local temp so it is not trashed when the
1632      * basic block ends at the branch insn.
1633      */
1634     tcg_gen_mov_i64(addr, inaddr);
1635     tcg_gen_brcond_i64(TCG_COND_NE, addr, cpu_exclusive_addr, fail_label);
1636
1637     tmp = tcg_temp_new_i64();
1638     tcg_gen_qemu_ld_i64(tmp, addr, get_mem_index(s), MO_TE + size);
1639     tcg_gen_brcond_i64(TCG_COND_NE, tmp, cpu_exclusive_val, fail_label);
1640     tcg_temp_free_i64(tmp);
1641
1642     if (is_pair) {
1643         TCGv_i64 addrhi = tcg_temp_new_i64();
1644         TCGv_i64 tmphi = tcg_temp_new_i64();
1645
1646         tcg_gen_addi_i64(addrhi, addr, 1 << size);
1647         tcg_gen_qemu_ld_i64(tmphi, addrhi, get_mem_index(s), MO_TE + size);
1648         tcg_gen_brcond_i64(TCG_COND_NE, tmphi, cpu_exclusive_high, fail_label);
1649
1650         tcg_temp_free_i64(tmphi);
1651         tcg_temp_free_i64(addrhi);
1652     }
1653
1654     /* We seem to still have the exclusive monitor, so do the store */
1655     tcg_gen_qemu_st_i64(cpu_reg(s, rt), addr, get_mem_index(s), MO_TE + size);
1656     if (is_pair) {
1657         TCGv_i64 addrhi = tcg_temp_new_i64();
1658
1659         tcg_gen_addi_i64(addrhi, addr, 1 << size);
1660         tcg_gen_qemu_st_i64(cpu_reg(s, rt2), addrhi,
1661                             get_mem_index(s), MO_TE + size);
1662         tcg_temp_free_i64(addrhi);
1663     }
1664
1665     tcg_temp_free_i64(addr);
1666
1667     tcg_gen_movi_i64(cpu_reg(s, rd), 0);
1668     tcg_gen_br(done_label);
1669     gen_set_label(fail_label);
1670     tcg_gen_movi_i64(cpu_reg(s, rd), 1);
1671     gen_set_label(done_label);
1672     tcg_gen_movi_i64(cpu_exclusive_addr, -1);
1673
1674 }
1675 #endif
1676
1677 /* C3.3.6 Load/store exclusive
1678  *
1679  *  31 30 29         24  23  22   21  20  16  15  14   10 9    5 4    0
1680  * +-----+-------------+----+---+----+------+----+-------+------+------+
1681  * | sz  | 0 0 1 0 0 0 | o2 | L | o1 |  Rs  | o0 |  Rt2  |  Rn  | Rt   |
1682  * +-----+-------------+----+---+----+------+----+-------+------+------+
1683  *
1684  *  sz: 00 -> 8 bit, 01 -> 16 bit, 10 -> 32 bit, 11 -> 64 bit
1685  *   L: 0 -> store, 1 -> load
1686  *  o2: 0 -> exclusive, 1 -> not
1687  *  o1: 0 -> single register, 1 -> register pair
1688  *  o0: 1 -> load-acquire/store-release, 0 -> not
1689  *
1690  *  o0 == 0 AND o2 == 1 is un-allocated
1691  *  o1 == 1 is un-allocated except for 32 and 64 bit sizes
1692  */
1693 static void disas_ldst_excl(DisasContext *s, uint32_t insn)
1694 {
1695     int rt = extract32(insn, 0, 5);
1696     int rn = extract32(insn, 5, 5);
1697     int rt2 = extract32(insn, 10, 5);
1698     int is_lasr = extract32(insn, 15, 1);
1699     int rs = extract32(insn, 16, 5);
1700     int is_pair = extract32(insn, 21, 1);
1701     int is_store = !extract32(insn, 22, 1);
1702     int is_excl = !extract32(insn, 23, 1);
1703     int size = extract32(insn, 30, 2);
1704     TCGv_i64 tcg_addr;
1705
1706     if ((!is_excl && !is_lasr) ||
1707         (is_pair && size < 2)) {
1708         unallocated_encoding(s);
1709         return;
1710     }
1711
1712     if (rn == 31) {
1713         gen_check_sp_alignment(s);
1714     }
1715     tcg_addr = read_cpu_reg_sp(s, rn, 1);
1716
1717     /* Note that since TCG is single threaded load-acquire/store-release
1718      * semantics require no extra if (is_lasr) { ... } handling.
1719      */
1720
1721     if (is_excl) {
1722         if (!is_store) {
1723             gen_load_exclusive(s, rt, rt2, tcg_addr, size, is_pair);
1724         } else {
1725             gen_store_exclusive(s, rs, rt, rt2, tcg_addr, size, is_pair);
1726         }
1727     } else {
1728         TCGv_i64 tcg_rt = cpu_reg(s, rt);
1729         if (is_store) {
1730             do_gpr_st(s, tcg_rt, tcg_addr, size);
1731         } else {
1732             do_gpr_ld(s, tcg_rt, tcg_addr, size, false, false);
1733         }
1734         if (is_pair) {
1735             TCGv_i64 tcg_rt2 = cpu_reg(s, rt);
1736             tcg_gen_addi_i64(tcg_addr, tcg_addr, 1 << size);
1737             if (is_store) {
1738                 do_gpr_st(s, tcg_rt2, tcg_addr, size);
1739             } else {
1740                 do_gpr_ld(s, tcg_rt2, tcg_addr, size, false, false);
1741             }
1742         }
1743     }
1744 }
1745
1746 /*
1747  * C3.3.5 Load register (literal)
1748  *
1749  *  31 30 29   27  26 25 24 23                5 4     0
1750  * +-----+-------+---+-----+-------------------+-------+
1751  * | opc | 0 1 1 | V | 0 0 |     imm19         |  Rt   |
1752  * +-----+-------+---+-----+-------------------+-------+
1753  *
1754  * V: 1 -> vector (simd/fp)
1755  * opc (non-vector): 00 -> 32 bit, 01 -> 64 bit,
1756  *                   10-> 32 bit signed, 11 -> prefetch
1757  * opc (vector): 00 -> 32 bit, 01 -> 64 bit, 10 -> 128 bit (11 unallocated)
1758  */
1759 static void disas_ld_lit(DisasContext *s, uint32_t insn)
1760 {
1761     int rt = extract32(insn, 0, 5);
1762     int64_t imm = sextract32(insn, 5, 19) << 2;
1763     bool is_vector = extract32(insn, 26, 1);
1764     int opc = extract32(insn, 30, 2);
1765     bool is_signed = false;
1766     int size = 2;
1767     TCGv_i64 tcg_rt, tcg_addr;
1768
1769     if (is_vector) {
1770         if (opc == 3) {
1771             unallocated_encoding(s);
1772             return;
1773         }
1774         size = 2 + opc;
1775         if (!fp_access_check(s)) {
1776             return;
1777         }
1778     } else {
1779         if (opc == 3) {
1780             /* PRFM (literal) : prefetch */
1781             return;
1782         }
1783         size = 2 + extract32(opc, 0, 1);
1784         is_signed = extract32(opc, 1, 1);
1785     }
1786
1787     tcg_rt = cpu_reg(s, rt);
1788
1789     tcg_addr = tcg_const_i64((s->pc - 4) + imm);
1790     if (is_vector) {
1791         do_fp_ld(s, rt, tcg_addr, size);
1792     } else {
1793         do_gpr_ld(s, tcg_rt, tcg_addr, size, is_signed, false);
1794     }
1795     tcg_temp_free_i64(tcg_addr);
1796 }
1797
1798 /*
1799  * C5.6.80 LDNP (Load Pair - non-temporal hint)
1800  * C5.6.81 LDP (Load Pair - non vector)
1801  * C5.6.82 LDPSW (Load Pair Signed Word - non vector)
1802  * C5.6.176 STNP (Store Pair - non-temporal hint)
1803  * C5.6.177 STP (Store Pair - non vector)
1804  * C6.3.165 LDNP (Load Pair of SIMD&FP - non-temporal hint)
1805  * C6.3.165 LDP (Load Pair of SIMD&FP)
1806  * C6.3.284 STNP (Store Pair of SIMD&FP - non-temporal hint)
1807  * C6.3.284 STP (Store Pair of SIMD&FP)
1808  *
1809  *  31 30 29   27  26  25 24   23  22 21   15 14   10 9    5 4    0
1810  * +-----+-------+---+---+-------+---+-----------------------------+
1811  * | opc | 1 0 1 | V | 0 | index | L |  imm7 |  Rt2  |  Rn  | Rt   |
1812  * +-----+-------+---+---+-------+---+-------+-------+------+------+
1813  *
1814  * opc: LDP/STP/LDNP/STNP        00 -> 32 bit, 10 -> 64 bit
1815  *      LDPSW                    01
1816  *      LDP/STP/LDNP/STNP (SIMD) 00 -> 32 bit, 01 -> 64 bit, 10 -> 128 bit
1817  *   V: 0 -> GPR, 1 -> Vector
1818  * idx: 00 -> signed offset with non-temporal hint, 01 -> post-index,
1819  *      10 -> signed offset, 11 -> pre-index
1820  *   L: 0 -> Store 1 -> Load
1821  *
1822  * Rt, Rt2 = GPR or SIMD registers to be stored
1823  * Rn = general purpose register containing address
1824  * imm7 = signed offset (multiple of 4 or 8 depending on size)
1825  */
1826 static void disas_ldst_pair(DisasContext *s, uint32_t insn)
1827 {
1828     int rt = extract32(insn, 0, 5);
1829     int rn = extract32(insn, 5, 5);
1830     int rt2 = extract32(insn, 10, 5);
1831     int64_t offset = sextract32(insn, 15, 7);
1832     int index = extract32(insn, 23, 2);
1833     bool is_vector = extract32(insn, 26, 1);
1834     bool is_load = extract32(insn, 22, 1);
1835     int opc = extract32(insn, 30, 2);
1836
1837     bool is_signed = false;
1838     bool postindex = false;
1839     bool wback = false;
1840
1841     TCGv_i64 tcg_addr; /* calculated address */
1842     int size;
1843
1844     if (opc == 3) {
1845         unallocated_encoding(s);
1846         return;
1847     }
1848
1849     if (is_vector) {
1850         size = 2 + opc;
1851     } else {
1852         size = 2 + extract32(opc, 1, 1);
1853         is_signed = extract32(opc, 0, 1);
1854         if (!is_load && is_signed) {
1855             unallocated_encoding(s);
1856             return;
1857         }
1858     }
1859
1860     switch (index) {
1861     case 1: /* post-index */
1862         postindex = true;
1863         wback = true;
1864         break;
1865     case 0:
1866         /* signed offset with "non-temporal" hint. Since we don't emulate
1867          * caches we don't care about hints to the cache system about
1868          * data access patterns, and handle this identically to plain
1869          * signed offset.
1870          */
1871         if (is_signed) {
1872             /* There is no non-temporal-hint version of LDPSW */
1873             unallocated_encoding(s);
1874             return;
1875         }
1876         postindex = false;
1877         break;
1878     case 2: /* signed offset, rn not updated */
1879         postindex = false;
1880         break;
1881     case 3: /* pre-index */
1882         postindex = false;
1883         wback = true;
1884         break;
1885     }
1886
1887     if (is_vector && !fp_access_check(s)) {
1888         return;
1889     }
1890
1891     offset <<= size;
1892
1893     if (rn == 31) {
1894         gen_check_sp_alignment(s);
1895     }
1896
1897     tcg_addr = read_cpu_reg_sp(s, rn, 1);
1898
1899     if (!postindex) {
1900         tcg_gen_addi_i64(tcg_addr, tcg_addr, offset);
1901     }
1902
1903     if (is_vector) {
1904         if (is_load) {
1905             do_fp_ld(s, rt, tcg_addr, size);
1906         } else {
1907             do_fp_st(s, rt, tcg_addr, size);
1908         }
1909     } else {
1910         TCGv_i64 tcg_rt = cpu_reg(s, rt);
1911         if (is_load) {
1912             do_gpr_ld(s, tcg_rt, tcg_addr, size, is_signed, false);
1913         } else {
1914             do_gpr_st(s, tcg_rt, tcg_addr, size);
1915         }
1916     }
1917     tcg_gen_addi_i64(tcg_addr, tcg_addr, 1 << size);
1918     if (is_vector) {
1919         if (is_load) {
1920             do_fp_ld(s, rt2, tcg_addr, size);
1921         } else {
1922             do_fp_st(s, rt2, tcg_addr, size);
1923         }
1924     } else {
1925         TCGv_i64 tcg_rt2 = cpu_reg(s, rt2);
1926         if (is_load) {
1927             do_gpr_ld(s, tcg_rt2, tcg_addr, size, is_signed, false);
1928         } else {
1929             do_gpr_st(s, tcg_rt2, tcg_addr, size);
1930         }
1931     }
1932
1933     if (wback) {
1934         if (postindex) {
1935             tcg_gen_addi_i64(tcg_addr, tcg_addr, offset - (1 << size));
1936         } else {
1937             tcg_gen_subi_i64(tcg_addr, tcg_addr, 1 << size);
1938         }
1939         tcg_gen_mov_i64(cpu_reg_sp(s, rn), tcg_addr);
1940     }
1941 }
1942
1943 /*
1944  * C3.3.8 Load/store (immediate post-indexed)
1945  * C3.3.9 Load/store (immediate pre-indexed)
1946  * C3.3.12 Load/store (unscaled immediate)
1947  *
1948  * 31 30 29   27  26 25 24 23 22 21  20    12 11 10 9    5 4    0
1949  * +----+-------+---+-----+-----+---+--------+-----+------+------+
1950  * |size| 1 1 1 | V | 0 0 | opc | 0 |  imm9  | idx |  Rn  |  Rt  |
1951  * +----+-------+---+-----+-----+---+--------+-----+------+------+
1952  *
1953  * idx = 01 -> post-indexed, 11 pre-indexed, 00 unscaled imm. (no writeback)
1954          10 -> unprivileged
1955  * V = 0 -> non-vector
1956  * size: 00 -> 8 bit, 01 -> 16 bit, 10 -> 32 bit, 11 -> 64bit
1957  * opc: 00 -> store, 01 -> loadu, 10 -> loads 64, 11 -> loads 32
1958  */
1959 static void disas_ldst_reg_imm9(DisasContext *s, uint32_t insn)
1960 {
1961     int rt = extract32(insn, 0, 5);
1962     int rn = extract32(insn, 5, 5);
1963     int imm9 = sextract32(insn, 12, 9);
1964     int opc = extract32(insn, 22, 2);
1965     int size = extract32(insn, 30, 2);
1966     int idx = extract32(insn, 10, 2);
1967     bool is_signed = false;
1968     bool is_store = false;
1969     bool is_extended = false;
1970     bool is_unpriv = (idx == 2);
1971     bool is_vector = extract32(insn, 26, 1);
1972     bool post_index;
1973     bool writeback;
1974
1975     TCGv_i64 tcg_addr;
1976
1977     if (is_vector) {
1978         size |= (opc & 2) << 1;
1979         if (size > 4 || is_unpriv) {
1980             unallocated_encoding(s);
1981             return;
1982         }
1983         is_store = ((opc & 1) == 0);
1984         if (!fp_access_check(s)) {
1985             return;
1986         }
1987     } else {
1988         if (size == 3 && opc == 2) {
1989             /* PRFM - prefetch */
1990             if (is_unpriv) {
1991                 unallocated_encoding(s);
1992                 return;
1993             }
1994             return;
1995         }
1996         if (opc == 3 && size > 1) {
1997             unallocated_encoding(s);
1998             return;
1999         }
2000         is_store = (opc == 0);
2001         is_signed = opc & (1<<1);
2002         is_extended = (size < 3) && (opc & 1);
2003     }
2004
2005     switch (idx) {
2006     case 0:
2007     case 2:
2008         post_index = false;
2009         writeback = false;
2010         break;
2011     case 1:
2012         post_index = true;
2013         writeback = true;
2014         break;
2015     case 3:
2016         post_index = false;
2017         writeback = true;
2018         break;
2019     }
2020
2021     if (rn == 31) {
2022         gen_check_sp_alignment(s);
2023     }
2024     tcg_addr = read_cpu_reg_sp(s, rn, 1);
2025
2026     if (!post_index) {
2027         tcg_gen_addi_i64(tcg_addr, tcg_addr, imm9);
2028     }
2029
2030     if (is_vector) {
2031         if (is_store) {
2032             do_fp_st(s, rt, tcg_addr, size);
2033         } else {
2034             do_fp_ld(s, rt, tcg_addr, size);
2035         }
2036     } else {
2037         TCGv_i64 tcg_rt = cpu_reg(s, rt);
2038         int memidx = is_unpriv ? 1 : get_mem_index(s);
2039
2040         if (is_store) {
2041             do_gpr_st_memidx(s, tcg_rt, tcg_addr, size, memidx);
2042         } else {
2043             do_gpr_ld_memidx(s, tcg_rt, tcg_addr, size,
2044                              is_signed, is_extended, memidx);
2045         }
2046     }
2047
2048     if (writeback) {
2049         TCGv_i64 tcg_rn = cpu_reg_sp(s, rn);
2050         if (post_index) {
2051             tcg_gen_addi_i64(tcg_addr, tcg_addr, imm9);
2052         }
2053         tcg_gen_mov_i64(tcg_rn, tcg_addr);
2054     }
2055 }
2056
2057 /*
2058  * C3.3.10 Load/store (register offset)
2059  *
2060  * 31 30 29   27  26 25 24 23 22 21  20  16 15 13 12 11 10 9  5 4  0
2061  * +----+-------+---+-----+-----+---+------+-----+--+-----+----+----+
2062  * |size| 1 1 1 | V | 0 0 | opc | 1 |  Rm  | opt | S| 1 0 | Rn | Rt |
2063  * +----+-------+---+-----+-----+---+------+-----+--+-----+----+----+
2064  *
2065  * For non-vector:
2066  *   size: 00-> byte, 01 -> 16 bit, 10 -> 32bit, 11 -> 64bit
2067  *   opc: 00 -> store, 01 -> loadu, 10 -> loads 64, 11 -> loads 32
2068  * For vector:
2069  *   size is opc<1>:size<1:0> so 100 -> 128 bit; 110 and 111 unallocated
2070  *   opc<0>: 0 -> store, 1 -> load
2071  * V: 1 -> vector/simd
2072  * opt: extend encoding (see DecodeRegExtend)
2073  * S: if S=1 then scale (essentially index by sizeof(size))
2074  * Rt: register to transfer into/out of
2075  * Rn: address register or SP for base
2076  * Rm: offset register or ZR for offset
2077  */
2078 static void disas_ldst_reg_roffset(DisasContext *s, uint32_t insn)
2079 {
2080     int rt = extract32(insn, 0, 5);
2081     int rn = extract32(insn, 5, 5);
2082     int shift = extract32(insn, 12, 1);
2083     int rm = extract32(insn, 16, 5);
2084     int opc = extract32(insn, 22, 2);
2085     int opt = extract32(insn, 13, 3);
2086     int size = extract32(insn, 30, 2);
2087     bool is_signed = false;
2088     bool is_store = false;
2089     bool is_extended = false;
2090     bool is_vector = extract32(insn, 26, 1);
2091
2092     TCGv_i64 tcg_rm;
2093     TCGv_i64 tcg_addr;
2094
2095     if (extract32(opt, 1, 1) == 0) {
2096         unallocated_encoding(s);
2097         return;
2098     }
2099
2100     if (is_vector) {
2101         size |= (opc & 2) << 1;
2102         if (size > 4) {
2103             unallocated_encoding(s);
2104             return;
2105         }
2106         is_store = !extract32(opc, 0, 1);
2107         if (!fp_access_check(s)) {
2108             return;
2109         }
2110     } else {
2111         if (size == 3 && opc == 2) {
2112             /* PRFM - prefetch */
2113             return;
2114         }
2115         if (opc == 3 && size > 1) {
2116             unallocated_encoding(s);
2117             return;
2118         }
2119         is_store = (opc == 0);
2120         is_signed = extract32(opc, 1, 1);
2121         is_extended = (size < 3) && extract32(opc, 0, 1);
2122     }
2123
2124     if (rn == 31) {
2125         gen_check_sp_alignment(s);
2126     }
2127     tcg_addr = read_cpu_reg_sp(s, rn, 1);
2128
2129     tcg_rm = read_cpu_reg(s, rm, 1);
2130     ext_and_shift_reg(tcg_rm, tcg_rm, opt, shift ? size : 0);
2131
2132     tcg_gen_add_i64(tcg_addr, tcg_addr, tcg_rm);
2133
2134     if (is_vector) {
2135         if (is_store) {
2136             do_fp_st(s, rt, tcg_addr, size);
2137         } else {
2138             do_fp_ld(s, rt, tcg_addr, size);
2139         }
2140     } else {
2141         TCGv_i64 tcg_rt = cpu_reg(s, rt);
2142         if (is_store) {
2143             do_gpr_st(s, tcg_rt, tcg_addr, size);
2144         } else {
2145             do_gpr_ld(s, tcg_rt, tcg_addr, size, is_signed, is_extended);
2146         }
2147     }
2148 }
2149
2150 /*
2151  * C3.3.13 Load/store (unsigned immediate)
2152  *
2153  * 31 30 29   27  26 25 24 23 22 21        10 9     5
2154  * +----+-------+---+-----+-----+------------+-------+------+
2155  * |size| 1 1 1 | V | 0 1 | opc |   imm12    |  Rn   |  Rt  |
2156  * +----+-------+---+-----+-----+------------+-------+------+
2157  *
2158  * For non-vector:
2159  *   size: 00-> byte, 01 -> 16 bit, 10 -> 32bit, 11 -> 64bit
2160  *   opc: 00 -> store, 01 -> loadu, 10 -> loads 64, 11 -> loads 32
2161  * For vector:
2162  *   size is opc<1>:size<1:0> so 100 -> 128 bit; 110 and 111 unallocated
2163  *   opc<0>: 0 -> store, 1 -> load
2164  * Rn: base address register (inc SP)
2165  * Rt: target register
2166  */
2167 static void disas_ldst_reg_unsigned_imm(DisasContext *s, uint32_t insn)
2168 {
2169     int rt = extract32(insn, 0, 5);
2170     int rn = extract32(insn, 5, 5);
2171     unsigned int imm12 = extract32(insn, 10, 12);
2172     bool is_vector = extract32(insn, 26, 1);
2173     int size = extract32(insn, 30, 2);
2174     int opc = extract32(insn, 22, 2);
2175     unsigned int offset;
2176
2177     TCGv_i64 tcg_addr;
2178
2179     bool is_store;
2180     bool is_signed = false;
2181     bool is_extended = false;
2182
2183     if (is_vector) {
2184         size |= (opc & 2) << 1;
2185         if (size > 4) {
2186             unallocated_encoding(s);
2187             return;
2188         }
2189         is_store = !extract32(opc, 0, 1);
2190         if (!fp_access_check(s)) {
2191             return;
2192         }
2193     } else {
2194         if (size == 3 && opc == 2) {
2195             /* PRFM - prefetch */
2196             return;
2197         }
2198         if (opc == 3 && size > 1) {
2199             unallocated_encoding(s);
2200             return;
2201         }
2202         is_store = (opc == 0);
2203         is_signed = extract32(opc, 1, 1);
2204         is_extended = (size < 3) && extract32(opc, 0, 1);
2205     }
2206
2207     if (rn == 31) {
2208         gen_check_sp_alignment(s);
2209     }
2210     tcg_addr = read_cpu_reg_sp(s, rn, 1);
2211     offset = imm12 << size;
2212     tcg_gen_addi_i64(tcg_addr, tcg_addr, offset);
2213
2214     if (is_vector) {
2215         if (is_store) {
2216             do_fp_st(s, rt, tcg_addr, size);
2217         } else {
2218             do_fp_ld(s, rt, tcg_addr, size);
2219         }
2220     } else {
2221         TCGv_i64 tcg_rt = cpu_reg(s, rt);
2222         if (is_store) {
2223             do_gpr_st(s, tcg_rt, tcg_addr, size);
2224         } else {
2225             do_gpr_ld(s, tcg_rt, tcg_addr, size, is_signed, is_extended);
2226         }
2227     }
2228 }
2229
2230 /* Load/store register (all forms) */
2231 static void disas_ldst_reg(DisasContext *s, uint32_t insn)
2232 {
2233     switch (extract32(insn, 24, 2)) {
2234     case 0:
2235         if (extract32(insn, 21, 1) == 1 && extract32(insn, 10, 2) == 2) {
2236             disas_ldst_reg_roffset(s, insn);
2237         } else {
2238             /* Load/store register (unscaled immediate)
2239              * Load/store immediate pre/post-indexed
2240              * Load/store register unprivileged
2241              */
2242             disas_ldst_reg_imm9(s, insn);
2243         }
2244         break;
2245     case 1:
2246         disas_ldst_reg_unsigned_imm(s, insn);
2247         break;
2248     default:
2249         unallocated_encoding(s);
2250         break;
2251     }
2252 }
2253
2254 /* C3.3.1 AdvSIMD load/store multiple structures
2255  *
2256  *  31  30  29           23 22  21         16 15    12 11  10 9    5 4    0
2257  * +---+---+---------------+---+-------------+--------+------+------+------+
2258  * | 0 | Q | 0 0 1 1 0 0 0 | L | 0 0 0 0 0 0 | opcode | size |  Rn  |  Rt  |
2259  * +---+---+---------------+---+-------------+--------+------+------+------+
2260  *
2261  * C3.3.2 AdvSIMD load/store multiple structures (post-indexed)
2262  *
2263  *  31  30  29           23 22  21  20     16 15    12 11  10 9    5 4    0
2264  * +---+---+---------------+---+---+---------+--------+------+------+------+
2265  * | 0 | Q | 0 0 1 1 0 0 1 | L | 0 |   Rm    | opcode | size |  Rn  |  Rt  |
2266  * +---+---+---------------+---+---+---------+--------+------+------+------+
2267  *
2268  * Rt: first (or only) SIMD&FP register to be transferred
2269  * Rn: base address or SP
2270  * Rm (post-index only): post-index register (when !31) or size dependent #imm
2271  */
2272 static void disas_ldst_multiple_struct(DisasContext *s, uint32_t insn)
2273 {
2274     int rt = extract32(insn, 0, 5);
2275     int rn = extract32(insn, 5, 5);
2276     int size = extract32(insn, 10, 2);
2277     int opcode = extract32(insn, 12, 4);
2278     bool is_store = !extract32(insn, 22, 1);
2279     bool is_postidx = extract32(insn, 23, 1);
2280     bool is_q = extract32(insn, 30, 1);
2281     TCGv_i64 tcg_addr, tcg_rn;
2282
2283     int ebytes = 1 << size;
2284     int elements = (is_q ? 128 : 64) / (8 << size);
2285     int rpt;    /* num iterations */
2286     int selem;  /* structure elements */
2287     int r;
2288
2289     if (extract32(insn, 31, 1) || extract32(insn, 21, 1)) {
2290         unallocated_encoding(s);
2291         return;
2292     }
2293
2294     /* From the shared decode logic */
2295     switch (opcode) {
2296     case 0x0:
2297         rpt = 1;
2298         selem = 4;
2299         break;
2300     case 0x2:
2301         rpt = 4;
2302         selem = 1;
2303         break;
2304     case 0x4:
2305         rpt = 1;
2306         selem = 3;
2307         break;
2308     case 0x6:
2309         rpt = 3;
2310         selem = 1;
2311         break;
2312     case 0x7:
2313         rpt = 1;
2314         selem = 1;
2315         break;
2316     case 0x8:
2317         rpt = 1;
2318         selem = 2;
2319         break;
2320     case 0xa:
2321         rpt = 2;
2322         selem = 1;
2323         break;
2324     default:
2325         unallocated_encoding(s);
2326         return;
2327     }
2328
2329     if (size == 3 && !is_q && selem != 1) {
2330         /* reserved */
2331         unallocated_encoding(s);
2332         return;
2333     }
2334
2335     if (!fp_access_check(s)) {
2336         return;
2337     }
2338
2339     if (rn == 31) {
2340         gen_check_sp_alignment(s);
2341     }
2342
2343     tcg_rn = cpu_reg_sp(s, rn);
2344     tcg_addr = tcg_temp_new_i64();
2345     tcg_gen_mov_i64(tcg_addr, tcg_rn);
2346
2347     for (r = 0; r < rpt; r++) {
2348         int e;
2349         for (e = 0; e < elements; e++) {
2350             int tt = (rt + r) % 32;
2351             int xs;
2352             for (xs = 0; xs < selem; xs++) {
2353                 if (is_store) {
2354                     do_vec_st(s, tt, e, tcg_addr, size);
2355                 } else {
2356                     do_vec_ld(s, tt, e, tcg_addr, size);
2357
2358                     /* For non-quad operations, setting a slice of the low
2359                      * 64 bits of the register clears the high 64 bits (in
2360                      * the ARM ARM pseudocode this is implicit in the fact
2361                      * that 'rval' is a 64 bit wide variable). We optimize
2362                      * by noticing that we only need to do this the first
2363                      * time we touch a register.
2364                      */
2365                     if (!is_q && e == 0 && (r == 0 || xs == selem - 1)) {
2366                         clear_vec_high(s, tt);
2367                     }
2368                 }
2369                 tcg_gen_addi_i64(tcg_addr, tcg_addr, ebytes);
2370                 tt = (tt + 1) % 32;
2371             }
2372         }
2373     }
2374
2375     if (is_postidx) {
2376         int rm = extract32(insn, 16, 5);
2377         if (rm == 31) {
2378             tcg_gen_mov_i64(tcg_rn, tcg_addr);
2379         } else {
2380             tcg_gen_add_i64(tcg_rn, tcg_rn, cpu_reg(s, rm));
2381         }
2382     }
2383     tcg_temp_free_i64(tcg_addr);
2384 }
2385
2386 /* C3.3.3 AdvSIMD load/store single structure
2387  *
2388  *  31  30  29           23 22 21 20       16 15 13 12  11  10 9    5 4    0
2389  * +---+---+---------------+-----+-----------+-----+---+------+------+------+
2390  * | 0 | Q | 0 0 1 1 0 1 0 | L R | 0 0 0 0 0 | opc | S | size |  Rn  |  Rt  |
2391  * +---+---+---------------+-----+-----------+-----+---+------+------+------+
2392  *
2393  * C3.3.4 AdvSIMD load/store single structure (post-indexed)
2394  *
2395  *  31  30  29           23 22 21 20       16 15 13 12  11  10 9    5 4    0
2396  * +---+---+---------------+-----+-----------+-----+---+------+------+------+
2397  * | 0 | Q | 0 0 1 1 0 1 1 | L R |     Rm    | opc | S | size |  Rn  |  Rt  |
2398  * +---+---+---------------+-----+-----------+-----+---+------+------+------+
2399  *
2400  * Rt: first (or only) SIMD&FP register to be transferred
2401  * Rn: base address or SP
2402  * Rm (post-index only): post-index register (when !31) or size dependent #imm
2403  * index = encoded in Q:S:size dependent on size
2404  *
2405  * lane_size = encoded in R, opc
2406  * transfer width = encoded in opc, S, size
2407  */
2408 static void disas_ldst_single_struct(DisasContext *s, uint32_t insn)
2409 {
2410     int rt = extract32(insn, 0, 5);
2411     int rn = extract32(insn, 5, 5);
2412     int size = extract32(insn, 10, 2);
2413     int S = extract32(insn, 12, 1);
2414     int opc = extract32(insn, 13, 3);
2415     int R = extract32(insn, 21, 1);
2416     int is_load = extract32(insn, 22, 1);
2417     int is_postidx = extract32(insn, 23, 1);
2418     int is_q = extract32(insn, 30, 1);
2419
2420     int scale = extract32(opc, 1, 2);
2421     int selem = (extract32(opc, 0, 1) << 1 | R) + 1;
2422     bool replicate = false;
2423     int index = is_q << 3 | S << 2 | size;
2424     int ebytes, xs;
2425     TCGv_i64 tcg_addr, tcg_rn;
2426
2427     switch (scale) {
2428     case 3:
2429         if (!is_load || S) {
2430             unallocated_encoding(s);
2431             return;
2432         }
2433         scale = size;
2434         replicate = true;
2435         break;
2436     case 0:
2437         break;
2438     case 1:
2439         if (extract32(size, 0, 1)) {
2440             unallocated_encoding(s);
2441             return;
2442         }
2443         index >>= 1;
2444         break;
2445     case 2:
2446         if (extract32(size, 1, 1)) {
2447             unallocated_encoding(s);
2448             return;
2449         }
2450         if (!extract32(size, 0, 1)) {
2451             index >>= 2;
2452         } else {
2453             if (S) {
2454                 unallocated_encoding(s);
2455                 return;
2456             }
2457             index >>= 3;
2458             scale = 3;
2459         }
2460         break;
2461     default:
2462         g_assert_not_reached();
2463     }
2464
2465     if (!fp_access_check(s)) {
2466         return;
2467     }
2468
2469     ebytes = 1 << scale;
2470
2471     if (rn == 31) {
2472         gen_check_sp_alignment(s);
2473     }
2474
2475     tcg_rn = cpu_reg_sp(s, rn);
2476     tcg_addr = tcg_temp_new_i64();
2477     tcg_gen_mov_i64(tcg_addr, tcg_rn);
2478
2479     for (xs = 0; xs < selem; xs++) {
2480         if (replicate) {
2481             /* Load and replicate to all elements */
2482             uint64_t mulconst;
2483             TCGv_i64 tcg_tmp = tcg_temp_new_i64();
2484
2485             tcg_gen_qemu_ld_i64(tcg_tmp, tcg_addr,
2486                                 get_mem_index(s), MO_TE + scale);
2487             switch (scale) {
2488             case 0:
2489                 mulconst = 0x0101010101010101ULL;
2490                 break;
2491             case 1:
2492                 mulconst = 0x0001000100010001ULL;
2493                 break;
2494             case 2:
2495                 mulconst = 0x0000000100000001ULL;
2496                 break;
2497             case 3:
2498                 mulconst = 0;
2499                 break;
2500             default:
2501                 g_assert_not_reached();
2502             }
2503             if (mulconst) {
2504                 tcg_gen_muli_i64(tcg_tmp, tcg_tmp, mulconst);
2505             }
2506             write_vec_element(s, tcg_tmp, rt, 0, MO_64);
2507             if (is_q) {
2508                 write_vec_element(s, tcg_tmp, rt, 1, MO_64);
2509             } else {
2510                 clear_vec_high(s, rt);
2511             }
2512             tcg_temp_free_i64(tcg_tmp);
2513         } else {
2514             /* Load/store one element per register */
2515             if (is_load) {
2516                 do_vec_ld(s, rt, index, tcg_addr, MO_TE + scale);
2517             } else {
2518                 do_vec_st(s, rt, index, tcg_addr, MO_TE + scale);
2519             }
2520         }
2521         tcg_gen_addi_i64(tcg_addr, tcg_addr, ebytes);
2522         rt = (rt + 1) % 32;
2523     }
2524
2525     if (is_postidx) {
2526         int rm = extract32(insn, 16, 5);
2527         if (rm == 31) {
2528             tcg_gen_mov_i64(tcg_rn, tcg_addr);
2529         } else {
2530             tcg_gen_add_i64(tcg_rn, tcg_rn, cpu_reg(s, rm));
2531         }
2532     }
2533     tcg_temp_free_i64(tcg_addr);
2534 }
2535
2536 /* C3.3 Loads and stores */
2537 static void disas_ldst(DisasContext *s, uint32_t insn)
2538 {
2539     switch (extract32(insn, 24, 6)) {
2540     case 0x08: /* Load/store exclusive */
2541         disas_ldst_excl(s, insn);
2542         break;
2543     case 0x18: case 0x1c: /* Load register (literal) */
2544         disas_ld_lit(s, insn);
2545         break;
2546     case 0x28: case 0x29:
2547     case 0x2c: case 0x2d: /* Load/store pair (all forms) */
2548         disas_ldst_pair(s, insn);
2549         break;
2550     case 0x38: case 0x39:
2551     case 0x3c: case 0x3d: /* Load/store register (all forms) */
2552         disas_ldst_reg(s, insn);
2553         break;
2554     case 0x0c: /* AdvSIMD load/store multiple structures */
2555         disas_ldst_multiple_struct(s, insn);
2556         break;
2557     case 0x0d: /* AdvSIMD load/store single structure */
2558         disas_ldst_single_struct(s, insn);
2559         break;
2560     default:
2561         unallocated_encoding(s);
2562         break;
2563     }
2564 }
2565
2566 /* C3.4.6 PC-rel. addressing
2567  *   31  30   29 28       24 23                5 4    0
2568  * +----+-------+-----------+-------------------+------+
2569  * | op | immlo | 1 0 0 0 0 |       immhi       |  Rd  |
2570  * +----+-------+-----------+-------------------+------+
2571  */
2572 static void disas_pc_rel_adr(DisasContext *s, uint32_t insn)
2573 {
2574     unsigned int page, rd;
2575     uint64_t base;
2576     int64_t offset;
2577
2578     page = extract32(insn, 31, 1);
2579     /* SignExtend(immhi:immlo) -> offset */
2580     offset = ((int64_t)sextract32(insn, 5, 19) << 2) | extract32(insn, 29, 2);
2581     rd = extract32(insn, 0, 5);
2582     base = s->pc - 4;
2583
2584     if (page) {
2585         /* ADRP (page based) */
2586         base &= ~0xfff;
2587         offset <<= 12;
2588     }
2589
2590     tcg_gen_movi_i64(cpu_reg(s, rd), base + offset);
2591 }
2592
2593 /*
2594  * C3.4.1 Add/subtract (immediate)
2595  *
2596  *  31 30 29 28       24 23 22 21         10 9   5 4   0
2597  * +--+--+--+-----------+-----+-------------+-----+-----+
2598  * |sf|op| S| 1 0 0 0 1 |shift|    imm12    |  Rn | Rd  |
2599  * +--+--+--+-----------+-----+-------------+-----+-----+
2600  *
2601  *    sf: 0 -> 32bit, 1 -> 64bit
2602  *    op: 0 -> add  , 1 -> sub
2603  *     S: 1 -> set flags
2604  * shift: 00 -> LSL imm by 0, 01 -> LSL imm by 12
2605  */
2606 static void disas_add_sub_imm(DisasContext *s, uint32_t insn)
2607 {
2608     int rd = extract32(insn, 0, 5);
2609     int rn = extract32(insn, 5, 5);
2610     uint64_t imm = extract32(insn, 10, 12);
2611     int shift = extract32(insn, 22, 2);
2612     bool setflags = extract32(insn, 29, 1);
2613     bool sub_op = extract32(insn, 30, 1);
2614     bool is_64bit = extract32(insn, 31, 1);
2615
2616     TCGv_i64 tcg_rn = cpu_reg_sp(s, rn);
2617     TCGv_i64 tcg_rd = setflags ? cpu_reg(s, rd) : cpu_reg_sp(s, rd);
2618     TCGv_i64 tcg_result;
2619
2620     switch (shift) {
2621     case 0x0:
2622         break;
2623     case 0x1:
2624         imm <<= 12;
2625         break;
2626     default:
2627         unallocated_encoding(s);
2628         return;
2629     }
2630
2631     tcg_result = tcg_temp_new_i64();
2632     if (!setflags) {
2633         if (sub_op) {
2634             tcg_gen_subi_i64(tcg_result, tcg_rn, imm);
2635         } else {
2636             tcg_gen_addi_i64(tcg_result, tcg_rn, imm);
2637         }
2638     } else {
2639         TCGv_i64 tcg_imm = tcg_const_i64(imm);
2640         if (sub_op) {
2641             gen_sub_CC(is_64bit, tcg_result, tcg_rn, tcg_imm);
2642         } else {
2643             gen_add_CC(is_64bit, tcg_result, tcg_rn, tcg_imm);
2644         }
2645         tcg_temp_free_i64(tcg_imm);
2646     }
2647
2648     if (is_64bit) {
2649         tcg_gen_mov_i64(tcg_rd, tcg_result);
2650     } else {
2651         tcg_gen_ext32u_i64(tcg_rd, tcg_result);
2652     }
2653
2654     tcg_temp_free_i64(tcg_result);
2655 }
2656
2657 /* The input should be a value in the bottom e bits (with higher
2658  * bits zero); returns that value replicated into every element
2659  * of size e in a 64 bit integer.
2660  */
2661 static uint64_t bitfield_replicate(uint64_t mask, unsigned int e)
2662 {
2663     assert(e != 0);
2664     while (e < 64) {
2665         mask |= mask << e;
2666         e *= 2;
2667     }
2668     return mask;
2669 }
2670
2671 /* Return a value with the bottom len bits set (where 0 < len <= 64) */
2672 static inline uint64_t bitmask64(unsigned int length)
2673 {
2674     assert(length > 0 && length <= 64);
2675     return ~0ULL >> (64 - length);
2676 }
2677
2678 /* Simplified variant of pseudocode DecodeBitMasks() for the case where we
2679  * only require the wmask. Returns false if the imms/immr/immn are a reserved
2680  * value (ie should cause a guest UNDEF exception), and true if they are
2681  * valid, in which case the decoded bit pattern is written to result.
2682  */
2683 static bool logic_imm_decode_wmask(uint64_t *result, unsigned int immn,
2684                                    unsigned int imms, unsigned int immr)
2685 {
2686     uint64_t mask;
2687     unsigned e, levels, s, r;
2688     int len;
2689
2690     assert(immn < 2 && imms < 64 && immr < 64);
2691
2692     /* The bit patterns we create here are 64 bit patterns which
2693      * are vectors of identical elements of size e = 2, 4, 8, 16, 32 or
2694      * 64 bits each. Each element contains the same value: a run
2695      * of between 1 and e-1 non-zero bits, rotated within the
2696      * element by between 0 and e-1 bits.
2697      *
2698      * The element size and run length are encoded into immn (1 bit)
2699      * and imms (6 bits) as follows:
2700      * 64 bit elements: immn = 1, imms = <length of run - 1>
2701      * 32 bit elements: immn = 0, imms = 0 : <length of run - 1>
2702      * 16 bit elements: immn = 0, imms = 10 : <length of run - 1>
2703      *  8 bit elements: immn = 0, imms = 110 : <length of run - 1>
2704      *  4 bit elements: immn = 0, imms = 1110 : <length of run - 1>
2705      *  2 bit elements: immn = 0, imms = 11110 : <length of run - 1>
2706      * Notice that immn = 0, imms = 11111x is the only combination
2707      * not covered by one of the above options; this is reserved.
2708      * Further, <length of run - 1> all-ones is a reserved pattern.
2709      *
2710      * In all cases the rotation is by immr % e (and immr is 6 bits).
2711      */
2712
2713     /* First determine the element size */
2714     len = 31 - clz32((immn << 6) | (~imms & 0x3f));
2715     if (len < 1) {
2716         /* This is the immn == 0, imms == 0x11111x case */
2717         return false;
2718     }
2719     e = 1 << len;
2720
2721     levels = e - 1;
2722     s = imms & levels;
2723     r = immr & levels;
2724
2725     if (s == levels) {
2726         /* <length of run - 1> mustn't be all-ones. */
2727         return false;
2728     }
2729
2730     /* Create the value of one element: s+1 set bits rotated
2731      * by r within the element (which is e bits wide)...
2732      */
2733     mask = bitmask64(s + 1);
2734     mask = (mask >> r) | (mask << (e - r));
2735     /* ...then replicate the element over the whole 64 bit value */
2736     mask = bitfield_replicate(mask, e);
2737     *result = mask;
2738     return true;
2739 }
2740
2741 /* C3.4.4 Logical (immediate)
2742  *   31  30 29 28         23 22  21  16 15  10 9    5 4    0
2743  * +----+-----+-------------+---+------+------+------+------+
2744  * | sf | opc | 1 0 0 1 0 0 | N | immr | imms |  Rn  |  Rd  |
2745  * +----+-----+-------------+---+------+------+------+------+
2746  */
2747 static void disas_logic_imm(DisasContext *s, uint32_t insn)
2748 {
2749     unsigned int sf, opc, is_n, immr, imms, rn, rd;
2750     TCGv_i64 tcg_rd, tcg_rn;
2751     uint64_t wmask;
2752     bool is_and = false;
2753
2754     sf = extract32(insn, 31, 1);
2755     opc = extract32(insn, 29, 2);
2756     is_n = extract32(insn, 22, 1);
2757     immr = extract32(insn, 16, 6);
2758     imms = extract32(insn, 10, 6);
2759     rn = extract32(insn, 5, 5);
2760     rd = extract32(insn, 0, 5);
2761
2762     if (!sf && is_n) {
2763         unallocated_encoding(s);
2764         return;
2765     }
2766
2767     if (opc == 0x3) { /* ANDS */
2768         tcg_rd = cpu_reg(s, rd);
2769     } else {
2770         tcg_rd = cpu_reg_sp(s, rd);
2771     }
2772     tcg_rn = cpu_reg(s, rn);
2773
2774     if (!logic_imm_decode_wmask(&wmask, is_n, imms, immr)) {
2775         /* some immediate field values are reserved */
2776         unallocated_encoding(s);
2777         return;
2778     }
2779
2780     if (!sf) {
2781         wmask &= 0xffffffff;
2782     }
2783
2784     switch (opc) {
2785     case 0x3: /* ANDS */
2786     case 0x0: /* AND */
2787         tcg_gen_andi_i64(tcg_rd, tcg_rn, wmask);
2788         is_and = true;
2789         break;
2790     case 0x1: /* ORR */
2791         tcg_gen_ori_i64(tcg_rd, tcg_rn, wmask);
2792         break;
2793     case 0x2: /* EOR */
2794         tcg_gen_xori_i64(tcg_rd, tcg_rn, wmask);
2795         break;
2796     default:
2797         assert(FALSE); /* must handle all above */
2798         break;
2799     }
2800
2801     if (!sf && !is_and) {
2802         /* zero extend final result; we know we can skip this for AND
2803          * since the immediate had the high 32 bits clear.
2804          */
2805         tcg_gen_ext32u_i64(tcg_rd, tcg_rd);
2806     }
2807
2808     if (opc == 3) { /* ANDS */
2809         gen_logic_CC(sf, tcg_rd);
2810     }
2811 }
2812
2813 /*
2814  * C3.4.5 Move wide (immediate)
2815  *
2816  *  31 30 29 28         23 22 21 20             5 4    0
2817  * +--+-----+-------------+-----+----------------+------+
2818  * |sf| opc | 1 0 0 1 0 1 |  hw |  imm16         |  Rd  |
2819  * +--+-----+-------------+-----+----------------+------+
2820  *
2821  * sf: 0 -> 32 bit, 1 -> 64 bit
2822  * opc: 00 -> N, 10 -> Z, 11 -> K
2823  * hw: shift/16 (0,16, and sf only 32, 48)
2824  */
2825 static void disas_movw_imm(DisasContext *s, uint32_t insn)
2826 {
2827     int rd = extract32(insn, 0, 5);
2828     uint64_t imm = extract32(insn, 5, 16);
2829     int sf = extract32(insn, 31, 1);
2830     int opc = extract32(insn, 29, 2);
2831     int pos = extract32(insn, 21, 2) << 4;
2832     TCGv_i64 tcg_rd = cpu_reg(s, rd);
2833     TCGv_i64 tcg_imm;
2834
2835     if (!sf && (pos >= 32)) {
2836         unallocated_encoding(s);
2837         return;
2838     }
2839
2840     switch (opc) {
2841     case 0: /* MOVN */
2842     case 2: /* MOVZ */
2843         imm <<= pos;
2844         if (opc == 0) {
2845             imm = ~imm;
2846         }
2847         if (!sf) {
2848             imm &= 0xffffffffu;
2849         }
2850         tcg_gen_movi_i64(tcg_rd, imm);
2851         break;
2852     case 3: /* MOVK */
2853         tcg_imm = tcg_const_i64(imm);
2854         tcg_gen_deposit_i64(tcg_rd, tcg_rd, tcg_imm, pos, 16);
2855         tcg_temp_free_i64(tcg_imm);
2856         if (!sf) {
2857             tcg_gen_ext32u_i64(tcg_rd, tcg_rd);
2858         }
2859         break;
2860     default:
2861         unallocated_encoding(s);
2862         break;
2863     }
2864 }
2865
2866 /* C3.4.2 Bitfield
2867  *   31  30 29 28         23 22  21  16 15  10 9    5 4    0
2868  * +----+-----+-------------+---+------+------+------+------+
2869  * | sf | opc | 1 0 0 1 1 0 | N | immr | imms |  Rn  |  Rd  |
2870  * +----+-----+-------------+---+------+------+------+------+
2871  */
2872 static void disas_bitfield(DisasContext *s, uint32_t insn)
2873 {
2874     unsigned int sf, n, opc, ri, si, rn, rd, bitsize, pos, len;
2875     TCGv_i64 tcg_rd, tcg_tmp;
2876
2877     sf = extract32(insn, 31, 1);
2878     opc = extract32(insn, 29, 2);
2879     n = extract32(insn, 22, 1);
2880     ri = extract32(insn, 16, 6);
2881     si = extract32(insn, 10, 6);
2882     rn = extract32(insn, 5, 5);
2883     rd = extract32(insn, 0, 5);
2884     bitsize = sf ? 64 : 32;
2885
2886     if (sf != n || ri >= bitsize || si >= bitsize || opc > 2) {
2887         unallocated_encoding(s);
2888         return;
2889     }
2890
2891     tcg_rd = cpu_reg(s, rd);
2892     tcg_tmp = read_cpu_reg(s, rn, sf);
2893
2894     /* OPTME: probably worth recognizing common cases of ext{8,16,32}{u,s} */
2895
2896     if (opc != 1) { /* SBFM or UBFM */
2897         tcg_gen_movi_i64(tcg_rd, 0);
2898     }
2899
2900     /* do the bit move operation */
2901     if (si >= ri) {
2902         /* Wd<s-r:0> = Wn<s:r> */
2903         tcg_gen_shri_i64(tcg_tmp, tcg_tmp, ri);
2904         pos = 0;
2905         len = (si - ri) + 1;
2906     } else {
2907         /* Wd<32+s-r,32-r> = Wn<s:0> */
2908         pos = bitsize - ri;
2909         len = si + 1;
2910     }
2911
2912     tcg_gen_deposit_i64(tcg_rd, tcg_rd, tcg_tmp, pos, len);
2913
2914     if (opc == 0) { /* SBFM - sign extend the destination field */
2915         tcg_gen_shli_i64(tcg_rd, tcg_rd, 64 - (pos + len));
2916         tcg_gen_sari_i64(tcg_rd, tcg_rd, 64 - (pos + len));
2917     }
2918
2919     if (!sf) { /* zero extend final result */
2920         tcg_gen_ext32u_i64(tcg_rd, tcg_rd);
2921     }
2922 }
2923
2924 /* C3.4.3 Extract
2925  *   31  30  29 28         23 22   21  20  16 15    10 9    5 4    0
2926  * +----+------+-------------+---+----+------+--------+------+------+
2927  * | sf | op21 | 1 0 0 1 1 1 | N | o0 |  Rm  |  imms  |  Rn  |  Rd  |
2928  * +----+------+-------------+---+----+------+--------+------+------+
2929  */
2930 static void disas_extract(DisasContext *s, uint32_t insn)
2931 {
2932     unsigned int sf, n, rm, imm, rn, rd, bitsize, op21, op0;
2933
2934     sf = extract32(insn, 31, 1);
2935     n = extract32(insn, 22, 1);
2936     rm = extract32(insn, 16, 5);
2937     imm = extract32(insn, 10, 6);
2938     rn = extract32(insn, 5, 5);
2939     rd = extract32(insn, 0, 5);
2940     op21 = extract32(insn, 29, 2);
2941     op0 = extract32(insn, 21, 1);
2942     bitsize = sf ? 64 : 32;
2943
2944     if (sf != n || op21 || op0 || imm >= bitsize) {
2945         unallocated_encoding(s);
2946     } else {
2947         TCGv_i64 tcg_rd, tcg_rm, tcg_rn;
2948
2949         tcg_rd = cpu_reg(s, rd);
2950
2951         if (imm) {
2952             /* OPTME: we can special case rm==rn as a rotate */
2953             tcg_rm = read_cpu_reg(s, rm, sf);
2954             tcg_rn = read_cpu_reg(s, rn, sf);
2955             tcg_gen_shri_i64(tcg_rm, tcg_rm, imm);
2956             tcg_gen_shli_i64(tcg_rn, tcg_rn, bitsize - imm);
2957             tcg_gen_or_i64(tcg_rd, tcg_rm, tcg_rn);
2958             if (!sf) {
2959                 tcg_gen_ext32u_i64(tcg_rd, tcg_rd);
2960             }
2961         } else {
2962             /* tcg shl_i32/shl_i64 is undefined for 32/64 bit shifts,
2963              * so an extract from bit 0 is a special case.
2964              */
2965             if (sf) {
2966                 tcg_gen_mov_i64(tcg_rd, cpu_reg(s, rm));
2967             } else {
2968                 tcg_gen_ext32u_i64(tcg_rd, cpu_reg(s, rm));
2969             }
2970         }
2971
2972     }
2973 }
2974
2975 /* C3.4 Data processing - immediate */
2976 static void disas_data_proc_imm(DisasContext *s, uint32_t insn)
2977 {
2978     switch (extract32(insn, 23, 6)) {
2979     case 0x20: case 0x21: /* PC-rel. addressing */
2980         disas_pc_rel_adr(s, insn);
2981         break;
2982     case 0x22: case 0x23: /* Add/subtract (immediate) */
2983         disas_add_sub_imm(s, insn);
2984         break;
2985     case 0x24: /* Logical (immediate) */
2986         disas_logic_imm(s, insn);
2987         break;
2988     case 0x25: /* Move wide (immediate) */
2989         disas_movw_imm(s, insn);
2990         break;
2991     case 0x26: /* Bitfield */
2992         disas_bitfield(s, insn);
2993         break;
2994     case 0x27: /* Extract */
2995         disas_extract(s, insn);
2996         break;
2997     default:
2998         unallocated_encoding(s);
2999         break;
3000     }
3001 }
3002
3003 /* Shift a TCGv src by TCGv shift_amount, put result in dst.
3004  * Note that it is the caller's responsibility to ensure that the
3005  * shift amount is in range (ie 0..31 or 0..63) and provide the ARM
3006  * mandated semantics for out of range shifts.
3007  */
3008 static void shift_reg(TCGv_i64 dst, TCGv_i64 src, int sf,
3009                       enum a64_shift_type shift_type, TCGv_i64 shift_amount)
3010 {
3011     switch (shift_type) {
3012     case A64_SHIFT_TYPE_LSL:
3013         tcg_gen_shl_i64(dst, src, shift_amount);
3014         break;
3015     case A64_SHIFT_TYPE_LSR:
3016         tcg_gen_shr_i64(dst, src, shift_amount);
3017         break;
3018     case A64_SHIFT_TYPE_ASR:
3019         if (!sf) {
3020             tcg_gen_ext32s_i64(dst, src);
3021         }
3022         tcg_gen_sar_i64(dst, sf ? src : dst, shift_amount);
3023         break;
3024     case A64_SHIFT_TYPE_ROR:
3025         if (sf) {
3026             tcg_gen_rotr_i64(dst, src, shift_amount);
3027         } else {
3028             TCGv_i32 t0, t1;
3029             t0 = tcg_temp_new_i32();
3030             t1 = tcg_temp_new_i32();
3031             tcg_gen_trunc_i64_i32(t0, src);
3032             tcg_gen_trunc_i64_i32(t1, shift_amount);
3033             tcg_gen_rotr_i32(t0, t0, t1);
3034             tcg_gen_extu_i32_i64(dst, t0);
3035             tcg_temp_free_i32(t0);
3036             tcg_temp_free_i32(t1);
3037         }
3038         break;
3039     default:
3040         assert(FALSE); /* all shift types should be handled */
3041         break;
3042     }
3043
3044     if (!sf) { /* zero extend final result */
3045         tcg_gen_ext32u_i64(dst, dst);
3046     }
3047 }
3048
3049 /* Shift a TCGv src by immediate, put result in dst.
3050  * The shift amount must be in range (this should always be true as the
3051  * relevant instructions will UNDEF on bad shift immediates).
3052  */
3053 static void shift_reg_imm(TCGv_i64 dst, TCGv_i64 src, int sf,
3054                           enum a64_shift_type shift_type, unsigned int shift_i)
3055 {
3056     assert(shift_i < (sf ? 64 : 32));
3057
3058     if (shift_i == 0) {
3059         tcg_gen_mov_i64(dst, src);
3060     } else {
3061         TCGv_i64 shift_const;
3062
3063         shift_const = tcg_const_i64(shift_i);
3064         shift_reg(dst, src, sf, shift_type, shift_const);
3065         tcg_temp_free_i64(shift_const);
3066     }
3067 }
3068
3069 /* C3.5.10 Logical (shifted register)
3070  *   31  30 29 28       24 23   22 21  20  16 15    10 9    5 4    0
3071  * +----+-----+-----------+-------+---+------+--------+------+------+
3072  * | sf | opc | 0 1 0 1 0 | shift | N |  Rm  |  imm6  |  Rn  |  Rd  |
3073  * +----+-----+-----------+-------+---+------+--------+------+------+
3074  */
3075 static void disas_logic_reg(DisasContext *s, uint32_t insn)
3076 {
3077     TCGv_i64 tcg_rd, tcg_rn, tcg_rm;
3078     unsigned int sf, opc, shift_type, invert, rm, shift_amount, rn, rd;
3079
3080     sf = extract32(insn, 31, 1);
3081     opc = extract32(insn, 29, 2);
3082     shift_type = extract32(insn, 22, 2);
3083     invert = extract32(insn, 21, 1);
3084     rm = extract32(insn, 16, 5);
3085     shift_amount = extract32(insn, 10, 6);
3086     rn = extract32(insn, 5, 5);
3087     rd = extract32(insn, 0, 5);
3088
3089     if (!sf && (shift_amount & (1 << 5))) {
3090         unallocated_encoding(s);
3091         return;
3092     }
3093
3094     tcg_rd = cpu_reg(s, rd);
3095
3096     if (opc == 1 && shift_amount == 0 && shift_type == 0 && rn == 31) {
3097         /* Unshifted ORR and ORN with WZR/XZR is the standard encoding for
3098          * register-register MOV and MVN, so it is worth special casing.
3099          */
3100         tcg_rm = cpu_reg(s, rm);
3101         if (invert) {
3102             tcg_gen_not_i64(tcg_rd, tcg_rm);
3103             if (!sf) {
3104                 tcg_gen_ext32u_i64(tcg_rd, tcg_rd);
3105             }
3106         } else {
3107             if (sf) {
3108                 tcg_gen_mov_i64(tcg_rd, tcg_rm);
3109             } else {
3110                 tcg_gen_ext32u_i64(tcg_rd, tcg_rm);
3111             }
3112         }
3113         return;
3114     }
3115
3116     tcg_rm = read_cpu_reg(s, rm, sf);
3117
3118     if (shift_amount) {
3119         shift_reg_imm(tcg_rm, tcg_rm, sf, shift_type, shift_amount);
3120     }
3121
3122     tcg_rn = cpu_reg(s, rn);
3123
3124     switch (opc | (invert << 2)) {
3125     case 0: /* AND */
3126     case 3: /* ANDS */
3127         tcg_gen_and_i64(tcg_rd, tcg_rn, tcg_rm);
3128         break;
3129     case 1: /* ORR */
3130         tcg_gen_or_i64(tcg_rd, tcg_rn, tcg_rm);
3131         break;
3132     case 2: /* EOR */
3133         tcg_gen_xor_i64(tcg_rd, tcg_rn, tcg_rm);
3134         break;
3135     case 4: /* BIC */
3136     case 7: /* BICS */
3137         tcg_gen_andc_i64(tcg_rd, tcg_rn, tcg_rm);
3138         break;
3139     case 5: /* ORN */
3140         tcg_gen_orc_i64(tcg_rd, tcg_rn, tcg_rm);
3141         break;
3142     case 6: /* EON */
3143         tcg_gen_eqv_i64(tcg_rd, tcg_rn, tcg_rm);
3144         break;
3145     default:
3146         assert(FALSE);
3147         break;
3148     }
3149
3150     if (!sf) {
3151         tcg_gen_ext32u_i64(tcg_rd, tcg_rd);
3152     }
3153
3154     if (opc == 3) {
3155         gen_logic_CC(sf, tcg_rd);
3156     }
3157 }
3158
3159 /*
3160  * C3.5.1 Add/subtract (extended register)
3161  *
3162  *  31|30|29|28       24|23 22|21|20   16|15  13|12  10|9  5|4  0|
3163  * +--+--+--+-----------+-----+--+-------+------+------+----+----+
3164  * |sf|op| S| 0 1 0 1 1 | opt | 1|  Rm   |option| imm3 | Rn | Rd |
3165  * +--+--+--+-----------+-----+--+-------+------+------+----+----+
3166  *
3167  *  sf: 0 -> 32bit, 1 -> 64bit
3168  *  op: 0 -> add  , 1 -> sub
3169  *   S: 1 -> set flags
3170  * opt: 00
3171  * option: extension type (see DecodeRegExtend)
3172  * imm3: optional shift to Rm
3173  *
3174  * Rd = Rn + LSL(extend(Rm), amount)
3175  */
3176 static void disas_add_sub_ext_reg(DisasContext *s, uint32_t insn)
3177 {
3178     int rd = extract32(insn, 0, 5);
3179     int rn = extract32(insn, 5, 5);
3180     int imm3 = extract32(insn, 10, 3);
3181     int option = extract32(insn, 13, 3);
3182     int rm = extract32(insn, 16, 5);
3183     bool setflags = extract32(insn, 29, 1);
3184     bool sub_op = extract32(insn, 30, 1);
3185     bool sf = extract32(insn, 31, 1);
3186
3187     TCGv_i64 tcg_rm, tcg_rn; /* temps */
3188     TCGv_i64 tcg_rd;
3189     TCGv_i64 tcg_result;
3190
3191     if (imm3 > 4) {
3192         unallocated_encoding(s);
3193         return;
3194     }
3195
3196     /* non-flag setting ops may use SP */
3197     if (!setflags) {
3198         tcg_rd = cpu_reg_sp(s, rd);
3199     } else {
3200         tcg_rd = cpu_reg(s, rd);
3201     }
3202     tcg_rn = read_cpu_reg_sp(s, rn, sf);
3203
3204     tcg_rm = read_cpu_reg(s, rm, sf);
3205     ext_and_shift_reg(tcg_rm, tcg_rm, option, imm3);
3206
3207     tcg_result = tcg_temp_new_i64();
3208
3209     if (!setflags) {
3210         if (sub_op) {
3211             tcg_gen_sub_i64(tcg_result, tcg_rn, tcg_rm);
3212         } else {
3213             tcg_gen_add_i64(tcg_result, tcg_rn, tcg_rm);
3214         }
3215     } else {
3216         if (sub_op) {
3217             gen_sub_CC(sf, tcg_result, tcg_rn, tcg_rm);
3218         } else {
3219             gen_add_CC(sf, tcg_result, tcg_rn, tcg_rm);
3220         }
3221     }
3222
3223     if (sf) {
3224         tcg_gen_mov_i64(tcg_rd, tcg_result);
3225     } else {
3226         tcg_gen_ext32u_i64(tcg_rd, tcg_result);
3227     }
3228
3229     tcg_temp_free_i64(tcg_result);
3230 }
3231
3232 /*
3233  * C3.5.2 Add/subtract (shifted register)
3234  *
3235  *  31 30 29 28       24 23 22 21 20   16 15     10 9    5 4    0
3236  * +--+--+--+-----------+-----+--+-------+---------+------+------+
3237  * |sf|op| S| 0 1 0 1 1 |shift| 0|  Rm   |  imm6   |  Rn  |  Rd  |
3238  * +--+--+--+-----------+-----+--+-------+---------+------+------+
3239  *
3240  *    sf: 0 -> 32bit, 1 -> 64bit
3241  *    op: 0 -> add  , 1 -> sub
3242  *     S: 1 -> set flags
3243  * shift: 00 -> LSL, 01 -> LSR, 10 -> ASR, 11 -> RESERVED
3244  *  imm6: Shift amount to apply to Rm before the add/sub
3245  */
3246 static void disas_add_sub_reg(DisasContext *s, uint32_t insn)
3247 {
3248     int rd = extract32(insn, 0, 5);
3249     int rn = extract32(insn, 5, 5);
3250     int imm6 = extract32(insn, 10, 6);
3251     int rm = extract32(insn, 16, 5);
3252     int shift_type = extract32(insn, 22, 2);
3253     bool setflags = extract32(insn, 29, 1);
3254     bool sub_op = extract32(insn, 30, 1);
3255     bool sf = extract32(insn, 31, 1);
3256
3257     TCGv_i64 tcg_rd = cpu_reg(s, rd);
3258     TCGv_i64 tcg_rn, tcg_rm;
3259     TCGv_i64 tcg_result;
3260
3261     if ((shift_type == 3) || (!sf && (imm6 > 31))) {
3262         unallocated_encoding(s);
3263         return;
3264     }
3265
3266     tcg_rn = read_cpu_reg(s, rn, sf);
3267     tcg_rm = read_cpu_reg(s, rm, sf);
3268
3269     shift_reg_imm(tcg_rm, tcg_rm, sf, shift_type, imm6);
3270
3271     tcg_result = tcg_temp_new_i64();
3272
3273     if (!setflags) {
3274         if (sub_op) {
3275             tcg_gen_sub_i64(tcg_result, tcg_rn, tcg_rm);
3276         } else {
3277             tcg_gen_add_i64(tcg_result, tcg_rn, tcg_rm);
3278         }
3279     } else {
3280         if (sub_op) {
3281             gen_sub_CC(sf, tcg_result, tcg_rn, tcg_rm);
3282         } else {
3283             gen_add_CC(sf, tcg_result, tcg_rn, tcg_rm);
3284         }
3285     }
3286
3287     if (sf) {
3288         tcg_gen_mov_i64(tcg_rd, tcg_result);
3289     } else {
3290         tcg_gen_ext32u_i64(tcg_rd, tcg_result);
3291     }
3292
3293     tcg_temp_free_i64(tcg_result);
3294 }
3295
3296 /* C3.5.9 Data-processing (3 source)
3297
3298    31 30  29 28       24 23 21  20  16  15  14  10 9    5 4    0
3299   +--+------+-----------+------+------+----+------+------+------+
3300   |sf| op54 | 1 1 0 1 1 | op31 |  Rm  | o0 |  Ra  |  Rn  |  Rd  |
3301   +--+------+-----------+------+------+----+------+------+------+
3302
3303  */
3304 static void disas_data_proc_3src(DisasContext *s, uint32_t insn)
3305 {
3306     int rd = extract32(insn, 0, 5);
3307     int rn = extract32(insn, 5, 5);
3308     int ra = extract32(insn, 10, 5);
3309     int rm = extract32(insn, 16, 5);
3310     int op_id = (extract32(insn, 29, 3) << 4) |
3311         (extract32(insn, 21, 3) << 1) |
3312         extract32(insn, 15, 1);
3313     bool sf = extract32(insn, 31, 1);
3314     bool is_sub = extract32(op_id, 0, 1);
3315     bool is_high = extract32(op_id, 2, 1);
3316     bool is_signed = false;
3317     TCGv_i64 tcg_op1;
3318     TCGv_i64 tcg_op2;
3319     TCGv_i64 tcg_tmp;
3320
3321     /* Note that op_id is sf:op54:op31:o0 so it includes the 32/64 size flag */
3322     switch (op_id) {
3323     case 0x42: /* SMADDL */
3324     case 0x43: /* SMSUBL */
3325     case 0x44: /* SMULH */
3326         is_signed = true;
3327         break;
3328     case 0x0: /* MADD (32bit) */
3329     case 0x1: /* MSUB (32bit) */
3330     case 0x40: /* MADD (64bit) */
3331     case 0x41: /* MSUB (64bit) */
3332     case 0x4a: /* UMADDL */
3333     case 0x4b: /* UMSUBL */
3334     case 0x4c: /* UMULH */
3335         break;
3336     default:
3337         unallocated_encoding(s);
3338         return;
3339     }
3340
3341     if (is_high) {
3342         TCGv_i64 low_bits = tcg_temp_new_i64(); /* low bits discarded */
3343         TCGv_i64 tcg_rd = cpu_reg(s, rd);
3344         TCGv_i64 tcg_rn = cpu_reg(s, rn);
3345         TCGv_i64 tcg_rm = cpu_reg(s, rm);
3346
3347         if (is_signed) {
3348             tcg_gen_muls2_i64(low_bits, tcg_rd, tcg_rn, tcg_rm);
3349         } else {
3350             tcg_gen_mulu2_i64(low_bits, tcg_rd, tcg_rn, tcg_rm);
3351         }
3352
3353         tcg_temp_free_i64(low_bits);
3354         return;
3355     }
3356
3357     tcg_op1 = tcg_temp_new_i64();
3358     tcg_op2 = tcg_temp_new_i64();
3359     tcg_tmp = tcg_temp_new_i64();
3360
3361     if (op_id < 0x42) {
3362         tcg_gen_mov_i64(tcg_op1, cpu_reg(s, rn));
3363         tcg_gen_mov_i64(tcg_op2, cpu_reg(s, rm));
3364     } else {
3365         if (is_signed) {
3366             tcg_gen_ext32s_i64(tcg_op1, cpu_reg(s, rn));
3367             tcg_gen_ext32s_i64(tcg_op2, cpu_reg(s, rm));
3368         } else {
3369             tcg_gen_ext32u_i64(tcg_op1, cpu_reg(s, rn));
3370             tcg_gen_ext32u_i64(tcg_op2, cpu_reg(s, rm));
3371         }
3372     }
3373
3374     if (ra == 31 && !is_sub) {
3375         /* Special-case MADD with rA == XZR; it is the standard MUL alias */
3376         tcg_gen_mul_i64(cpu_reg(s, rd), tcg_op1, tcg_op2);
3377     } else {
3378         tcg_gen_mul_i64(tcg_tmp, tcg_op1, tcg_op2);
3379         if (is_sub) {
3380             tcg_gen_sub_i64(cpu_reg(s, rd), cpu_reg(s, ra), tcg_tmp);
3381         } else {
3382             tcg_gen_add_i64(cpu_reg(s, rd), cpu_reg(s, ra), tcg_tmp);
3383         }
3384     }
3385
3386     if (!sf) {
3387         tcg_gen_ext32u_i64(cpu_reg(s, rd), cpu_reg(s, rd));
3388     }
3389
3390     tcg_temp_free_i64(tcg_op1);
3391     tcg_temp_free_i64(tcg_op2);
3392     tcg_temp_free_i64(tcg_tmp);
3393 }
3394
3395 /* C3.5.3 - Add/subtract (with carry)
3396  *  31 30 29 28 27 26 25 24 23 22 21  20  16  15   10  9    5 4   0
3397  * +--+--+--+------------------------+------+---------+------+-----+
3398  * |sf|op| S| 1  1  0  1  0  0  0  0 |  rm  | opcode2 |  Rn  |  Rd |
3399  * +--+--+--+------------------------+------+---------+------+-----+
3400  *                                            [000000]
3401  */
3402
3403 static void disas_adc_sbc(DisasContext *s, uint32_t insn)
3404 {
3405     unsigned int sf, op, setflags, rm, rn, rd;
3406     TCGv_i64 tcg_y, tcg_rn, tcg_rd;
3407
3408     if (extract32(insn, 10, 6) != 0) {
3409         unallocated_encoding(s);
3410         return;
3411     }
3412
3413     sf = extract32(insn, 31, 1);
3414     op = extract32(insn, 30, 1);
3415     setflags = extract32(insn, 29, 1);
3416     rm = extract32(insn, 16, 5);
3417     rn = extract32(insn, 5, 5);
3418     rd = extract32(insn, 0, 5);
3419
3420     tcg_rd = cpu_reg(s, rd);
3421     tcg_rn = cpu_reg(s, rn);
3422
3423     if (op) {
3424         tcg_y = new_tmp_a64(s);
3425         tcg_gen_not_i64(tcg_y, cpu_reg(s, rm));
3426     } else {
3427         tcg_y = cpu_reg(s, rm);
3428     }
3429
3430     if (setflags) {
3431         gen_adc_CC(sf, tcg_rd, tcg_rn, tcg_y);
3432     } else {
3433         gen_adc(sf, tcg_rd, tcg_rn, tcg_y);
3434     }
3435 }
3436
3437 /* C3.5.4 - C3.5.5 Conditional compare (immediate / register)
3438  *  31 30 29 28 27 26 25 24 23 22 21  20    16 15  12  11  10  9   5  4 3   0
3439  * +--+--+--+------------------------+--------+------+----+--+------+--+-----+
3440  * |sf|op| S| 1  1  0  1  0  0  1  0 |imm5/rm | cond |i/r |o2|  Rn  |o3|nzcv |
3441  * +--+--+--+------------------------+--------+------+----+--+------+--+-----+
3442  *        [1]                             y                [0]       [0]
3443  */
3444 static void disas_cc(DisasContext *s, uint32_t insn)
3445 {
3446     unsigned int sf, op, y, cond, rn, nzcv, is_imm;
3447     int label_continue = -1;
3448     TCGv_i64 tcg_tmp, tcg_y, tcg_rn;
3449
3450     if (!extract32(insn, 29, 1)) {
3451         unallocated_encoding(s);
3452         return;
3453     }
3454     if (insn & (1 << 10 | 1 << 4)) {
3455         unallocated_encoding(s);
3456         return;
3457     }
3458     sf = extract32(insn, 31, 1);
3459     op = extract32(insn, 30, 1);
3460     is_imm = extract32(insn, 11, 1);
3461     y = extract32(insn, 16, 5); /* y = rm (reg) or imm5 (imm) */
3462     cond = extract32(insn, 12, 4);
3463     rn = extract32(insn, 5, 5);
3464     nzcv = extract32(insn, 0, 4);
3465
3466     if (cond < 0x0e) { /* not always */
3467         int label_match = gen_new_label();
3468         label_continue = gen_new_label();
3469         arm_gen_test_cc(cond, label_match);
3470         /* nomatch: */
3471         tcg_tmp = tcg_temp_new_i64();
3472         tcg_gen_movi_i64(tcg_tmp, nzcv << 28);
3473         gen_set_nzcv(tcg_tmp);
3474         tcg_temp_free_i64(tcg_tmp);
3475         tcg_gen_br(label_continue);
3476         gen_set_label(label_match);
3477     }
3478     /* match, or condition is always */
3479     if (is_imm) {
3480         tcg_y = new_tmp_a64(s);
3481         tcg_gen_movi_i64(tcg_y, y);
3482     } else {
3483         tcg_y = cpu_reg(s, y);
3484     }
3485     tcg_rn = cpu_reg(s, rn);
3486
3487     tcg_tmp = tcg_temp_new_i64();
3488     if (op) {
3489         gen_sub_CC(sf, tcg_tmp, tcg_rn, tcg_y);
3490     } else {
3491         gen_add_CC(sf, tcg_tmp, tcg_rn, tcg_y);
3492     }
3493     tcg_temp_free_i64(tcg_tmp);
3494
3495     if (cond < 0x0e) { /* continue */
3496         gen_set_label(label_continue);
3497     }
3498 }
3499
3500 /* C3.5.6 Conditional select
3501  *   31   30  29  28             21 20  16 15  12 11 10 9    5 4    0
3502  * +----+----+---+-----------------+------+------+-----+------+------+
3503  * | sf | op | S | 1 1 0 1 0 1 0 0 |  Rm  | cond | op2 |  Rn  |  Rd  |
3504  * +----+----+---+-----------------+------+------+-----+------+------+
3505  */
3506 static void disas_cond_select(DisasContext *s, uint32_t insn)
3507 {
3508     unsigned int sf, else_inv, rm, cond, else_inc, rn, rd;
3509     TCGv_i64 tcg_rd, tcg_src;
3510
3511     if (extract32(insn, 29, 1) || extract32(insn, 11, 1)) {
3512         /* S == 1 or op2<1> == 1 */
3513         unallocated_encoding(s);
3514         return;
3515     }
3516     sf = extract32(insn, 31, 1);
3517     else_inv = extract32(insn, 30, 1);
3518     rm = extract32(insn, 16, 5);
3519     cond = extract32(insn, 12, 4);
3520     else_inc = extract32(insn, 10, 1);
3521     rn = extract32(insn, 5, 5);
3522     rd = extract32(insn, 0, 5);
3523
3524     if (rd == 31) {
3525         /* silly no-op write; until we use movcond we must special-case
3526          * this to avoid a dead temporary across basic blocks.
3527          */
3528         return;
3529     }
3530
3531     tcg_rd = cpu_reg(s, rd);
3532
3533     if (cond >= 0x0e) { /* condition "always" */
3534         tcg_src = read_cpu_reg(s, rn, sf);
3535         tcg_gen_mov_i64(tcg_rd, tcg_src);
3536     } else {
3537         /* OPTME: we could use movcond here, at the cost of duplicating
3538          * a lot of the arm_gen_test_cc() logic.
3539          */
3540         int label_match = gen_new_label();
3541         int label_continue = gen_new_label();
3542
3543         arm_gen_test_cc(cond, label_match);
3544         /* nomatch: */
3545         tcg_src = cpu_reg(s, rm);
3546
3547         if (else_inv && else_inc) {
3548             tcg_gen_neg_i64(tcg_rd, tcg_src);
3549         } else if (else_inv) {
3550             tcg_gen_not_i64(tcg_rd, tcg_src);
3551         } else if (else_inc) {
3552             tcg_gen_addi_i64(tcg_rd, tcg_src, 1);
3553         } else {
3554             tcg_gen_mov_i64(tcg_rd, tcg_src);
3555         }
3556         if (!sf) {
3557             tcg_gen_ext32u_i64(tcg_rd, tcg_rd);
3558         }
3559         tcg_gen_br(label_continue);
3560         /* match: */
3561         gen_set_label(label_match);
3562         tcg_src = read_cpu_reg(s, rn, sf);
3563         tcg_gen_mov_i64(tcg_rd, tcg_src);
3564         /* continue: */
3565         gen_set_label(label_continue);
3566     }
3567 }
3568
3569 static void handle_clz(DisasContext *s, unsigned int sf,
3570                        unsigned int rn, unsigned int rd)
3571 {
3572     TCGv_i64 tcg_rd, tcg_rn;
3573     tcg_rd = cpu_reg(s, rd);
3574     tcg_rn = cpu_reg(s, rn);
3575
3576     if (sf) {
3577         gen_helper_clz64(tcg_rd, tcg_rn);
3578     } else {
3579         TCGv_i32 tcg_tmp32 = tcg_temp_new_i32();
3580         tcg_gen_trunc_i64_i32(tcg_tmp32, tcg_rn);
3581         gen_helper_clz(tcg_tmp32, tcg_tmp32);
3582         tcg_gen_extu_i32_i64(tcg_rd, tcg_tmp32);
3583         tcg_temp_free_i32(tcg_tmp32);
3584     }
3585 }
3586
3587 static void handle_cls(DisasContext *s, unsigned int sf,
3588                        unsigned int rn, unsigned int rd)
3589 {
3590     TCGv_i64 tcg_rd, tcg_rn;
3591     tcg_rd = cpu_reg(s, rd);
3592     tcg_rn = cpu_reg(s, rn);
3593
3594     if (sf) {
3595         gen_helper_cls64(tcg_rd, tcg_rn);
3596     } else {
3597         TCGv_i32 tcg_tmp32 = tcg_temp_new_i32();
3598         tcg_gen_trunc_i64_i32(tcg_tmp32, tcg_rn);
3599         gen_helper_cls32(tcg_tmp32, tcg_tmp32);
3600         tcg_gen_extu_i32_i64(tcg_rd, tcg_tmp32);
3601         tcg_temp_free_i32(tcg_tmp32);
3602     }
3603 }
3604
3605 static void handle_rbit(DisasContext *s, unsigned int sf,
3606                         unsigned int rn, unsigned int rd)
3607 {
3608     TCGv_i64 tcg_rd, tcg_rn;
3609     tcg_rd = cpu_reg(s, rd);
3610     tcg_rn = cpu_reg(s, rn);
3611
3612     if (sf) {
3613         gen_helper_rbit64(tcg_rd, tcg_rn);
3614     } else {
3615         TCGv_i32 tcg_tmp32 = tcg_temp_new_i32();
3616         tcg_gen_trunc_i64_i32(tcg_tmp32, tcg_rn);
3617         gen_helper_rbit(tcg_tmp32, tcg_tmp32);
3618         tcg_gen_extu_i32_i64(tcg_rd, tcg_tmp32);
3619         tcg_temp_free_i32(tcg_tmp32);
3620     }
3621 }
3622
3623 /* C5.6.149 REV with sf==1, opcode==3 ("REV64") */
3624 static void handle_rev64(DisasContext *s, unsigned int sf,
3625                          unsigned int rn, unsigned int rd)
3626 {
3627     if (!sf) {
3628         unallocated_encoding(s);
3629         return;
3630     }
3631     tcg_gen_bswap64_i64(cpu_reg(s, rd), cpu_reg(s, rn));
3632 }
3633
3634 /* C5.6.149 REV with sf==0, opcode==2
3635  * C5.6.151 REV32 (sf==1, opcode==2)
3636  */
3637 static void handle_rev32(DisasContext *s, unsigned int sf,
3638                          unsigned int rn, unsigned int rd)
3639 {
3640     TCGv_i64 tcg_rd = cpu_reg(s, rd);
3641
3642     if (sf) {
3643         TCGv_i64 tcg_tmp = tcg_temp_new_i64();
3644         TCGv_i64 tcg_rn = read_cpu_reg(s, rn, sf);
3645
3646         /* bswap32_i64 requires zero high word */
3647         tcg_gen_ext32u_i64(tcg_tmp, tcg_rn);
3648         tcg_gen_bswap32_i64(tcg_rd, tcg_tmp);
3649         tcg_gen_shri_i64(tcg_tmp, tcg_rn, 32);
3650         tcg_gen_bswap32_i64(tcg_tmp, tcg_tmp);
3651         tcg_gen_concat32_i64(tcg_rd, tcg_rd, tcg_tmp);
3652
3653         tcg_temp_free_i64(tcg_tmp);
3654     } else {
3655         tcg_gen_ext32u_i64(tcg_rd, cpu_reg(s, rn));
3656         tcg_gen_bswap32_i64(tcg_rd, tcg_rd);
3657     }
3658 }
3659
3660 /* C5.6.150 REV16 (opcode==1) */
3661 static void handle_rev16(DisasContext *s, unsigned int sf,
3662                          unsigned int rn, unsigned int rd)
3663 {
3664     TCGv_i64 tcg_rd = cpu_reg(s, rd);
3665     TCGv_i64 tcg_tmp = tcg_temp_new_i64();
3666     TCGv_i64 tcg_rn = read_cpu_reg(s, rn, sf);
3667
3668     tcg_gen_andi_i64(tcg_tmp, tcg_rn, 0xffff);
3669     tcg_gen_bswap16_i64(tcg_rd, tcg_tmp);
3670
3671     tcg_gen_shri_i64(tcg_tmp, tcg_rn, 16);
3672     tcg_gen_andi_i64(tcg_tmp, tcg_tmp, 0xffff);
3673     tcg_gen_bswap16_i64(tcg_tmp, tcg_tmp);
3674     tcg_gen_deposit_i64(tcg_rd, tcg_rd, tcg_tmp, 16, 16);
3675
3676     if (sf) {
3677         tcg_gen_shri_i64(tcg_tmp, tcg_rn, 32);
3678         tcg_gen_andi_i64(tcg_tmp, tcg_tmp, 0xffff);
3679         tcg_gen_bswap16_i64(tcg_tmp, tcg_tmp);
3680         tcg_gen_deposit_i64(tcg_rd, tcg_rd, tcg_tmp, 32, 16);
3681
3682         tcg_gen_shri_i64(tcg_tmp, tcg_rn, 48);
3683         tcg_gen_bswap16_i64(tcg_tmp, tcg_tmp);
3684         tcg_gen_deposit_i64(tcg_rd, tcg_rd, tcg_tmp, 48, 16);
3685     }
3686
3687     tcg_temp_free_i64(tcg_tmp);
3688 }
3689
3690 /* C3.5.7 Data-processing (1 source)
3691  *   31  30  29  28             21 20     16 15    10 9    5 4    0
3692  * +----+---+---+-----------------+---------+--------+------+------+
3693  * | sf | 1 | S | 1 1 0 1 0 1 1 0 | opcode2 | opcode |  Rn  |  Rd  |
3694  * +----+---+---+-----------------+---------+--------+------+------+
3695  */
3696 static void disas_data_proc_1src(DisasContext *s, uint32_t insn)
3697 {
3698     unsigned int sf, opcode, rn, rd;
3699
3700     if (extract32(insn, 29, 1) || extract32(insn, 16, 5)) {
3701         unallocated_encoding(s);
3702         return;
3703     }
3704
3705     sf = extract32(insn, 31, 1);
3706     opcode = extract32(insn, 10, 6);
3707     rn = extract32(insn, 5, 5);
3708     rd = extract32(insn, 0, 5);
3709
3710     switch (opcode) {
3711     case 0: /* RBIT */
3712         handle_rbit(s, sf, rn, rd);
3713         break;
3714     case 1: /* REV16 */
3715         handle_rev16(s, sf, rn, rd);
3716         break;
3717     case 2: /* REV32 */
3718         handle_rev32(s, sf, rn, rd);
3719         break;
3720     case 3: /* REV64 */
3721         handle_rev64(s, sf, rn, rd);
3722         break;
3723     case 4: /* CLZ */
3724         handle_clz(s, sf, rn, rd);
3725         break;
3726     case 5: /* CLS */
3727         handle_cls(s, sf, rn, rd);
3728         break;
3729     }
3730 }
3731
3732 static void handle_div(DisasContext *s, bool is_signed, unsigned int sf,
3733                        unsigned int rm, unsigned int rn, unsigned int rd)
3734 {
3735     TCGv_i64 tcg_n, tcg_m, tcg_rd;
3736     tcg_rd = cpu_reg(s, rd);
3737
3738     if (!sf && is_signed) {
3739         tcg_n = new_tmp_a64(s);
3740         tcg_m = new_tmp_a64(s);
3741         tcg_gen_ext32s_i64(tcg_n, cpu_reg(s, rn));
3742         tcg_gen_ext32s_i64(tcg_m, cpu_reg(s, rm));
3743     } else {
3744         tcg_n = read_cpu_reg(s, rn, sf);
3745         tcg_m = read_cpu_reg(s, rm, sf);
3746     }
3747
3748     if (is_signed) {
3749         gen_helper_sdiv64(tcg_rd, tcg_n, tcg_m);
3750     } else {
3751         gen_helper_udiv64(tcg_rd, tcg_n, tcg_m);
3752     }
3753
3754     if (!sf) { /* zero extend final result */
3755         tcg_gen_ext32u_i64(tcg_rd, tcg_rd);
3756     }
3757 }
3758
3759 /* C5.6.115 LSLV, C5.6.118 LSRV, C5.6.17 ASRV, C5.6.154 RORV */
3760 static void handle_shift_reg(DisasContext *s,
3761                              enum a64_shift_type shift_type, unsigned int sf,
3762                              unsigned int rm, unsigned int rn, unsigned int rd)
3763 {
3764     TCGv_i64 tcg_shift = tcg_temp_new_i64();
3765     TCGv_i64 tcg_rd = cpu_reg(s, rd);
3766     TCGv_i64 tcg_rn = read_cpu_reg(s, rn, sf);
3767
3768     tcg_gen_andi_i64(tcg_shift, cpu_reg(s, rm), sf ? 63 : 31);
3769     shift_reg(tcg_rd, tcg_rn, sf, shift_type, tcg_shift);
3770     tcg_temp_free_i64(tcg_shift);
3771 }
3772
3773 /* C3.5.8 Data-processing (2 source)
3774  *   31   30  29 28             21 20  16 15    10 9    5 4    0
3775  * +----+---+---+-----------------+------+--------+------+------+
3776  * | sf | 0 | S | 1 1 0 1 0 1 1 0 |  Rm  | opcode |  Rn  |  Rd  |
3777  * +----+---+---+-----------------+------+--------+------+------+
3778  */
3779 static void disas_data_proc_2src(DisasContext *s, uint32_t insn)
3780 {
3781     unsigned int sf, rm, opcode, rn, rd;
3782     sf = extract32(insn, 31, 1);
3783     rm = extract32(insn, 16, 5);
3784     opcode = extract32(insn, 10, 6);
3785     rn = extract32(insn, 5, 5);
3786     rd = extract32(insn, 0, 5);
3787
3788     if (extract32(insn, 29, 1)) {
3789         unallocated_encoding(s);
3790         return;
3791     }
3792
3793     switch (opcode) {
3794     case 2: /* UDIV */
3795         handle_div(s, false, sf, rm, rn, rd);
3796         break;
3797     case 3: /* SDIV */
3798         handle_div(s, true, sf, rm, rn, rd);
3799         break;
3800     case 8: /* LSLV */
3801         handle_shift_reg(s, A64_SHIFT_TYPE_LSL, sf, rm, rn, rd);
3802         break;
3803     case 9: /* LSRV */
3804         handle_shift_reg(s, A64_SHIFT_TYPE_LSR, sf, rm, rn, rd);
3805         break;
3806     case 10: /* ASRV */
3807         handle_shift_reg(s, A64_SHIFT_TYPE_ASR, sf, rm, rn, rd);
3808         break;
3809     case 11: /* RORV */
3810         handle_shift_reg(s, A64_SHIFT_TYPE_ROR, sf, rm, rn, rd);
3811         break;
3812     case 16:
3813     case 17:
3814     case 18:
3815     case 19:
3816     case 20:
3817     case 21:
3818     case 22:
3819     case 23: /* CRC32 */
3820         unsupported_encoding(s, insn);
3821         break;
3822     default:
3823         unallocated_encoding(s);
3824         break;
3825     }
3826 }
3827
3828 /* C3.5 Data processing - register */
3829 static void disas_data_proc_reg(DisasContext *s, uint32_t insn)
3830 {
3831     switch (extract32(insn, 24, 5)) {
3832     case 0x0a: /* Logical (shifted register) */
3833         disas_logic_reg(s, insn);
3834         break;
3835     case 0x0b: /* Add/subtract */
3836         if (insn & (1 << 21)) { /* (extended register) */
3837             disas_add_sub_ext_reg(s, insn);
3838         } else {
3839             disas_add_sub_reg(s, insn);
3840         }
3841         break;
3842     case 0x1b: /* Data-processing (3 source) */
3843         disas_data_proc_3src(s, insn);
3844         break;
3845     case 0x1a:
3846         switch (extract32(insn, 21, 3)) {
3847         case 0x0: /* Add/subtract (with carry) */
3848             disas_adc_sbc(s, insn);
3849             break;
3850         case 0x2: /* Conditional compare */
3851             disas_cc(s, insn); /* both imm and reg forms */
3852             break;
3853         case 0x4: /* Conditional select */
3854             disas_cond_select(s, insn);
3855             break;
3856         case 0x6: /* Data-processing */
3857             if (insn & (1 << 30)) { /* (1 source) */
3858                 disas_data_proc_1src(s, insn);
3859             } else {            /* (2 source) */
3860                 disas_data_proc_2src(s, insn);
3861             }
3862             break;
3863         default:
3864             unallocated_encoding(s);
3865             break;
3866         }
3867         break;
3868     default:
3869         unallocated_encoding(s);
3870         break;
3871     }
3872 }
3873
3874 static void handle_fp_compare(DisasContext *s, bool is_double,
3875                               unsigned int rn, unsigned int rm,
3876                               bool cmp_with_zero, bool signal_all_nans)
3877 {
3878     TCGv_i64 tcg_flags = tcg_temp_new_i64();
3879     TCGv_ptr fpst = get_fpstatus_ptr();
3880
3881     if (is_double) {
3882         TCGv_i64 tcg_vn, tcg_vm;
3883
3884         tcg_vn = read_fp_dreg(s, rn);
3885         if (cmp_with_zero) {
3886             tcg_vm = tcg_const_i64(0);
3887         } else {
3888             tcg_vm = read_fp_dreg(s, rm);
3889         }
3890         if (signal_all_nans) {
3891             gen_helper_vfp_cmped_a64(tcg_flags, tcg_vn, tcg_vm, fpst);
3892         } else {
3893             gen_helper_vfp_cmpd_a64(tcg_flags, tcg_vn, tcg_vm, fpst);
3894         }
3895         tcg_temp_free_i64(tcg_vn);
3896         tcg_temp_free_i64(tcg_vm);
3897     } else {
3898         TCGv_i32 tcg_vn, tcg_vm;
3899
3900         tcg_vn = read_fp_sreg(s, rn);
3901         if (cmp_with_zero) {
3902             tcg_vm = tcg_const_i32(0);
3903         } else {
3904             tcg_vm = read_fp_sreg(s, rm);
3905         }
3906         if (signal_all_nans) {
3907             gen_helper_vfp_cmpes_a64(tcg_flags, tcg_vn, tcg_vm, fpst);
3908         } else {
3909             gen_helper_vfp_cmps_a64(tcg_flags, tcg_vn, tcg_vm, fpst);
3910         }
3911         tcg_temp_free_i32(tcg_vn);
3912         tcg_temp_free_i32(tcg_vm);
3913     }
3914
3915     tcg_temp_free_ptr(fpst);
3916
3917     gen_set_nzcv(tcg_flags);
3918
3919     tcg_temp_free_i64(tcg_flags);
3920 }
3921
3922 /* C3.6.22 Floating point compare
3923  *   31  30  29 28       24 23  22  21 20  16 15 14 13  10    9    5 4     0
3924  * +---+---+---+-----------+------+---+------+-----+---------+------+-------+
3925  * | M | 0 | S | 1 1 1 1 0 | type | 1 |  Rm  | op  | 1 0 0 0 |  Rn  |  op2  |
3926  * +---+---+---+-----------+------+---+------+-----+---------+------+-------+
3927  */
3928 static void disas_fp_compare(DisasContext *s, uint32_t insn)
3929 {
3930     unsigned int mos, type, rm, op, rn, opc, op2r;
3931
3932     mos = extract32(insn, 29, 3);
3933     type = extract32(insn, 22, 2); /* 0 = single, 1 = double */
3934     rm = extract32(insn, 16, 5);
3935     op = extract32(insn, 14, 2);
3936     rn = extract32(insn, 5, 5);
3937     opc = extract32(insn, 3, 2);
3938     op2r = extract32(insn, 0, 3);
3939
3940     if (mos || op || op2r || type > 1) {
3941         unallocated_encoding(s);
3942         return;
3943     }
3944
3945     if (!fp_access_check(s)) {
3946         return;
3947     }
3948
3949     handle_fp_compare(s, type, rn, rm, opc & 1, opc & 2);
3950 }
3951
3952 /* C3.6.23 Floating point conditional compare
3953  *   31  30  29 28       24 23  22  21 20  16 15  12 11 10 9    5  4   3    0
3954  * +---+---+---+-----------+------+---+------+------+-----+------+----+------+
3955  * | M | 0 | S | 1 1 1 1 0 | type | 1 |  Rm  | cond | 0 1 |  Rn  | op | nzcv |
3956  * +---+---+---+-----------+------+---+------+------+-----+------+----+------+
3957  */
3958 static void disas_fp_ccomp(DisasContext *s, uint32_t insn)
3959 {
3960     unsigned int mos, type, rm, cond, rn, op, nzcv;
3961     TCGv_i64 tcg_flags;
3962     int label_continue = -1;
3963
3964     mos = extract32(insn, 29, 3);
3965     type = extract32(insn, 22, 2); /* 0 = single, 1 = double */
3966     rm = extract32(insn, 16, 5);
3967     cond = extract32(insn, 12, 4);
3968     rn = extract32(insn, 5, 5);
3969     op = extract32(insn, 4, 1);
3970     nzcv = extract32(insn, 0, 4);
3971
3972     if (mos || type > 1) {
3973         unallocated_encoding(s);
3974         return;
3975     }
3976
3977     if (!fp_access_check(s)) {
3978         return;
3979     }
3980
3981     if (cond < 0x0e) { /* not always */
3982         int label_match = gen_new_label();
3983         label_continue = gen_new_label();
3984         arm_gen_test_cc(cond, label_match);
3985         /* nomatch: */
3986         tcg_flags = tcg_const_i64(nzcv << 28);
3987         gen_set_nzcv(tcg_flags);
3988         tcg_temp_free_i64(tcg_flags);
3989         tcg_gen_br(label_continue);
3990         gen_set_label(label_match);
3991     }
3992
3993     handle_fp_compare(s, type, rn, rm, false, op);
3994
3995     if (cond < 0x0e) {
3996         gen_set_label(label_continue);
3997     }
3998 }
3999
4000 /* copy src FP register to dst FP register; type specifies single or double */
4001 static void gen_mov_fp2fp(DisasContext *s, int type, int dst, int src)
4002 {
4003     if (type) {
4004         TCGv_i64 v = read_fp_dreg(s, src);
4005         write_fp_dreg(s, dst, v);
4006         tcg_temp_free_i64(v);
4007     } else {
4008         TCGv_i32 v = read_fp_sreg(s, src);
4009         write_fp_sreg(s, dst, v);
4010         tcg_temp_free_i32(v);
4011     }
4012 }
4013
4014 /* C3.6.24 Floating point conditional select
4015  *   31  30  29 28       24 23  22  21 20  16 15  12 11 10 9    5 4    0
4016  * +---+---+---+-----------+------+---+------+------+-----+------+------+
4017  * | M | 0 | S | 1 1 1 1 0 | type | 1 |  Rm  | cond | 1 1 |  Rn  |  Rd  |
4018  * +---+---+---+-----------+------+---+------+------+-----+------+------+
4019  */
4020 static void disas_fp_csel(DisasContext *s, uint32_t insn)
4021 {
4022     unsigned int mos, type, rm, cond, rn, rd;
4023     int label_continue = -1;
4024
4025     mos = extract32(insn, 29, 3);
4026     type = extract32(insn, 22, 2); /* 0 = single, 1 = double */
4027     rm = extract32(insn, 16, 5);
4028     cond = extract32(insn, 12, 4);
4029     rn = extract32(insn, 5, 5);
4030     rd = extract32(insn, 0, 5);
4031
4032     if (mos || type > 1) {
4033         unallocated_encoding(s);
4034         return;
4035     }
4036
4037     if (!fp_access_check(s)) {
4038         return;
4039     }
4040
4041     if (cond < 0x0e) { /* not always */
4042         int label_match = gen_new_label();
4043         label_continue = gen_new_label();
4044         arm_gen_test_cc(cond, label_match);
4045         /* nomatch: */
4046         gen_mov_fp2fp(s, type, rd, rm);
4047         tcg_gen_br(label_continue);
4048         gen_set_label(label_match);
4049     }
4050
4051     gen_mov_fp2fp(s, type, rd, rn);
4052
4053     if (cond < 0x0e) { /* continue */
4054         gen_set_label(label_continue);
4055     }
4056 }
4057
4058 /* C3.6.25 Floating-point data-processing (1 source) - single precision */
4059 static void handle_fp_1src_single(DisasContext *s, int opcode, int rd, int rn)
4060 {
4061     TCGv_ptr fpst;
4062     TCGv_i32 tcg_op;
4063     TCGv_i32 tcg_res;
4064
4065     fpst = get_fpstatus_ptr();
4066     tcg_op = read_fp_sreg(s, rn);
4067     tcg_res = tcg_temp_new_i32();
4068
4069     switch (opcode) {
4070     case 0x0: /* FMOV */
4071         tcg_gen_mov_i32(tcg_res, tcg_op);
4072         break;
4073     case 0x1: /* FABS */
4074         gen_helper_vfp_abss(tcg_res, tcg_op);
4075         break;
4076     case 0x2: /* FNEG */
4077         gen_helper_vfp_negs(tcg_res, tcg_op);
4078         break;
4079     case 0x3: /* FSQRT */
4080         gen_helper_vfp_sqrts(tcg_res, tcg_op, cpu_env);
4081         break;
4082     case 0x8: /* FRINTN */
4083     case 0x9: /* FRINTP */
4084     case 0xa: /* FRINTM */
4085     case 0xb: /* FRINTZ */
4086     case 0xc: /* FRINTA */
4087     {
4088         TCGv_i32 tcg_rmode = tcg_const_i32(arm_rmode_to_sf(opcode & 7));
4089
4090         gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
4091         gen_helper_rints(tcg_res, tcg_op, fpst);
4092
4093         gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
4094         tcg_temp_free_i32(tcg_rmode);
4095         break;
4096     }
4097     case 0xe: /* FRINTX */
4098         gen_helper_rints_exact(tcg_res, tcg_op, fpst);
4099         break;
4100     case 0xf: /* FRINTI */
4101         gen_helper_rints(tcg_res, tcg_op, fpst);
4102         break;
4103     default:
4104         abort();
4105     }
4106
4107     write_fp_sreg(s, rd, tcg_res);
4108
4109     tcg_temp_free_ptr(fpst);
4110     tcg_temp_free_i32(tcg_op);
4111     tcg_temp_free_i32(tcg_res);
4112 }
4113
4114 /* C3.6.25 Floating-point data-processing (1 source) - double precision */
4115 static void handle_fp_1src_double(DisasContext *s, int opcode, int rd, int rn)
4116 {
4117     TCGv_ptr fpst;
4118     TCGv_i64 tcg_op;
4119     TCGv_i64 tcg_res;
4120
4121     fpst = get_fpstatus_ptr();
4122     tcg_op = read_fp_dreg(s, rn);
4123     tcg_res = tcg_temp_new_i64();
4124
4125     switch (opcode) {
4126     case 0x0: /* FMOV */
4127         tcg_gen_mov_i64(tcg_res, tcg_op);
4128         break;
4129     case 0x1: /* FABS */
4130         gen_helper_vfp_absd(tcg_res, tcg_op);
4131         break;
4132     case 0x2: /* FNEG */
4133         gen_helper_vfp_negd(tcg_res, tcg_op);
4134         break;
4135     case 0x3: /* FSQRT */
4136         gen_helper_vfp_sqrtd(tcg_res, tcg_op, cpu_env);
4137         break;
4138     case 0x8: /* FRINTN */
4139     case 0x9: /* FRINTP */
4140     case 0xa: /* FRINTM */
4141     case 0xb: /* FRINTZ */
4142     case 0xc: /* FRINTA */
4143     {
4144         TCGv_i32 tcg_rmode = tcg_const_i32(arm_rmode_to_sf(opcode & 7));
4145
4146         gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
4147         gen_helper_rintd(tcg_res, tcg_op, fpst);
4148
4149         gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
4150         tcg_temp_free_i32(tcg_rmode);
4151         break;
4152     }
4153     case 0xe: /* FRINTX */
4154         gen_helper_rintd_exact(tcg_res, tcg_op, fpst);
4155         break;
4156     case 0xf: /* FRINTI */
4157         gen_helper_rintd(tcg_res, tcg_op, fpst);
4158         break;
4159     default:
4160         abort();
4161     }
4162
4163     write_fp_dreg(s, rd, tcg_res);
4164
4165     tcg_temp_free_ptr(fpst);
4166     tcg_temp_free_i64(tcg_op);
4167     tcg_temp_free_i64(tcg_res);
4168 }
4169
4170 static void handle_fp_fcvt(DisasContext *s, int opcode,
4171                            int rd, int rn, int dtype, int ntype)
4172 {
4173     switch (ntype) {
4174     case 0x0:
4175     {
4176         TCGv_i32 tcg_rn = read_fp_sreg(s, rn);
4177         if (dtype == 1) {
4178             /* Single to double */
4179             TCGv_i64 tcg_rd = tcg_temp_new_i64();
4180             gen_helper_vfp_fcvtds(tcg_rd, tcg_rn, cpu_env);
4181             write_fp_dreg(s, rd, tcg_rd);
4182             tcg_temp_free_i64(tcg_rd);
4183         } else {
4184             /* Single to half */
4185             TCGv_i32 tcg_rd = tcg_temp_new_i32();
4186             gen_helper_vfp_fcvt_f32_to_f16(tcg_rd, tcg_rn, cpu_env);
4187             /* write_fp_sreg is OK here because top half of tcg_rd is zero */
4188             write_fp_sreg(s, rd, tcg_rd);
4189             tcg_temp_free_i32(tcg_rd);
4190         }
4191         tcg_temp_free_i32(tcg_rn);
4192         break;
4193     }
4194     case 0x1:
4195     {
4196         TCGv_i64 tcg_rn = read_fp_dreg(s, rn);
4197         TCGv_i32 tcg_rd = tcg_temp_new_i32();
4198         if (dtype == 0) {
4199             /* Double to single */
4200             gen_helper_vfp_fcvtsd(tcg_rd, tcg_rn, cpu_env);
4201         } else {
4202             /* Double to half */
4203             gen_helper_vfp_fcvt_f64_to_f16(tcg_rd, tcg_rn, cpu_env);
4204             /* write_fp_sreg is OK here because top half of tcg_rd is zero */
4205         }
4206         write_fp_sreg(s, rd, tcg_rd);
4207         tcg_temp_free_i32(tcg_rd);
4208         tcg_temp_free_i64(tcg_rn);
4209         break;
4210     }
4211     case 0x3:
4212     {
4213         TCGv_i32 tcg_rn = read_fp_sreg(s, rn);
4214         tcg_gen_ext16u_i32(tcg_rn, tcg_rn);
4215         if (dtype == 0) {
4216             /* Half to single */
4217             TCGv_i32 tcg_rd = tcg_temp_new_i32();
4218             gen_helper_vfp_fcvt_f16_to_f32(tcg_rd, tcg_rn, cpu_env);
4219             write_fp_sreg(s, rd, tcg_rd);
4220             tcg_temp_free_i32(tcg_rd);
4221         } else {
4222             /* Half to double */
4223             TCGv_i64 tcg_rd = tcg_temp_new_i64();
4224             gen_helper_vfp_fcvt_f16_to_f64(tcg_rd, tcg_rn, cpu_env);
4225             write_fp_dreg(s, rd, tcg_rd);
4226             tcg_temp_free_i64(tcg_rd);
4227         }
4228         tcg_temp_free_i32(tcg_rn);
4229         break;
4230     }
4231     default:
4232         abort();
4233     }
4234 }
4235
4236 /* C3.6.25 Floating point data-processing (1 source)
4237  *   31  30  29 28       24 23  22  21 20    15 14       10 9    5 4    0
4238  * +---+---+---+-----------+------+---+--------+-----------+------+------+
4239  * | M | 0 | S | 1 1 1 1 0 | type | 1 | opcode | 1 0 0 0 0 |  Rn  |  Rd  |
4240  * +---+---+---+-----------+------+---+--------+-----------+------+------+
4241  */
4242 static void disas_fp_1src(DisasContext *s, uint32_t insn)
4243 {
4244     int type = extract32(insn, 22, 2);
4245     int opcode = extract32(insn, 15, 6);
4246     int rn = extract32(insn, 5, 5);
4247     int rd = extract32(insn, 0, 5);
4248
4249     switch (opcode) {
4250     case 0x4: case 0x5: case 0x7:
4251     {
4252         /* FCVT between half, single and double precision */
4253         int dtype = extract32(opcode, 0, 2);
4254         if (type == 2 || dtype == type) {
4255             unallocated_encoding(s);
4256             return;
4257         }
4258         if (!fp_access_check(s)) {
4259             return;
4260         }
4261
4262         handle_fp_fcvt(s, opcode, rd, rn, dtype, type);
4263         break;
4264     }
4265     case 0x0 ... 0x3:
4266     case 0x8 ... 0xc:
4267     case 0xe ... 0xf:
4268         /* 32-to-32 and 64-to-64 ops */
4269         switch (type) {
4270         case 0:
4271             if (!fp_access_check(s)) {
4272                 return;
4273             }
4274
4275             handle_fp_1src_single(s, opcode, rd, rn);
4276             break;
4277         case 1:
4278             if (!fp_access_check(s)) {
4279                 return;
4280             }
4281
4282             handle_fp_1src_double(s, opcode, rd, rn);
4283             break;
4284         default:
4285             unallocated_encoding(s);
4286         }
4287         break;
4288     default:
4289         unallocated_encoding(s);
4290         break;
4291     }
4292 }
4293
4294 /* C3.6.26 Floating-point data-processing (2 source) - single precision */
4295 static void handle_fp_2src_single(DisasContext *s, int opcode,
4296                                   int rd, int rn, int rm)
4297 {
4298     TCGv_i32 tcg_op1;
4299     TCGv_i32 tcg_op2;
4300     TCGv_i32 tcg_res;
4301     TCGv_ptr fpst;
4302
4303     tcg_res = tcg_temp_new_i32();
4304     fpst = get_fpstatus_ptr();
4305     tcg_op1 = read_fp_sreg(s, rn);
4306     tcg_op2 = read_fp_sreg(s, rm);
4307
4308     switch (opcode) {
4309     case 0x0: /* FMUL */
4310         gen_helper_vfp_muls(tcg_res, tcg_op1, tcg_op2, fpst);
4311         break;
4312     case 0x1: /* FDIV */
4313         gen_helper_vfp_divs(tcg_res, tcg_op1, tcg_op2, fpst);
4314         break;
4315     case 0x2: /* FADD */
4316         gen_helper_vfp_adds(tcg_res, tcg_op1, tcg_op2, fpst);
4317         break;
4318     case 0x3: /* FSUB */
4319         gen_helper_vfp_subs(tcg_res, tcg_op1, tcg_op2, fpst);
4320         break;
4321     case 0x4: /* FMAX */
4322         gen_helper_vfp_maxs(tcg_res, tcg_op1, tcg_op2, fpst);
4323         break;
4324     case 0x5: /* FMIN */
4325         gen_helper_vfp_mins(tcg_res, tcg_op1, tcg_op2, fpst);
4326         break;
4327     case 0x6: /* FMAXNM */
4328         gen_helper_vfp_maxnums(tcg_res, tcg_op1, tcg_op2, fpst);
4329         break;
4330     case 0x7: /* FMINNM */
4331         gen_helper_vfp_minnums(tcg_res, tcg_op1, tcg_op2, fpst);
4332         break;
4333     case 0x8: /* FNMUL */
4334         gen_helper_vfp_muls(tcg_res, tcg_op1, tcg_op2, fpst);
4335         gen_helper_vfp_negs(tcg_res, tcg_res);
4336         break;
4337     }
4338
4339     write_fp_sreg(s, rd, tcg_res);
4340
4341     tcg_temp_free_ptr(fpst);
4342     tcg_temp_free_i32(tcg_op1);
4343     tcg_temp_free_i32(tcg_op2);
4344     tcg_temp_free_i32(tcg_res);
4345 }
4346
4347 /* C3.6.26 Floating-point data-processing (2 source) - double precision */
4348 static void handle_fp_2src_double(DisasContext *s, int opcode,
4349                                   int rd, int rn, int rm)
4350 {
4351     TCGv_i64 tcg_op1;
4352     TCGv_i64 tcg_op2;
4353     TCGv_i64 tcg_res;
4354     TCGv_ptr fpst;
4355
4356     tcg_res = tcg_temp_new_i64();
4357     fpst = get_fpstatus_ptr();
4358     tcg_op1 = read_fp_dreg(s, rn);
4359     tcg_op2 = read_fp_dreg(s, rm);
4360
4361     switch (opcode) {
4362     case 0x0: /* FMUL */
4363         gen_helper_vfp_muld(tcg_res, tcg_op1, tcg_op2, fpst);
4364         break;
4365     case 0x1: /* FDIV */
4366         gen_helper_vfp_divd(tcg_res, tcg_op1, tcg_op2, fpst);
4367         break;
4368     case 0x2: /* FADD */
4369         gen_helper_vfp_addd(tcg_res, tcg_op1, tcg_op2, fpst);
4370         break;
4371     case 0x3: /* FSUB */
4372         gen_helper_vfp_subd(tcg_res, tcg_op1, tcg_op2, fpst);
4373         break;
4374     case 0x4: /* FMAX */
4375         gen_helper_vfp_maxd(tcg_res, tcg_op1, tcg_op2, fpst);
4376         break;
4377     case 0x5: /* FMIN */
4378         gen_helper_vfp_mind(tcg_res, tcg_op1, tcg_op2, fpst);
4379         break;
4380     case 0x6: /* FMAXNM */
4381         gen_helper_vfp_maxnumd(tcg_res, tcg_op1, tcg_op2, fpst);
4382         break;
4383     case 0x7: /* FMINNM */
4384         gen_helper_vfp_minnumd(tcg_res, tcg_op1, tcg_op2, fpst);
4385         break;
4386     case 0x8: /* FNMUL */
4387         gen_helper_vfp_muld(tcg_res, tcg_op1, tcg_op2, fpst);
4388         gen_helper_vfp_negd(tcg_res, tcg_res);
4389         break;
4390     }
4391
4392     write_fp_dreg(s, rd, tcg_res);
4393
4394     tcg_temp_free_ptr(fpst);
4395     tcg_temp_free_i64(tcg_op1);
4396     tcg_temp_free_i64(tcg_op2);
4397     tcg_temp_free_i64(tcg_res);
4398 }
4399
4400 /* C3.6.26 Floating point data-processing (2 source)
4401  *   31  30  29 28       24 23  22  21 20  16 15    12 11 10 9    5 4    0
4402  * +---+---+---+-----------+------+---+------+--------+-----+------+------+
4403  * | M | 0 | S | 1 1 1 1 0 | type | 1 |  Rm  | opcode | 1 0 |  Rn  |  Rd  |
4404  * +---+---+---+-----------+------+---+------+--------+-----+------+------+
4405  */
4406 static void disas_fp_2src(DisasContext *s, uint32_t insn)
4407 {
4408     int type = extract32(insn, 22, 2);
4409     int rd = extract32(insn, 0, 5);
4410     int rn = extract32(insn, 5, 5);
4411     int rm = extract32(insn, 16, 5);
4412     int opcode = extract32(insn, 12, 4);
4413
4414     if (opcode > 8) {
4415         unallocated_encoding(s);
4416         return;
4417     }
4418
4419     switch (type) {
4420     case 0:
4421         if (!fp_access_check(s)) {
4422             return;
4423         }
4424         handle_fp_2src_single(s, opcode, rd, rn, rm);
4425         break;
4426     case 1:
4427         if (!fp_access_check(s)) {
4428             return;
4429         }
4430         handle_fp_2src_double(s, opcode, rd, rn, rm);
4431         break;
4432     default:
4433         unallocated_encoding(s);
4434     }
4435 }
4436
4437 /* C3.6.27 Floating-point data-processing (3 source) - single precision */
4438 static void handle_fp_3src_single(DisasContext *s, bool o0, bool o1,
4439                                   int rd, int rn, int rm, int ra)
4440 {
4441     TCGv_i32 tcg_op1, tcg_op2, tcg_op3;
4442     TCGv_i32 tcg_res = tcg_temp_new_i32();
4443     TCGv_ptr fpst = get_fpstatus_ptr();
4444
4445     tcg_op1 = read_fp_sreg(s, rn);
4446     tcg_op2 = read_fp_sreg(s, rm);
4447     tcg_op3 = read_fp_sreg(s, ra);
4448
4449     /* These are fused multiply-add, and must be done as one
4450      * floating point operation with no rounding between the
4451      * multiplication and addition steps.
4452      * NB that doing the negations here as separate steps is
4453      * correct : an input NaN should come out with its sign bit
4454      * flipped if it is a negated-input.
4455      */
4456     if (o1 == true) {
4457         gen_helper_vfp_negs(tcg_op3, tcg_op3);
4458     }
4459
4460     if (o0 != o1) {
4461         gen_helper_vfp_negs(tcg_op1, tcg_op1);
4462     }
4463
4464     gen_helper_vfp_muladds(tcg_res, tcg_op1, tcg_op2, tcg_op3, fpst);
4465
4466     write_fp_sreg(s, rd, tcg_res);
4467
4468     tcg_temp_free_ptr(fpst);
4469     tcg_temp_free_i32(tcg_op1);
4470     tcg_temp_free_i32(tcg_op2);
4471     tcg_temp_free_i32(tcg_op3);
4472     tcg_temp_free_i32(tcg_res);
4473 }
4474
4475 /* C3.6.27 Floating-point data-processing (3 source) - double precision */
4476 static void handle_fp_3src_double(DisasContext *s, bool o0, bool o1,
4477                                   int rd, int rn, int rm, int ra)
4478 {
4479     TCGv_i64 tcg_op1, tcg_op2, tcg_op3;
4480     TCGv_i64 tcg_res = tcg_temp_new_i64();
4481     TCGv_ptr fpst = get_fpstatus_ptr();
4482
4483     tcg_op1 = read_fp_dreg(s, rn);
4484     tcg_op2 = read_fp_dreg(s, rm);
4485     tcg_op3 = read_fp_dreg(s, ra);
4486
4487     /* These are fused multiply-add, and must be done as one
4488      * floating point operation with no rounding between the
4489      * multiplication and addition steps.
4490      * NB that doing the negations here as separate steps is
4491      * correct : an input NaN should come out with its sign bit
4492      * flipped if it is a negated-input.
4493      */
4494     if (o1 == true) {
4495         gen_helper_vfp_negd(tcg_op3, tcg_op3);
4496     }
4497
4498     if (o0 != o1) {
4499         gen_helper_vfp_negd(tcg_op1, tcg_op1);
4500     }
4501
4502     gen_helper_vfp_muladdd(tcg_res, tcg_op1, tcg_op2, tcg_op3, fpst);
4503
4504     write_fp_dreg(s, rd, tcg_res);
4505
4506     tcg_temp_free_ptr(fpst);
4507     tcg_temp_free_i64(tcg_op1);
4508     tcg_temp_free_i64(tcg_op2);
4509     tcg_temp_free_i64(tcg_op3);
4510     tcg_temp_free_i64(tcg_res);
4511 }
4512
4513 /* C3.6.27 Floating point data-processing (3 source)
4514  *   31  30  29 28       24 23  22  21  20  16  15  14  10 9    5 4    0
4515  * +---+---+---+-----------+------+----+------+----+------+------+------+
4516  * | M | 0 | S | 1 1 1 1 1 | type | o1 |  Rm  | o0 |  Ra  |  Rn  |  Rd  |
4517  * +---+---+---+-----------+------+----+------+----+------+------+------+
4518  */
4519 static void disas_fp_3src(DisasContext *s, uint32_t insn)
4520 {
4521     int type = extract32(insn, 22, 2);
4522     int rd = extract32(insn, 0, 5);
4523     int rn = extract32(insn, 5, 5);
4524     int ra = extract32(insn, 10, 5);
4525     int rm = extract32(insn, 16, 5);
4526     bool o0 = extract32(insn, 15, 1);
4527     bool o1 = extract32(insn, 21, 1);
4528
4529     switch (type) {
4530     case 0:
4531         if (!fp_access_check(s)) {
4532             return;
4533         }
4534         handle_fp_3src_single(s, o0, o1, rd, rn, rm, ra);
4535         break;
4536     case 1:
4537         if (!fp_access_check(s)) {
4538             return;
4539         }
4540         handle_fp_3src_double(s, o0, o1, rd, rn, rm, ra);
4541         break;
4542     default:
4543         unallocated_encoding(s);
4544     }
4545 }
4546
4547 /* C3.6.28 Floating point immediate
4548  *   31  30  29 28       24 23  22  21 20        13 12   10 9    5 4    0
4549  * +---+---+---+-----------+------+---+------------+-------+------+------+
4550  * | M | 0 | S | 1 1 1 1 0 | type | 1 |    imm8    | 1 0 0 | imm5 |  Rd  |
4551  * +---+---+---+-----------+------+---+------------+-------+------+------+
4552  */
4553 static void disas_fp_imm(DisasContext *s, uint32_t insn)
4554 {
4555     int rd = extract32(insn, 0, 5);
4556     int imm8 = extract32(insn, 13, 8);
4557     int is_double = extract32(insn, 22, 2);
4558     uint64_t imm;
4559     TCGv_i64 tcg_res;
4560
4561     if (is_double > 1) {
4562         unallocated_encoding(s);
4563         return;
4564     }
4565
4566     if (!fp_access_check(s)) {
4567         return;
4568     }
4569
4570     /* The imm8 encodes the sign bit, enough bits to represent
4571      * an exponent in the range 01....1xx to 10....0xx,
4572      * and the most significant 4 bits of the mantissa; see
4573      * VFPExpandImm() in the v8 ARM ARM.
4574      */
4575     if (is_double) {
4576         imm = (extract32(imm8, 7, 1) ? 0x8000 : 0) |
4577             (extract32(imm8, 6, 1) ? 0x3fc0 : 0x4000) |
4578             extract32(imm8, 0, 6);
4579         imm <<= 48;
4580     } else {
4581         imm = (extract32(imm8, 7, 1) ? 0x8000 : 0) |
4582             (extract32(imm8, 6, 1) ? 0x3e00 : 0x4000) |
4583             (extract32(imm8, 0, 6) << 3);
4584         imm <<= 16;
4585     }
4586
4587     tcg_res = tcg_const_i64(imm);
4588     write_fp_dreg(s, rd, tcg_res);
4589     tcg_temp_free_i64(tcg_res);
4590 }
4591
4592 /* Handle floating point <=> fixed point conversions. Note that we can
4593  * also deal with fp <=> integer conversions as a special case (scale == 64)
4594  * OPTME: consider handling that special case specially or at least skipping
4595  * the call to scalbn in the helpers for zero shifts.
4596  */
4597 static void handle_fpfpcvt(DisasContext *s, int rd, int rn, int opcode,
4598                            bool itof, int rmode, int scale, int sf, int type)
4599 {
4600     bool is_signed = !(opcode & 1);
4601     bool is_double = type;
4602     TCGv_ptr tcg_fpstatus;
4603     TCGv_i32 tcg_shift;
4604
4605     tcg_fpstatus = get_fpstatus_ptr();
4606
4607     tcg_shift = tcg_const_i32(64 - scale);
4608
4609     if (itof) {
4610         TCGv_i64 tcg_int = cpu_reg(s, rn);
4611         if (!sf) {
4612             TCGv_i64 tcg_extend = new_tmp_a64(s);
4613
4614             if (is_signed) {
4615                 tcg_gen_ext32s_i64(tcg_extend, tcg_int);
4616             } else {
4617                 tcg_gen_ext32u_i64(tcg_extend, tcg_int);
4618             }
4619
4620             tcg_int = tcg_extend;
4621         }
4622
4623         if (is_double) {
4624             TCGv_i64 tcg_double = tcg_temp_new_i64();
4625             if (is_signed) {
4626                 gen_helper_vfp_sqtod(tcg_double, tcg_int,
4627                                      tcg_shift, tcg_fpstatus);
4628             } else {
4629                 gen_helper_vfp_uqtod(tcg_double, tcg_int,
4630                                      tcg_shift, tcg_fpstatus);
4631             }
4632             write_fp_dreg(s, rd, tcg_double);
4633             tcg_temp_free_i64(tcg_double);
4634         } else {
4635             TCGv_i32 tcg_single = tcg_temp_new_i32();
4636             if (is_signed) {
4637                 gen_helper_vfp_sqtos(tcg_single, tcg_int,
4638                                      tcg_shift, tcg_fpstatus);
4639             } else {
4640                 gen_helper_vfp_uqtos(tcg_single, tcg_int,
4641                                      tcg_shift, tcg_fpstatus);
4642             }
4643             write_fp_sreg(s, rd, tcg_single);
4644             tcg_temp_free_i32(tcg_single);
4645         }
4646     } else {
4647         TCGv_i64 tcg_int = cpu_reg(s, rd);
4648         TCGv_i32 tcg_rmode;
4649
4650         if (extract32(opcode, 2, 1)) {
4651             /* There are too many rounding modes to all fit into rmode,
4652              * so FCVTA[US] is a special case.
4653              */
4654             rmode = FPROUNDING_TIEAWAY;
4655         }
4656
4657         tcg_rmode = tcg_const_i32(arm_rmode_to_sf(rmode));
4658
4659         gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
4660
4661         if (is_double) {
4662             TCGv_i64 tcg_double = read_fp_dreg(s, rn);
4663             if (is_signed) {
4664                 if (!sf) {
4665                     gen_helper_vfp_tosld(tcg_int, tcg_double,
4666                                          tcg_shift, tcg_fpstatus);
4667                 } else {
4668                     gen_helper_vfp_tosqd(tcg_int, tcg_double,
4669                                          tcg_shift, tcg_fpstatus);
4670                 }
4671             } else {
4672                 if (!sf) {
4673                     gen_helper_vfp_tould(tcg_int, tcg_double,
4674                                          tcg_shift, tcg_fpstatus);
4675                 } else {
4676                     gen_helper_vfp_touqd(tcg_int, tcg_double,
4677                                          tcg_shift, tcg_fpstatus);
4678                 }
4679             }
4680             tcg_temp_free_i64(tcg_double);
4681         } else {
4682             TCGv_i32 tcg_single = read_fp_sreg(s, rn);
4683             if (sf) {
4684                 if (is_signed) {
4685                     gen_helper_vfp_tosqs(tcg_int, tcg_single,
4686                                          tcg_shift, tcg_fpstatus);
4687                 } else {
4688                     gen_helper_vfp_touqs(tcg_int, tcg_single,
4689                                          tcg_shift, tcg_fpstatus);
4690                 }
4691             } else {
4692                 TCGv_i32 tcg_dest = tcg_temp_new_i32();
4693                 if (is_signed) {
4694                     gen_helper_vfp_tosls(tcg_dest, tcg_single,
4695                                          tcg_shift, tcg_fpstatus);
4696                 } else {
4697                     gen_helper_vfp_touls(tcg_dest, tcg_single,
4698                                          tcg_shift, tcg_fpstatus);
4699                 }
4700                 tcg_gen_extu_i32_i64(tcg_int, tcg_dest);
4701                 tcg_temp_free_i32(tcg_dest);
4702             }
4703             tcg_temp_free_i32(tcg_single);
4704         }
4705
4706         gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
4707         tcg_temp_free_i32(tcg_rmode);
4708
4709         if (!sf) {
4710             tcg_gen_ext32u_i64(tcg_int, tcg_int);
4711         }
4712     }
4713
4714     tcg_temp_free_ptr(tcg_fpstatus);
4715     tcg_temp_free_i32(tcg_shift);
4716 }
4717
4718 /* C3.6.29 Floating point <-> fixed point conversions
4719  *   31   30  29 28       24 23  22  21 20   19 18    16 15   10 9    5 4    0
4720  * +----+---+---+-----------+------+---+-------+--------+-------+------+------+
4721  * | sf | 0 | S | 1 1 1 1 0 | type | 0 | rmode | opcode | scale |  Rn  |  Rd  |
4722  * +----+---+---+-----------+------+---+-------+--------+-------+------+------+
4723  */
4724 static void disas_fp_fixed_conv(DisasContext *s, uint32_t insn)
4725 {
4726     int rd = extract32(insn, 0, 5);
4727     int rn = extract32(insn, 5, 5);
4728     int scale = extract32(insn, 10, 6);
4729     int opcode = extract32(insn, 16, 3);
4730     int rmode = extract32(insn, 19, 2);
4731     int type = extract32(insn, 22, 2);
4732     bool sbit = extract32(insn, 29, 1);
4733     bool sf = extract32(insn, 31, 1);
4734     bool itof;
4735
4736     if (sbit || (type > 1)
4737         || (!sf && scale < 32)) {
4738         unallocated_encoding(s);
4739         return;
4740     }
4741
4742     switch ((rmode << 3) | opcode) {
4743     case 0x2: /* SCVTF */
4744     case 0x3: /* UCVTF */
4745         itof = true;
4746         break;
4747     case 0x18: /* FCVTZS */
4748     case 0x19: /* FCVTZU */
4749         itof = false;
4750         break;
4751     default:
4752         unallocated_encoding(s);
4753         return;
4754     }
4755
4756     if (!fp_access_check(s)) {
4757         return;
4758     }
4759
4760     handle_fpfpcvt(s, rd, rn, opcode, itof, FPROUNDING_ZERO, scale, sf, type);
4761 }
4762
4763 static void handle_fmov(DisasContext *s, int rd, int rn, int type, bool itof)
4764 {
4765     /* FMOV: gpr to or from float, double, or top half of quad fp reg,
4766      * without conversion.
4767      */
4768
4769     if (itof) {
4770         TCGv_i64 tcg_rn = cpu_reg(s, rn);
4771
4772         switch (type) {
4773         case 0:
4774         {
4775             /* 32 bit */
4776             TCGv_i64 tmp = tcg_temp_new_i64();
4777             tcg_gen_ext32u_i64(tmp, tcg_rn);
4778             tcg_gen_st_i64(tmp, cpu_env, fp_reg_offset(s, rd, MO_64));
4779             tcg_gen_movi_i64(tmp, 0);
4780             tcg_gen_st_i64(tmp, cpu_env, fp_reg_hi_offset(s, rd));
4781             tcg_temp_free_i64(tmp);
4782             break;
4783         }
4784         case 1:
4785         {
4786             /* 64 bit */
4787             TCGv_i64 tmp = tcg_const_i64(0);
4788             tcg_gen_st_i64(tcg_rn, cpu_env, fp_reg_offset(s, rd, MO_64));
4789             tcg_gen_st_i64(tmp, cpu_env, fp_reg_hi_offset(s, rd));
4790             tcg_temp_free_i64(tmp);
4791             break;
4792         }
4793         case 2:
4794             /* 64 bit to top half. */
4795             tcg_gen_st_i64(tcg_rn, cpu_env, fp_reg_hi_offset(s, rd));
4796             break;
4797         }
4798     } else {
4799         TCGv_i64 tcg_rd = cpu_reg(s, rd);
4800
4801         switch (type) {
4802         case 0:
4803             /* 32 bit */
4804             tcg_gen_ld32u_i64(tcg_rd, cpu_env, fp_reg_offset(s, rn, MO_32));
4805             break;
4806         case 1:
4807             /* 64 bit */
4808             tcg_gen_ld_i64(tcg_rd, cpu_env, fp_reg_offset(s, rn, MO_64));
4809             break;
4810         case 2:
4811             /* 64 bits from top half */
4812             tcg_gen_ld_i64(tcg_rd, cpu_env, fp_reg_hi_offset(s, rn));
4813             break;
4814         }
4815     }
4816 }
4817
4818 /* C3.6.30 Floating point <-> integer conversions
4819  *   31   30  29 28       24 23  22  21 20   19 18 16 15         10 9  5 4  0
4820  * +----+---+---+-----------+------+---+-------+-----+-------------+----+----+
4821  * | sf | 0 | S | 1 1 1 1 0 | type | 1 | rmode | opc | 0 0 0 0 0 0 | Rn | Rd |
4822  * +----+---+---+-----------+------+---+-------+-----+-------------+----+----+
4823  */
4824 static void disas_fp_int_conv(DisasContext *s, uint32_t insn)
4825 {
4826     int rd = extract32(insn, 0, 5);
4827     int rn = extract32(insn, 5, 5);
4828     int opcode = extract32(insn, 16, 3);
4829     int rmode = extract32(insn, 19, 2);
4830     int type = extract32(insn, 22, 2);
4831     bool sbit = extract32(insn, 29, 1);
4832     bool sf = extract32(insn, 31, 1);
4833
4834     if (sbit) {
4835         unallocated_encoding(s);
4836         return;
4837     }
4838
4839     if (opcode > 5) {
4840         /* FMOV */
4841         bool itof = opcode & 1;
4842
4843         if (rmode >= 2) {
4844             unallocated_encoding(s);
4845             return;
4846         }
4847
4848         switch (sf << 3 | type << 1 | rmode) {
4849         case 0x0: /* 32 bit */
4850         case 0xa: /* 64 bit */
4851         case 0xd: /* 64 bit to top half of quad */
4852             break;
4853         default:
4854             /* all other sf/type/rmode combinations are invalid */
4855             unallocated_encoding(s);
4856             break;
4857         }
4858
4859         if (!fp_access_check(s)) {
4860             return;
4861         }
4862         handle_fmov(s, rd, rn, type, itof);
4863     } else {
4864         /* actual FP conversions */
4865         bool itof = extract32(opcode, 1, 1);
4866
4867         if (type > 1 || (rmode != 0 && opcode > 1)) {
4868             unallocated_encoding(s);
4869             return;
4870         }
4871
4872         if (!fp_access_check(s)) {
4873             return;
4874         }
4875         handle_fpfpcvt(s, rd, rn, opcode, itof, rmode, 64, sf, type);
4876     }
4877 }
4878
4879 /* FP-specific subcases of table C3-6 (SIMD and FP data processing)
4880  *   31  30  29 28     25 24                          0
4881  * +---+---+---+---------+-----------------------------+
4882  * |   | 0 |   | 1 1 1 1 |                             |
4883  * +---+---+---+---------+-----------------------------+
4884  */
4885 static void disas_data_proc_fp(DisasContext *s, uint32_t insn)
4886 {
4887     if (extract32(insn, 24, 1)) {
4888         /* Floating point data-processing (3 source) */
4889         disas_fp_3src(s, insn);
4890     } else if (extract32(insn, 21, 1) == 0) {
4891         /* Floating point to fixed point conversions */
4892         disas_fp_fixed_conv(s, insn);
4893     } else {
4894         switch (extract32(insn, 10, 2)) {
4895         case 1:
4896             /* Floating point conditional compare */
4897             disas_fp_ccomp(s, insn);
4898             break;
4899         case 2:
4900             /* Floating point data-processing (2 source) */
4901             disas_fp_2src(s, insn);
4902             break;
4903         case 3:
4904             /* Floating point conditional select */
4905             disas_fp_csel(s, insn);
4906             break;
4907         case 0:
4908             switch (ctz32(extract32(insn, 12, 4))) {
4909             case 0: /* [15:12] == xxx1 */
4910                 /* Floating point immediate */
4911                 disas_fp_imm(s, insn);
4912                 break;
4913             case 1: /* [15:12] == xx10 */
4914                 /* Floating point compare */
4915                 disas_fp_compare(s, insn);
4916                 break;
4917             case 2: /* [15:12] == x100 */
4918                 /* Floating point data-processing (1 source) */
4919                 disas_fp_1src(s, insn);
4920                 break;
4921             case 3: /* [15:12] == 1000 */
4922                 unallocated_encoding(s);
4923                 break;
4924             default: /* [15:12] == 0000 */
4925                 /* Floating point <-> integer conversions */
4926                 disas_fp_int_conv(s, insn);
4927                 break;
4928             }
4929             break;
4930         }
4931     }
4932 }
4933
4934 static void do_ext64(DisasContext *s, TCGv_i64 tcg_left, TCGv_i64 tcg_right,
4935                      int pos)
4936 {
4937     /* Extract 64 bits from the middle of two concatenated 64 bit
4938      * vector register slices left:right. The extracted bits start
4939      * at 'pos' bits into the right (least significant) side.
4940      * We return the result in tcg_right, and guarantee not to
4941      * trash tcg_left.
4942      */
4943     TCGv_i64 tcg_tmp = tcg_temp_new_i64();
4944     assert(pos > 0 && pos < 64);
4945
4946     tcg_gen_shri_i64(tcg_right, tcg_right, pos);
4947     tcg_gen_shli_i64(tcg_tmp, tcg_left, 64 - pos);
4948     tcg_gen_or_i64(tcg_right, tcg_right, tcg_tmp);
4949
4950     tcg_temp_free_i64(tcg_tmp);
4951 }
4952
4953 /* C3.6.1 EXT
4954  *   31  30 29         24 23 22  21 20  16 15  14  11 10  9    5 4    0
4955  * +---+---+-------------+-----+---+------+---+------+---+------+------+
4956  * | 0 | Q | 1 0 1 1 1 0 | op2 | 0 |  Rm  | 0 | imm4 | 0 |  Rn  |  Rd  |
4957  * +---+---+-------------+-----+---+------+---+------+---+------+------+
4958  */
4959 static void disas_simd_ext(DisasContext *s, uint32_t insn)
4960 {
4961     int is_q = extract32(insn, 30, 1);
4962     int op2 = extract32(insn, 22, 2);
4963     int imm4 = extract32(insn, 11, 4);
4964     int rm = extract32(insn, 16, 5);
4965     int rn = extract32(insn, 5, 5);
4966     int rd = extract32(insn, 0, 5);
4967     int pos = imm4 << 3;
4968     TCGv_i64 tcg_resl, tcg_resh;
4969
4970     if (op2 != 0 || (!is_q && extract32(imm4, 3, 1))) {
4971         unallocated_encoding(s);
4972         return;
4973     }
4974
4975     if (!fp_access_check(s)) {
4976         return;
4977     }
4978
4979     tcg_resh = tcg_temp_new_i64();
4980     tcg_resl = tcg_temp_new_i64();
4981
4982     /* Vd gets bits starting at pos bits into Vm:Vn. This is
4983      * either extracting 128 bits from a 128:128 concatenation, or
4984      * extracting 64 bits from a 64:64 concatenation.
4985      */
4986     if (!is_q) {
4987         read_vec_element(s, tcg_resl, rn, 0, MO_64);
4988         if (pos != 0) {
4989             read_vec_element(s, tcg_resh, rm, 0, MO_64);
4990             do_ext64(s, tcg_resh, tcg_resl, pos);
4991         }
4992         tcg_gen_movi_i64(tcg_resh, 0);
4993     } else {
4994         TCGv_i64 tcg_hh;
4995         typedef struct {
4996             int reg;
4997             int elt;
4998         } EltPosns;
4999         EltPosns eltposns[] = { {rn, 0}, {rn, 1}, {rm, 0}, {rm, 1} };
5000         EltPosns *elt = eltposns;
5001
5002         if (pos >= 64) {
5003             elt++;
5004             pos -= 64;
5005         }
5006
5007         read_vec_element(s, tcg_resl, elt->reg, elt->elt, MO_64);
5008         elt++;
5009         read_vec_element(s, tcg_resh, elt->reg, elt->elt, MO_64);
5010         elt++;
5011         if (pos != 0) {
5012             do_ext64(s, tcg_resh, tcg_resl, pos);
5013             tcg_hh = tcg_temp_new_i64();
5014             read_vec_element(s, tcg_hh, elt->reg, elt->elt, MO_64);
5015             do_ext64(s, tcg_hh, tcg_resh, pos);
5016             tcg_temp_free_i64(tcg_hh);
5017         }
5018     }
5019
5020     write_vec_element(s, tcg_resl, rd, 0, MO_64);
5021     tcg_temp_free_i64(tcg_resl);
5022     write_vec_element(s, tcg_resh, rd, 1, MO_64);
5023     tcg_temp_free_i64(tcg_resh);
5024 }
5025
5026 /* C3.6.2 TBL/TBX
5027  *   31  30 29         24 23 22  21 20  16 15  14 13  12  11 10 9    5 4    0
5028  * +---+---+-------------+-----+---+------+---+-----+----+-----+------+------+
5029  * | 0 | Q | 0 0 1 1 1 0 | op2 | 0 |  Rm  | 0 | len | op | 0 0 |  Rn  |  Rd  |
5030  * +---+---+-------------+-----+---+------+---+-----+----+-----+------+------+
5031  */
5032 static void disas_simd_tb(DisasContext *s, uint32_t insn)
5033 {
5034     int op2 = extract32(insn, 22, 2);
5035     int is_q = extract32(insn, 30, 1);
5036     int rm = extract32(insn, 16, 5);
5037     int rn = extract32(insn, 5, 5);
5038     int rd = extract32(insn, 0, 5);
5039     int is_tblx = extract32(insn, 12, 1);
5040     int len = extract32(insn, 13, 2);
5041     TCGv_i64 tcg_resl, tcg_resh, tcg_idx;
5042     TCGv_i32 tcg_regno, tcg_numregs;
5043
5044     if (op2 != 0) {
5045         unallocated_encoding(s);
5046         return;
5047     }
5048
5049     if (!fp_access_check(s)) {
5050         return;
5051     }
5052
5053     /* This does a table lookup: for every byte element in the input
5054      * we index into a table formed from up to four vector registers,
5055      * and then the output is the result of the lookups. Our helper
5056      * function does the lookup operation for a single 64 bit part of
5057      * the input.
5058      */
5059     tcg_resl = tcg_temp_new_i64();
5060     tcg_resh = tcg_temp_new_i64();
5061
5062     if (is_tblx) {
5063         read_vec_element(s, tcg_resl, rd, 0, MO_64);
5064     } else {
5065         tcg_gen_movi_i64(tcg_resl, 0);
5066     }
5067     if (is_tblx && is_q) {
5068         read_vec_element(s, tcg_resh, rd, 1, MO_64);
5069     } else {
5070         tcg_gen_movi_i64(tcg_resh, 0);
5071     }
5072
5073     tcg_idx = tcg_temp_new_i64();
5074     tcg_regno = tcg_const_i32(rn);
5075     tcg_numregs = tcg_const_i32(len + 1);
5076     read_vec_element(s, tcg_idx, rm, 0, MO_64);
5077     gen_helper_simd_tbl(tcg_resl, cpu_env, tcg_resl, tcg_idx,
5078                         tcg_regno, tcg_numregs);
5079     if (is_q) {
5080         read_vec_element(s, tcg_idx, rm, 1, MO_64);
5081         gen_helper_simd_tbl(tcg_resh, cpu_env, tcg_resh, tcg_idx,
5082                             tcg_regno, tcg_numregs);
5083     }
5084     tcg_temp_free_i64(tcg_idx);
5085     tcg_temp_free_i32(tcg_regno);
5086     tcg_temp_free_i32(tcg_numregs);
5087
5088     write_vec_element(s, tcg_resl, rd, 0, MO_64);
5089     tcg_temp_free_i64(tcg_resl);
5090     write_vec_element(s, tcg_resh, rd, 1, MO_64);
5091     tcg_temp_free_i64(tcg_resh);
5092 }
5093
5094 /* C3.6.3 ZIP/UZP/TRN
5095  *   31  30 29         24 23  22  21 20   16 15 14 12 11 10 9    5 4    0
5096  * +---+---+-------------+------+---+------+---+------------------+------+
5097  * | 0 | Q | 0 0 1 1 1 0 | size | 0 |  Rm  | 0 | opc | 1 0 |  Rn  |  Rd  |
5098  * +---+---+-------------+------+---+------+---+------------------+------+
5099  */
5100 static void disas_simd_zip_trn(DisasContext *s, uint32_t insn)
5101 {
5102     int rd = extract32(insn, 0, 5);
5103     int rn = extract32(insn, 5, 5);
5104     int rm = extract32(insn, 16, 5);
5105     int size = extract32(insn, 22, 2);
5106     /* opc field bits [1:0] indicate ZIP/UZP/TRN;
5107      * bit 2 indicates 1 vs 2 variant of the insn.
5108      */
5109     int opcode = extract32(insn, 12, 2);
5110     bool part = extract32(insn, 14, 1);
5111     bool is_q = extract32(insn, 30, 1);
5112     int esize = 8 << size;
5113     int i, ofs;
5114     int datasize = is_q ? 128 : 64;
5115     int elements = datasize / esize;
5116     TCGv_i64 tcg_res, tcg_resl, tcg_resh;
5117
5118     if (opcode == 0 || (size == 3 && !is_q)) {
5119         unallocated_encoding(s);
5120         return;
5121     }
5122
5123     if (!fp_access_check(s)) {
5124         return;
5125     }
5126
5127     tcg_resl = tcg_const_i64(0);
5128     tcg_resh = tcg_const_i64(0);
5129     tcg_res = tcg_temp_new_i64();
5130
5131     for (i = 0; i < elements; i++) {
5132         switch (opcode) {
5133         case 1: /* UZP1/2 */
5134         {
5135             int midpoint = elements / 2;
5136             if (i < midpoint) {
5137                 read_vec_element(s, tcg_res, rn, 2 * i + part, size);
5138             } else {
5139                 read_vec_element(s, tcg_res, rm,
5140                                  2 * (i - midpoint) + part, size);
5141             }
5142             break;
5143         }
5144         case 2: /* TRN1/2 */
5145             if (i & 1) {
5146                 read_vec_element(s, tcg_res, rm, (i & ~1) + part, size);
5147             } else {
5148                 read_vec_element(s, tcg_res, rn, (i & ~1) + part, size);
5149             }
5150             break;
5151         case 3: /* ZIP1/2 */
5152         {
5153             int base = part * elements / 2;
5154             if (i & 1) {
5155                 read_vec_element(s, tcg_res, rm, base + (i >> 1), size);
5156             } else {
5157                 read_vec_element(s, tcg_res, rn, base + (i >> 1), size);
5158             }
5159             break;
5160         }
5161         default:
5162             g_assert_not_reached();
5163         }
5164
5165         ofs = i * esize;
5166         if (ofs < 64) {
5167             tcg_gen_shli_i64(tcg_res, tcg_res, ofs);
5168             tcg_gen_or_i64(tcg_resl, tcg_resl, tcg_res);
5169         } else {
5170             tcg_gen_shli_i64(tcg_res, tcg_res, ofs - 64);
5171             tcg_gen_or_i64(tcg_resh, tcg_resh, tcg_res);
5172         }
5173     }
5174
5175     tcg_temp_free_i64(tcg_res);
5176
5177     write_vec_element(s, tcg_resl, rd, 0, MO_64);
5178     tcg_temp_free_i64(tcg_resl);
5179     write_vec_element(s, tcg_resh, rd, 1, MO_64);
5180     tcg_temp_free_i64(tcg_resh);
5181 }
5182
5183 static void do_minmaxop(DisasContext *s, TCGv_i32 tcg_elt1, TCGv_i32 tcg_elt2,
5184                         int opc, bool is_min, TCGv_ptr fpst)
5185 {
5186     /* Helper function for disas_simd_across_lanes: do a single precision
5187      * min/max operation on the specified two inputs,
5188      * and return the result in tcg_elt1.
5189      */
5190     if (opc == 0xc) {
5191         if (is_min) {
5192             gen_helper_vfp_minnums(tcg_elt1, tcg_elt1, tcg_elt2, fpst);
5193         } else {
5194             gen_helper_vfp_maxnums(tcg_elt1, tcg_elt1, tcg_elt2, fpst);
5195         }
5196     } else {
5197         assert(opc == 0xf);
5198         if (is_min) {
5199             gen_helper_vfp_mins(tcg_elt1, tcg_elt1, tcg_elt2, fpst);
5200         } else {
5201             gen_helper_vfp_maxs(tcg_elt1, tcg_elt1, tcg_elt2, fpst);
5202         }
5203     }
5204 }
5205
5206 /* C3.6.4 AdvSIMD across lanes
5207  *   31  30  29 28       24 23  22 21       17 16    12 11 10 9    5 4    0
5208  * +---+---+---+-----------+------+-----------+--------+-----+------+------+
5209  * | 0 | Q | U | 0 1 1 1 0 | size | 1 1 0 0 0 | opcode | 1 0 |  Rn  |  Rd  |
5210  * +---+---+---+-----------+------+-----------+--------+-----+------+------+
5211  */
5212 static void disas_simd_across_lanes(DisasContext *s, uint32_t insn)
5213 {
5214     int rd = extract32(insn, 0, 5);
5215     int rn = extract32(insn, 5, 5);
5216     int size = extract32(insn, 22, 2);
5217     int opcode = extract32(insn, 12, 5);
5218     bool is_q = extract32(insn, 30, 1);
5219     bool is_u = extract32(insn, 29, 1);
5220     bool is_fp = false;
5221     bool is_min = false;
5222     int esize;
5223     int elements;
5224     int i;
5225     TCGv_i64 tcg_res, tcg_elt;
5226
5227     switch (opcode) {
5228     case 0x1b: /* ADDV */
5229         if (is_u) {
5230             unallocated_encoding(s);
5231             return;
5232         }
5233         /* fall through */
5234     case 0x3: /* SADDLV, UADDLV */
5235     case 0xa: /* SMAXV, UMAXV */
5236     case 0x1a: /* SMINV, UMINV */
5237         if (size == 3 || (size == 2 && !is_q)) {
5238             unallocated_encoding(s);
5239             return;
5240         }
5241         break;
5242     case 0xc: /* FMAXNMV, FMINNMV */
5243     case 0xf: /* FMAXV, FMINV */
5244         if (!is_u || !is_q || extract32(size, 0, 1)) {
5245             unallocated_encoding(s);
5246             return;
5247         }
5248         /* Bit 1 of size field encodes min vs max, and actual size is always
5249          * 32 bits: adjust the size variable so following code can rely on it
5250          */
5251         is_min = extract32(size, 1, 1);
5252         is_fp = true;
5253         size = 2;
5254         break;
5255     default:
5256         unallocated_encoding(s);
5257         return;
5258     }
5259
5260     if (!fp_access_check(s)) {
5261         return;
5262     }
5263
5264     esize = 8 << size;
5265     elements = (is_q ? 128 : 64) / esize;
5266
5267     tcg_res = tcg_temp_new_i64();
5268     tcg_elt = tcg_temp_new_i64();
5269
5270     /* These instructions operate across all lanes of a vector
5271      * to produce a single result. We can guarantee that a 64
5272      * bit intermediate is sufficient:
5273      *  + for [US]ADDLV the maximum element size is 32 bits, and
5274      *    the result type is 64 bits
5275      *  + for FMAX*V, FMIN*V, ADDV the intermediate type is the
5276      *    same as the element size, which is 32 bits at most
5277      * For the integer operations we can choose to work at 64
5278      * or 32 bits and truncate at the end; for simplicity
5279      * we use 64 bits always. The floating point
5280      * ops do require 32 bit intermediates, though.
5281      */
5282     if (!is_fp) {
5283         read_vec_element(s, tcg_res, rn, 0, size | (is_u ? 0 : MO_SIGN));
5284
5285         for (i = 1; i < elements; i++) {
5286             read_vec_element(s, tcg_elt, rn, i, size | (is_u ? 0 : MO_SIGN));
5287
5288             switch (opcode) {
5289             case 0x03: /* SADDLV / UADDLV */
5290             case 0x1b: /* ADDV */
5291                 tcg_gen_add_i64(tcg_res, tcg_res, tcg_elt);
5292                 break;
5293             case 0x0a: /* SMAXV / UMAXV */
5294                 tcg_gen_movcond_i64(is_u ? TCG_COND_GEU : TCG_COND_GE,
5295                                     tcg_res,
5296                                     tcg_res, tcg_elt, tcg_res, tcg_elt);
5297                 break;
5298             case 0x1a: /* SMINV / UMINV */
5299                 tcg_gen_movcond_i64(is_u ? TCG_COND_LEU : TCG_COND_LE,
5300                                     tcg_res,
5301                                     tcg_res, tcg_elt, tcg_res, tcg_elt);
5302                 break;
5303                 break;
5304             default:
5305                 g_assert_not_reached();
5306             }
5307
5308         }
5309     } else {
5310         /* Floating point ops which work on 32 bit (single) intermediates.
5311          * Note that correct NaN propagation requires that we do these
5312          * operations in exactly the order specified by the pseudocode.
5313          */
5314         TCGv_i32 tcg_elt1 = tcg_temp_new_i32();
5315         TCGv_i32 tcg_elt2 = tcg_temp_new_i32();
5316         TCGv_i32 tcg_elt3 = tcg_temp_new_i32();
5317         TCGv_ptr fpst = get_fpstatus_ptr();
5318
5319         assert(esize == 32);
5320         assert(elements == 4);
5321
5322         read_vec_element(s, tcg_elt, rn, 0, MO_32);
5323         tcg_gen_trunc_i64_i32(tcg_elt1, tcg_elt);
5324         read_vec_element(s, tcg_elt, rn, 1, MO_32);
5325         tcg_gen_trunc_i64_i32(tcg_elt2, tcg_elt);
5326
5327         do_minmaxop(s, tcg_elt1, tcg_elt2, opcode, is_min, fpst);
5328
5329         read_vec_element(s, tcg_elt, rn, 2, MO_32);
5330         tcg_gen_trunc_i64_i32(tcg_elt2, tcg_elt);
5331         read_vec_element(s, tcg_elt, rn, 3, MO_32);
5332         tcg_gen_trunc_i64_i32(tcg_elt3, tcg_elt);
5333
5334         do_minmaxop(s, tcg_elt2, tcg_elt3, opcode, is_min, fpst);
5335
5336         do_minmaxop(s, tcg_elt1, tcg_elt2, opcode, is_min, fpst);
5337
5338         tcg_gen_extu_i32_i64(tcg_res, tcg_elt1);
5339         tcg_temp_free_i32(tcg_elt1);
5340         tcg_temp_free_i32(tcg_elt2);
5341         tcg_temp_free_i32(tcg_elt3);
5342         tcg_temp_free_ptr(fpst);
5343     }
5344
5345     tcg_temp_free_i64(tcg_elt);
5346
5347     /* Now truncate the result to the width required for the final output */
5348     if (opcode == 0x03) {
5349         /* SADDLV, UADDLV: result is 2*esize */
5350         size++;
5351     }
5352
5353     switch (size) {
5354     case 0:
5355         tcg_gen_ext8u_i64(tcg_res, tcg_res);
5356         break;
5357     case 1:
5358         tcg_gen_ext16u_i64(tcg_res, tcg_res);
5359         break;
5360     case 2:
5361         tcg_gen_ext32u_i64(tcg_res, tcg_res);
5362         break;
5363     case 3:
5364         break;
5365     default:
5366         g_assert_not_reached();
5367     }
5368
5369     write_fp_dreg(s, rd, tcg_res);
5370     tcg_temp_free_i64(tcg_res);
5371 }
5372
5373 /* C6.3.31 DUP (Element, Vector)
5374  *
5375  *  31  30   29              21 20    16 15        10  9    5 4    0
5376  * +---+---+-------------------+--------+-------------+------+------+
5377  * | 0 | Q | 0 0 1 1 1 0 0 0 0 |  imm5  | 0 0 0 0 0 1 |  Rn  |  Rd  |
5378  * +---+---+-------------------+--------+-------------+------+------+
5379  *
5380  * size: encoded in imm5 (see ARM ARM LowestSetBit())
5381  */
5382 static void handle_simd_dupe(DisasContext *s, int is_q, int rd, int rn,
5383                              int imm5)
5384 {
5385     int size = ctz32(imm5);
5386     int esize = 8 << size;
5387     int elements = (is_q ? 128 : 64) / esize;
5388     int index, i;
5389     TCGv_i64 tmp;
5390
5391     if (size > 3 || (size == 3 && !is_q)) {
5392         unallocated_encoding(s);
5393         return;
5394     }
5395
5396     if (!fp_access_check(s)) {
5397         return;
5398     }
5399
5400     index = imm5 >> (size + 1);
5401
5402     tmp = tcg_temp_new_i64();
5403     read_vec_element(s, tmp, rn, index, size);
5404
5405     for (i = 0; i < elements; i++) {
5406         write_vec_element(s, tmp, rd, i, size);
5407     }
5408
5409     if (!is_q) {
5410         clear_vec_high(s, rd);
5411     }
5412
5413     tcg_temp_free_i64(tmp);
5414 }
5415
5416 /* C6.3.31 DUP (element, scalar)
5417  *  31                   21 20    16 15        10  9    5 4    0
5418  * +-----------------------+--------+-------------+------+------+
5419  * | 0 1 0 1 1 1 1 0 0 0 0 |  imm5  | 0 0 0 0 0 1 |  Rn  |  Rd  |
5420  * +-----------------------+--------+-------------+------+------+
5421  */
5422 static void handle_simd_dupes(DisasContext *s, int rd, int rn,
5423                               int imm5)
5424 {
5425     int size = ctz32(imm5);
5426     int index;
5427     TCGv_i64 tmp;
5428
5429     if (size > 3) {
5430         unallocated_encoding(s);
5431         return;
5432     }
5433
5434     if (!fp_access_check(s)) {
5435         return;
5436     }
5437
5438     index = imm5 >> (size + 1);
5439
5440     /* This instruction just extracts the specified element and
5441      * zero-extends it into the bottom of the destination register.
5442      */
5443     tmp = tcg_temp_new_i64();
5444     read_vec_element(s, tmp, rn, index, size);
5445     write_fp_dreg(s, rd, tmp);
5446     tcg_temp_free_i64(tmp);
5447 }
5448
5449 /* C6.3.32 DUP (General)
5450  *
5451  *  31  30   29              21 20    16 15        10  9    5 4    0
5452  * +---+---+-------------------+--------+-------------+------+------+
5453  * | 0 | Q | 0 0 1 1 1 0 0 0 0 |  imm5  | 0 0 0 0 1 1 |  Rn  |  Rd  |
5454  * +---+---+-------------------+--------+-------------+------+------+
5455  *
5456  * size: encoded in imm5 (see ARM ARM LowestSetBit())
5457  */
5458 static void handle_simd_dupg(DisasContext *s, int is_q, int rd, int rn,
5459                              int imm5)
5460 {
5461     int size = ctz32(imm5);
5462     int esize = 8 << size;
5463     int elements = (is_q ? 128 : 64)/esize;
5464     int i = 0;
5465
5466     if (size > 3 || ((size == 3) && !is_q)) {
5467         unallocated_encoding(s);
5468         return;
5469     }
5470
5471     if (!fp_access_check(s)) {
5472         return;
5473     }
5474
5475     for (i = 0; i < elements; i++) {
5476         write_vec_element(s, cpu_reg(s, rn), rd, i, size);
5477     }
5478     if (!is_q) {
5479         clear_vec_high(s, rd);
5480     }
5481 }
5482
5483 /* C6.3.150 INS (Element)
5484  *
5485  *  31                   21 20    16 15  14    11  10 9    5 4    0
5486  * +-----------------------+--------+------------+---+------+------+
5487  * | 0 1 1 0 1 1 1 0 0 0 0 |  imm5  | 0 |  imm4  | 1 |  Rn  |  Rd  |
5488  * +-----------------------+--------+------------+---+------+------+
5489  *
5490  * size: encoded in imm5 (see ARM ARM LowestSetBit())
5491  * index: encoded in imm5<4:size+1>
5492  */
5493 static void handle_simd_inse(DisasContext *s, int rd, int rn,
5494                              int imm4, int imm5)
5495 {
5496     int size = ctz32(imm5);
5497     int src_index, dst_index;
5498     TCGv_i64 tmp;
5499
5500     if (size > 3) {
5501         unallocated_encoding(s);
5502         return;
5503     }
5504
5505     if (!fp_access_check(s)) {
5506         return;
5507     }
5508
5509     dst_index = extract32(imm5, 1+size, 5);
5510     src_index = extract32(imm4, size, 4);
5511
5512     tmp = tcg_temp_new_i64();
5513
5514     read_vec_element(s, tmp, rn, src_index, size);
5515     write_vec_element(s, tmp, rd, dst_index, size);
5516
5517     tcg_temp_free_i64(tmp);
5518 }
5519
5520
5521 /* C6.3.151 INS (General)
5522  *
5523  *  31                   21 20    16 15        10  9    5 4    0
5524  * +-----------------------+--------+-------------+------+------+
5525  * | 0 1 0 0 1 1 1 0 0 0 0 |  imm5  | 0 0 0 1 1 1 |  Rn  |  Rd  |
5526  * +-----------------------+--------+-------------+------+------+
5527  *
5528  * size: encoded in imm5 (see ARM ARM LowestSetBit())
5529  * index: encoded in imm5<4:size+1>
5530  */
5531 static void handle_simd_insg(DisasContext *s, int rd, int rn, int imm5)
5532 {
5533     int size = ctz32(imm5);
5534     int idx;
5535
5536     if (size > 3) {
5537         unallocated_encoding(s);
5538         return;
5539     }
5540
5541     if (!fp_access_check(s)) {
5542         return;
5543     }
5544
5545     idx = extract32(imm5, 1 + size, 4 - size);
5546     write_vec_element(s, cpu_reg(s, rn), rd, idx, size);
5547 }
5548
5549 /*
5550  * C6.3.321 UMOV (General)
5551  * C6.3.237 SMOV (General)
5552  *
5553  *  31  30   29              21 20    16 15    12   10 9    5 4    0
5554  * +---+---+-------------------+--------+-------------+------+------+
5555  * | 0 | Q | 0 0 1 1 1 0 0 0 0 |  imm5  | 0 0 1 U 1 1 |  Rn  |  Rd  |
5556  * +---+---+-------------------+--------+-------------+------+------+
5557  *
5558  * U: unsigned when set
5559  * size: encoded in imm5 (see ARM ARM LowestSetBit())
5560  */
5561 static void handle_simd_umov_smov(DisasContext *s, int is_q, int is_signed,
5562                                   int rn, int rd, int imm5)
5563 {
5564     int size = ctz32(imm5);
5565     int element;
5566     TCGv_i64 tcg_rd;
5567
5568     /* Check for UnallocatedEncodings */
5569     if (is_signed) {
5570         if (size > 2 || (size == 2 && !is_q)) {
5571             unallocated_encoding(s);
5572             return;
5573         }
5574     } else {
5575         if (size > 3
5576             || (size < 3 && is_q)
5577             || (size == 3 && !is_q)) {
5578             unallocated_encoding(s);
5579             return;
5580         }
5581     }
5582
5583     if (!fp_access_check(s)) {
5584         return;
5585     }
5586
5587     element = extract32(imm5, 1+size, 4);
5588
5589     tcg_rd = cpu_reg(s, rd);
5590     read_vec_element(s, tcg_rd, rn, element, size | (is_signed ? MO_SIGN : 0));
5591     if (is_signed && !is_q) {
5592         tcg_gen_ext32u_i64(tcg_rd, tcg_rd);
5593     }
5594 }
5595
5596 /* C3.6.5 AdvSIMD copy
5597  *   31  30  29  28             21 20  16 15  14  11 10  9    5 4    0
5598  * +---+---+----+-----------------+------+---+------+---+------+------+
5599  * | 0 | Q | op | 0 1 1 1 0 0 0 0 | imm5 | 0 | imm4 | 1 |  Rn  |  Rd  |
5600  * +---+---+----+-----------------+------+---+------+---+------+------+
5601  */
5602 static void disas_simd_copy(DisasContext *s, uint32_t insn)
5603 {
5604     int rd = extract32(insn, 0, 5);
5605     int rn = extract32(insn, 5, 5);
5606     int imm4 = extract32(insn, 11, 4);
5607     int op = extract32(insn, 29, 1);
5608     int is_q = extract32(insn, 30, 1);
5609     int imm5 = extract32(insn, 16, 5);
5610
5611     if (op) {
5612         if (is_q) {
5613             /* INS (element) */
5614             handle_simd_inse(s, rd, rn, imm4, imm5);
5615         } else {
5616             unallocated_encoding(s);
5617         }
5618     } else {
5619         switch (imm4) {
5620         case 0:
5621             /* DUP (element - vector) */
5622             handle_simd_dupe(s, is_q, rd, rn, imm5);
5623             break;
5624         case 1:
5625             /* DUP (general) */
5626             handle_simd_dupg(s, is_q, rd, rn, imm5);
5627             break;
5628         case 3:
5629             if (is_q) {
5630                 /* INS (general) */
5631                 handle_simd_insg(s, rd, rn, imm5);
5632             } else {
5633                 unallocated_encoding(s);
5634             }
5635             break;
5636         case 5:
5637         case 7:
5638             /* UMOV/SMOV (is_q indicates 32/64; imm4 indicates signedness) */
5639             handle_simd_umov_smov(s, is_q, (imm4 == 5), rn, rd, imm5);
5640             break;
5641         default:
5642             unallocated_encoding(s);
5643             break;
5644         }
5645     }
5646 }
5647
5648 /* C3.6.6 AdvSIMD modified immediate
5649  *  31  30   29  28                 19 18 16 15   12  11  10  9     5 4    0
5650  * +---+---+----+---------------------+-----+-------+----+---+-------+------+
5651  * | 0 | Q | op | 0 1 1 1 1 0 0 0 0 0 | abc | cmode | o2 | 1 | defgh |  Rd  |
5652  * +---+---+----+---------------------+-----+-------+----+---+-------+------+
5653  *
5654  * There are a number of operations that can be carried out here:
5655  *   MOVI - move (shifted) imm into register
5656  *   MVNI - move inverted (shifted) imm into register
5657  *   ORR  - bitwise OR of (shifted) imm with register
5658  *   BIC  - bitwise clear of (shifted) imm with register
5659  */
5660 static void disas_simd_mod_imm(DisasContext *s, uint32_t insn)
5661 {
5662     int rd = extract32(insn, 0, 5);
5663     int cmode = extract32(insn, 12, 4);
5664     int cmode_3_1 = extract32(cmode, 1, 3);
5665     int cmode_0 = extract32(cmode, 0, 1);
5666     int o2 = extract32(insn, 11, 1);
5667     uint64_t abcdefgh = extract32(insn, 5, 5) | (extract32(insn, 16, 3) << 5);
5668     bool is_neg = extract32(insn, 29, 1);
5669     bool is_q = extract32(insn, 30, 1);
5670     uint64_t imm = 0;
5671     TCGv_i64 tcg_rd, tcg_imm;
5672     int i;
5673
5674     if (o2 != 0 || ((cmode == 0xf) && is_neg && !is_q)) {
5675         unallocated_encoding(s);
5676         return;
5677     }
5678
5679     if (!fp_access_check(s)) {
5680         return;
5681     }
5682
5683     /* See AdvSIMDExpandImm() in ARM ARM */
5684     switch (cmode_3_1) {
5685     case 0: /* Replicate(Zeros(24):imm8, 2) */
5686     case 1: /* Replicate(Zeros(16):imm8:Zeros(8), 2) */
5687     case 2: /* Replicate(Zeros(8):imm8:Zeros(16), 2) */
5688     case 3: /* Replicate(imm8:Zeros(24), 2) */
5689     {
5690         int shift = cmode_3_1 * 8;
5691         imm = bitfield_replicate(abcdefgh << shift, 32);
5692         break;
5693     }
5694     case 4: /* Replicate(Zeros(8):imm8, 4) */
5695     case 5: /* Replicate(imm8:Zeros(8), 4) */
5696     {
5697         int shift = (cmode_3_1 & 0x1) * 8;
5698         imm = bitfield_replicate(abcdefgh << shift, 16);
5699         break;
5700     }
5701     case 6:
5702         if (cmode_0) {
5703             /* Replicate(Zeros(8):imm8:Ones(16), 2) */
5704             imm = (abcdefgh << 16) | 0xffff;
5705         } else {
5706             /* Replicate(Zeros(16):imm8:Ones(8), 2) */
5707             imm = (abcdefgh << 8) | 0xff;
5708         }
5709         imm = bitfield_replicate(imm, 32);
5710         break;
5711     case 7:
5712         if (!cmode_0 && !is_neg) {
5713             imm = bitfield_replicate(abcdefgh, 8);
5714         } else if (!cmode_0 && is_neg) {
5715             int i;
5716             imm = 0;
5717             for (i = 0; i < 8; i++) {
5718                 if ((abcdefgh) & (1 << i)) {
5719                     imm |= 0xffULL << (i * 8);
5720                 }
5721             }
5722         } else if (cmode_0) {
5723             if (is_neg) {
5724                 imm = (abcdefgh & 0x3f) << 48;
5725                 if (abcdefgh & 0x80) {
5726                     imm |= 0x8000000000000000ULL;
5727                 }
5728                 if (abcdefgh & 0x40) {
5729                     imm |= 0x3fc0000000000000ULL;
5730                 } else {
5731                     imm |= 0x4000000000000000ULL;
5732                 }
5733             } else {
5734                 imm = (abcdefgh & 0x3f) << 19;
5735                 if (abcdefgh & 0x80) {
5736                     imm |= 0x80000000;
5737                 }
5738                 if (abcdefgh & 0x40) {
5739                     imm |= 0x3e000000;
5740                 } else {
5741                     imm |= 0x40000000;
5742                 }
5743                 imm |= (imm << 32);
5744             }
5745         }
5746         break;
5747     }
5748
5749     if (cmode_3_1 != 7 && is_neg) {
5750         imm = ~imm;
5751     }
5752
5753     tcg_imm = tcg_const_i64(imm);
5754     tcg_rd = new_tmp_a64(s);
5755
5756     for (i = 0; i < 2; i++) {
5757         int foffs = i ? fp_reg_hi_offset(s, rd) : fp_reg_offset(s, rd, MO_64);
5758
5759         if (i == 1 && !is_q) {
5760             /* non-quad ops clear high half of vector */
5761             tcg_gen_movi_i64(tcg_rd, 0);
5762         } else if ((cmode & 0x9) == 0x1 || (cmode & 0xd) == 0x9) {
5763             tcg_gen_ld_i64(tcg_rd, cpu_env, foffs);
5764             if (is_neg) {
5765                 /* AND (BIC) */
5766                 tcg_gen_and_i64(tcg_rd, tcg_rd, tcg_imm);
5767             } else {
5768                 /* ORR */
5769                 tcg_gen_or_i64(tcg_rd, tcg_rd, tcg_imm);
5770             }
5771         } else {
5772             /* MOVI */
5773             tcg_gen_mov_i64(tcg_rd, tcg_imm);
5774         }
5775         tcg_gen_st_i64(tcg_rd, cpu_env, foffs);
5776     }
5777
5778     tcg_temp_free_i64(tcg_imm);
5779 }
5780
5781 /* C3.6.7 AdvSIMD scalar copy
5782  *  31 30  29  28             21 20  16 15  14  11 10  9    5 4    0
5783  * +-----+----+-----------------+------+---+------+---+------+------+
5784  * | 0 1 | op | 1 1 1 1 0 0 0 0 | imm5 | 0 | imm4 | 1 |  Rn  |  Rd  |
5785  * +-----+----+-----------------+------+---+------+---+------+------+
5786  */
5787 static void disas_simd_scalar_copy(DisasContext *s, uint32_t insn)
5788 {
5789     int rd = extract32(insn, 0, 5);
5790     int rn = extract32(insn, 5, 5);
5791     int imm4 = extract32(insn, 11, 4);
5792     int imm5 = extract32(insn, 16, 5);
5793     int op = extract32(insn, 29, 1);
5794
5795     if (op != 0 || imm4 != 0) {
5796         unallocated_encoding(s);
5797         return;
5798     }
5799
5800     /* DUP (element, scalar) */
5801     handle_simd_dupes(s, rd, rn, imm5);
5802 }
5803
5804 /* C3.6.8 AdvSIMD scalar pairwise
5805  *  31 30  29 28       24 23  22 21       17 16    12 11 10 9    5 4    0
5806  * +-----+---+-----------+------+-----------+--------+-----+------+------+
5807  * | 0 1 | U | 1 1 1 1 0 | size | 1 1 0 0 0 | opcode | 1 0 |  Rn  |  Rd  |
5808  * +-----+---+-----------+------+-----------+--------+-----+------+------+
5809  */
5810 static void disas_simd_scalar_pairwise(DisasContext *s, uint32_t insn)
5811 {
5812     int u = extract32(insn, 29, 1);
5813     int size = extract32(insn, 22, 2);
5814     int opcode = extract32(insn, 12, 5);
5815     int rn = extract32(insn, 5, 5);
5816     int rd = extract32(insn, 0, 5);
5817     TCGv_ptr fpst;
5818
5819     /* For some ops (the FP ones), size[1] is part of the encoding.
5820      * For ADDP strictly it is not but size[1] is always 1 for valid
5821      * encodings.
5822      */
5823     opcode |= (extract32(size, 1, 1) << 5);
5824
5825     switch (opcode) {
5826     case 0x3b: /* ADDP */
5827         if (u || size != 3) {
5828             unallocated_encoding(s);
5829             return;
5830         }
5831         if (!fp_access_check(s)) {
5832             return;
5833         }
5834
5835         TCGV_UNUSED_PTR(fpst);
5836         break;
5837     case 0xc: /* FMAXNMP */
5838     case 0xd: /* FADDP */
5839     case 0xf: /* FMAXP */
5840     case 0x2c: /* FMINNMP */
5841     case 0x2f: /* FMINP */
5842         /* FP op, size[0] is 32 or 64 bit */
5843         if (!u) {
5844             unallocated_encoding(s);
5845             return;
5846         }
5847         if (!fp_access_check(s)) {
5848             return;
5849         }
5850
5851         size = extract32(size, 0, 1) ? 3 : 2;
5852         fpst = get_fpstatus_ptr();
5853         break;
5854     default:
5855         unallocated_encoding(s);
5856         return;
5857     }
5858
5859     if (size == 3) {
5860         TCGv_i64 tcg_op1 = tcg_temp_new_i64();
5861         TCGv_i64 tcg_op2 = tcg_temp_new_i64();
5862         TCGv_i64 tcg_res = tcg_temp_new_i64();
5863
5864         read_vec_element(s, tcg_op1, rn, 0, MO_64);
5865         read_vec_element(s, tcg_op2, rn, 1, MO_64);
5866
5867         switch (opcode) {
5868         case 0x3b: /* ADDP */
5869             tcg_gen_add_i64(tcg_res, tcg_op1, tcg_op2);
5870             break;
5871         case 0xc: /* FMAXNMP */
5872             gen_helper_vfp_maxnumd(tcg_res, tcg_op1, tcg_op2, fpst);
5873             break;
5874         case 0xd: /* FADDP */
5875             gen_helper_vfp_addd(tcg_res, tcg_op1, tcg_op2, fpst);
5876             break;
5877         case 0xf: /* FMAXP */
5878             gen_helper_vfp_maxd(tcg_res, tcg_op1, tcg_op2, fpst);
5879             break;
5880         case 0x2c: /* FMINNMP */
5881             gen_helper_vfp_minnumd(tcg_res, tcg_op1, tcg_op2, fpst);
5882             break;
5883         case 0x2f: /* FMINP */
5884             gen_helper_vfp_mind(tcg_res, tcg_op1, tcg_op2, fpst);
5885             break;
5886         default:
5887             g_assert_not_reached();
5888         }
5889
5890         write_fp_dreg(s, rd, tcg_res);
5891
5892         tcg_temp_free_i64(tcg_op1);
5893         tcg_temp_free_i64(tcg_op2);
5894         tcg_temp_free_i64(tcg_res);
5895     } else {
5896         TCGv_i32 tcg_op1 = tcg_temp_new_i32();
5897         TCGv_i32 tcg_op2 = tcg_temp_new_i32();
5898         TCGv_i32 tcg_res = tcg_temp_new_i32();
5899
5900         read_vec_element_i32(s, tcg_op1, rn, 0, MO_32);
5901         read_vec_element_i32(s, tcg_op2, rn, 1, MO_32);
5902
5903         switch (opcode) {
5904         case 0xc: /* FMAXNMP */
5905             gen_helper_vfp_maxnums(tcg_res, tcg_op1, tcg_op2, fpst);
5906             break;
5907         case 0xd: /* FADDP */
5908             gen_helper_vfp_adds(tcg_res, tcg_op1, tcg_op2, fpst);
5909             break;
5910         case 0xf: /* FMAXP */
5911             gen_helper_vfp_maxs(tcg_res, tcg_op1, tcg_op2, fpst);
5912             break;
5913         case 0x2c: /* FMINNMP */
5914             gen_helper_vfp_minnums(tcg_res, tcg_op1, tcg_op2, fpst);
5915             break;
5916         case 0x2f: /* FMINP */
5917             gen_helper_vfp_mins(tcg_res, tcg_op1, tcg_op2, fpst);
5918             break;
5919         default:
5920             g_assert_not_reached();
5921         }
5922
5923         write_fp_sreg(s, rd, tcg_res);
5924
5925         tcg_temp_free_i32(tcg_op1);
5926         tcg_temp_free_i32(tcg_op2);
5927         tcg_temp_free_i32(tcg_res);
5928     }
5929
5930     if (!TCGV_IS_UNUSED_PTR(fpst)) {
5931         tcg_temp_free_ptr(fpst);
5932     }
5933 }
5934
5935 /*
5936  * Common SSHR[RA]/USHR[RA] - Shift right (optional rounding/accumulate)
5937  *
5938  * This code is handles the common shifting code and is used by both
5939  * the vector and scalar code.
5940  */
5941 static void handle_shri_with_rndacc(TCGv_i64 tcg_res, TCGv_i64 tcg_src,
5942                                     TCGv_i64 tcg_rnd, bool accumulate,
5943                                     bool is_u, int size, int shift)
5944 {
5945     bool extended_result = false;
5946     bool round = !TCGV_IS_UNUSED_I64(tcg_rnd);
5947     int ext_lshift = 0;
5948     TCGv_i64 tcg_src_hi;
5949
5950     if (round && size == 3) {
5951         extended_result = true;
5952         ext_lshift = 64 - shift;
5953         tcg_src_hi = tcg_temp_new_i64();
5954     } else if (shift == 64) {
5955         if (!accumulate && is_u) {
5956             /* result is zero */
5957             tcg_gen_movi_i64(tcg_res, 0);
5958             return;
5959         }
5960     }
5961
5962     /* Deal with the rounding step */
5963     if (round) {
5964         if (extended_result) {
5965             TCGv_i64 tcg_zero = tcg_const_i64(0);
5966             if (!is_u) {
5967                 /* take care of sign extending tcg_res */
5968                 tcg_gen_sari_i64(tcg_src_hi, tcg_src, 63);
5969                 tcg_gen_add2_i64(tcg_src, tcg_src_hi,
5970                                  tcg_src, tcg_src_hi,
5971                                  tcg_rnd, tcg_zero);
5972             } else {
5973                 tcg_gen_add2_i64(tcg_src, tcg_src_hi,
5974                                  tcg_src, tcg_zero,
5975                                  tcg_rnd, tcg_zero);
5976             }
5977             tcg_temp_free_i64(tcg_zero);
5978         } else {
5979             tcg_gen_add_i64(tcg_src, tcg_src, tcg_rnd);
5980         }
5981     }
5982
5983     /* Now do the shift right */
5984     if (round && extended_result) {
5985         /* extended case, >64 bit precision required */
5986         if (ext_lshift == 0) {
5987             /* special case, only high bits matter */
5988             tcg_gen_mov_i64(tcg_src, tcg_src_hi);
5989         } else {
5990             tcg_gen_shri_i64(tcg_src, tcg_src, shift);
5991             tcg_gen_shli_i64(tcg_src_hi, tcg_src_hi, ext_lshift);
5992             tcg_gen_or_i64(tcg_src, tcg_src, tcg_src_hi);
5993         }
5994     } else {
5995         if (is_u) {
5996             if (shift == 64) {
5997                 /* essentially shifting in 64 zeros */
5998                 tcg_gen_movi_i64(tcg_src, 0);
5999             } else {
6000                 tcg_gen_shri_i64(tcg_src, tcg_src, shift);
6001             }
6002         } else {
6003             if (shift == 64) {
6004                 /* effectively extending the sign-bit */
6005                 tcg_gen_sari_i64(tcg_src, tcg_src, 63);
6006             } else {
6007                 tcg_gen_sari_i64(tcg_src, tcg_src, shift);
6008             }
6009         }
6010     }
6011
6012     if (accumulate) {
6013         tcg_gen_add_i64(tcg_res, tcg_res, tcg_src);
6014     } else {
6015         tcg_gen_mov_i64(tcg_res, tcg_src);
6016     }
6017
6018     if (extended_result) {
6019         tcg_temp_free_i64(tcg_src_hi);
6020     }
6021 }
6022
6023 /* Common SHL/SLI - Shift left with an optional insert */
6024 static void handle_shli_with_ins(TCGv_i64 tcg_res, TCGv_i64 tcg_src,
6025                                  bool insert, int shift)
6026 {
6027     if (insert) { /* SLI */
6028         tcg_gen_deposit_i64(tcg_res, tcg_res, tcg_src, shift, 64 - shift);
6029     } else { /* SHL */
6030         tcg_gen_shli_i64(tcg_res, tcg_src, shift);
6031     }
6032 }
6033
6034 /* SRI: shift right with insert */
6035 static void handle_shri_with_ins(TCGv_i64 tcg_res, TCGv_i64 tcg_src,
6036                                  int size, int shift)
6037 {
6038     int esize = 8 << size;
6039
6040     /* shift count same as element size is valid but does nothing;
6041      * special case to avoid potential shift by 64.
6042      */
6043     if (shift != esize) {
6044         tcg_gen_shri_i64(tcg_src, tcg_src, shift);
6045         tcg_gen_deposit_i64(tcg_res, tcg_res, tcg_src, 0, esize - shift);
6046     }
6047 }
6048
6049 /* SSHR[RA]/USHR[RA] - Scalar shift right (optional rounding/accumulate) */
6050 static void handle_scalar_simd_shri(DisasContext *s,
6051                                     bool is_u, int immh, int immb,
6052                                     int opcode, int rn, int rd)
6053 {
6054     const int size = 3;
6055     int immhb = immh << 3 | immb;
6056     int shift = 2 * (8 << size) - immhb;
6057     bool accumulate = false;
6058     bool round = false;
6059     bool insert = false;
6060     TCGv_i64 tcg_rn;
6061     TCGv_i64 tcg_rd;
6062     TCGv_i64 tcg_round;
6063
6064     if (!extract32(immh, 3, 1)) {
6065         unallocated_encoding(s);
6066         return;
6067     }
6068
6069     if (!fp_access_check(s)) {
6070         return;
6071     }
6072
6073     switch (opcode) {
6074     case 0x02: /* SSRA / USRA (accumulate) */
6075         accumulate = true;
6076         break;
6077     case 0x04: /* SRSHR / URSHR (rounding) */
6078         round = true;
6079         break;
6080     case 0x06: /* SRSRA / URSRA (accum + rounding) */
6081         accumulate = round = true;
6082         break;
6083     case 0x08: /* SRI */
6084         insert = true;
6085         break;
6086     }
6087
6088     if (round) {
6089         uint64_t round_const = 1ULL << (shift - 1);
6090         tcg_round = tcg_const_i64(round_const);
6091     } else {
6092         TCGV_UNUSED_I64(tcg_round);
6093     }
6094
6095     tcg_rn = read_fp_dreg(s, rn);
6096     tcg_rd = (accumulate || insert) ? read_fp_dreg(s, rd) : tcg_temp_new_i64();
6097
6098     if (insert) {
6099         handle_shri_with_ins(tcg_rd, tcg_rn, size, shift);
6100     } else {
6101         handle_shri_with_rndacc(tcg_rd, tcg_rn, tcg_round,
6102                                 accumulate, is_u, size, shift);
6103     }
6104
6105     write_fp_dreg(s, rd, tcg_rd);
6106
6107     tcg_temp_free_i64(tcg_rn);
6108     tcg_temp_free_i64(tcg_rd);
6109     if (round) {
6110         tcg_temp_free_i64(tcg_round);
6111     }
6112 }
6113
6114 /* SHL/SLI - Scalar shift left */
6115 static void handle_scalar_simd_shli(DisasContext *s, bool insert,
6116                                     int immh, int immb, int opcode,
6117                                     int rn, int rd)
6118 {
6119     int size = 32 - clz32(immh) - 1;
6120     int immhb = immh << 3 | immb;
6121     int shift = immhb - (8 << size);
6122     TCGv_i64 tcg_rn = new_tmp_a64(s);
6123     TCGv_i64 tcg_rd = new_tmp_a64(s);
6124
6125     if (!extract32(immh, 3, 1)) {
6126         unallocated_encoding(s);
6127         return;
6128     }
6129
6130     if (!fp_access_check(s)) {
6131         return;
6132     }
6133
6134     tcg_rn = read_fp_dreg(s, rn);
6135     tcg_rd = insert ? read_fp_dreg(s, rd) : tcg_temp_new_i64();
6136
6137     handle_shli_with_ins(tcg_rd, tcg_rn, insert, shift);
6138
6139     write_fp_dreg(s, rd, tcg_rd);
6140
6141     tcg_temp_free_i64(tcg_rn);
6142     tcg_temp_free_i64(tcg_rd);
6143 }
6144
6145 /* SQSHRN/SQSHRUN - Saturating (signed/unsigned) shift right with
6146  * (signed/unsigned) narrowing */
6147 static void handle_vec_simd_sqshrn(DisasContext *s, bool is_scalar, bool is_q,
6148                                    bool is_u_shift, bool is_u_narrow,
6149                                    int immh, int immb, int opcode,
6150                                    int rn, int rd)
6151 {
6152     int immhb = immh << 3 | immb;
6153     int size = 32 - clz32(immh) - 1;
6154     int esize = 8 << size;
6155     int shift = (2 * esize) - immhb;
6156     int elements = is_scalar ? 1 : (64 / esize);
6157     bool round = extract32(opcode, 0, 1);
6158     TCGMemOp ldop = (size + 1) | (is_u_shift ? 0 : MO_SIGN);
6159     TCGv_i64 tcg_rn, tcg_rd, tcg_round;
6160     TCGv_i32 tcg_rd_narrowed;
6161     TCGv_i64 tcg_final;
6162
6163     static NeonGenNarrowEnvFn * const signed_narrow_fns[4][2] = {
6164         { gen_helper_neon_narrow_sat_s8,
6165           gen_helper_neon_unarrow_sat8 },
6166         { gen_helper_neon_narrow_sat_s16,
6167           gen_helper_neon_unarrow_sat16 },
6168         { gen_helper_neon_narrow_sat_s32,
6169           gen_helper_neon_unarrow_sat32 },
6170         { NULL, NULL },
6171     };
6172     static NeonGenNarrowEnvFn * const unsigned_narrow_fns[4] = {
6173         gen_helper_neon_narrow_sat_u8,
6174         gen_helper_neon_narrow_sat_u16,
6175         gen_helper_neon_narrow_sat_u32,
6176         NULL
6177     };
6178     NeonGenNarrowEnvFn *narrowfn;
6179
6180     int i;
6181
6182     assert(size < 4);
6183
6184     if (extract32(immh, 3, 1)) {
6185         unallocated_encoding(s);
6186         return;
6187     }
6188
6189     if (!fp_access_check(s)) {
6190         return;
6191     }
6192
6193     if (is_u_shift) {
6194         narrowfn = unsigned_narrow_fns[size];
6195     } else {
6196         narrowfn = signed_narrow_fns[size][is_u_narrow ? 1 : 0];
6197     }
6198
6199     tcg_rn = tcg_temp_new_i64();
6200     tcg_rd = tcg_temp_new_i64();
6201     tcg_rd_narrowed = tcg_temp_new_i32();
6202     tcg_final = tcg_const_i64(0);
6203
6204     if (round) {
6205         uint64_t round_const = 1ULL << (shift - 1);
6206         tcg_round = tcg_const_i64(round_const);
6207     } else {
6208         TCGV_UNUSED_I64(tcg_round);
6209     }
6210
6211     for (i = 0; i < elements; i++) {
6212         read_vec_element(s, tcg_rn, rn, i, ldop);
6213         handle_shri_with_rndacc(tcg_rd, tcg_rn, tcg_round,
6214                                 false, is_u_shift, size+1, shift);
6215         narrowfn(tcg_rd_narrowed, cpu_env, tcg_rd);
6216         tcg_gen_extu_i32_i64(tcg_rd, tcg_rd_narrowed);
6217         tcg_gen_deposit_i64(tcg_final, tcg_final, tcg_rd, esize * i, esize);
6218     }
6219
6220     if (!is_q) {
6221         clear_vec_high(s, rd);
6222         write_vec_element(s, tcg_final, rd, 0, MO_64);
6223     } else {
6224         write_vec_element(s, tcg_final, rd, 1, MO_64);
6225     }
6226
6227     if (round) {
6228         tcg_temp_free_i64(tcg_round);
6229     }
6230     tcg_temp_free_i64(tcg_rn);
6231     tcg_temp_free_i64(tcg_rd);
6232     tcg_temp_free_i32(tcg_rd_narrowed);
6233     tcg_temp_free_i64(tcg_final);
6234     return;
6235 }
6236
6237 /* SQSHLU, UQSHL, SQSHL: saturating left shifts */
6238 static void handle_simd_qshl(DisasContext *s, bool scalar, bool is_q,
6239                              bool src_unsigned, bool dst_unsigned,
6240                              int immh, int immb, int rn, int rd)
6241 {
6242     int immhb = immh << 3 | immb;
6243     int size = 32 - clz32(immh) - 1;
6244     int shift = immhb - (8 << size);
6245     int pass;
6246
6247     assert(immh != 0);
6248     assert(!(scalar && is_q));
6249
6250     if (!scalar) {
6251         if (!is_q && extract32(immh, 3, 1)) {
6252             unallocated_encoding(s);
6253             return;
6254         }
6255
6256         /* Since we use the variable-shift helpers we must
6257          * replicate the shift count into each element of
6258          * the tcg_shift value.
6259          */
6260         switch (size) {
6261         case 0:
6262             shift |= shift << 8;
6263             /* fall through */
6264         case 1:
6265             shift |= shift << 16;
6266             break;
6267         case 2:
6268         case 3:
6269             break;
6270         default:
6271             g_assert_not_reached();
6272         }
6273     }
6274
6275     if (!fp_access_check(s)) {
6276         return;
6277     }
6278
6279     if (size == 3) {
6280         TCGv_i64 tcg_shift = tcg_const_i64(shift);
6281         static NeonGenTwo64OpEnvFn * const fns[2][2] = {
6282             { gen_helper_neon_qshl_s64, gen_helper_neon_qshlu_s64 },
6283             { NULL, gen_helper_neon_qshl_u64 },
6284         };
6285         NeonGenTwo64OpEnvFn *genfn = fns[src_unsigned][dst_unsigned];
6286         int maxpass = is_q ? 2 : 1;
6287
6288         for (pass = 0; pass < maxpass; pass++) {
6289             TCGv_i64 tcg_op = tcg_temp_new_i64();
6290
6291             read_vec_element(s, tcg_op, rn, pass, MO_64);
6292             genfn(tcg_op, cpu_env, tcg_op, tcg_shift);
6293             write_vec_element(s, tcg_op, rd, pass, MO_64);
6294
6295             tcg_temp_free_i64(tcg_op);
6296         }
6297         tcg_temp_free_i64(tcg_shift);
6298
6299         if (!is_q) {
6300             clear_vec_high(s, rd);
6301         }
6302     } else {
6303         TCGv_i32 tcg_shift = tcg_const_i32(shift);
6304         static NeonGenTwoOpEnvFn * const fns[2][2][3] = {
6305             {
6306                 { gen_helper_neon_qshl_s8,
6307                   gen_helper_neon_qshl_s16,
6308                   gen_helper_neon_qshl_s32 },
6309                 { gen_helper_neon_qshlu_s8,
6310                   gen_helper_neon_qshlu_s16,
6311                   gen_helper_neon_qshlu_s32 }
6312             }, {
6313                 { NULL, NULL, NULL },
6314                 { gen_helper_neon_qshl_u8,
6315                   gen_helper_neon_qshl_u16,
6316                   gen_helper_neon_qshl_u32 }
6317             }
6318         };
6319         NeonGenTwoOpEnvFn *genfn = fns[src_unsigned][dst_unsigned][size];
6320         TCGMemOp memop = scalar ? size : MO_32;
6321         int maxpass = scalar ? 1 : is_q ? 4 : 2;
6322
6323         for (pass = 0; pass < maxpass; pass++) {
6324             TCGv_i32 tcg_op = tcg_temp_new_i32();
6325
6326             read_vec_element_i32(s, tcg_op, rn, pass, memop);
6327             genfn(tcg_op, cpu_env, tcg_op, tcg_shift);
6328             if (scalar) {
6329                 switch (size) {
6330                 case 0:
6331                     tcg_gen_ext8u_i32(tcg_op, tcg_op);
6332                     break;
6333                 case 1:
6334                     tcg_gen_ext16u_i32(tcg_op, tcg_op);
6335                     break;
6336                 case 2:
6337                     break;
6338                 default:
6339                     g_assert_not_reached();
6340                 }
6341                 write_fp_sreg(s, rd, tcg_op);
6342             } else {
6343                 write_vec_element_i32(s, tcg_op, rd, pass, MO_32);
6344             }
6345
6346             tcg_temp_free_i32(tcg_op);
6347         }
6348         tcg_temp_free_i32(tcg_shift);
6349
6350         if (!is_q && !scalar) {
6351             clear_vec_high(s, rd);
6352         }
6353     }
6354 }
6355
6356 /* Common vector code for handling integer to FP conversion */
6357 static void handle_simd_intfp_conv(DisasContext *s, int rd, int rn,
6358                                    int elements, int is_signed,
6359                                    int fracbits, int size)
6360 {
6361     bool is_double = size == 3 ? true : false;
6362     TCGv_ptr tcg_fpst = get_fpstatus_ptr();
6363     TCGv_i32 tcg_shift = tcg_const_i32(fracbits);
6364     TCGv_i64 tcg_int = tcg_temp_new_i64();
6365     TCGMemOp mop = size | (is_signed ? MO_SIGN : 0);
6366     int pass;
6367
6368     for (pass = 0; pass < elements; pass++) {
6369         read_vec_element(s, tcg_int, rn, pass, mop);
6370
6371         if (is_double) {
6372             TCGv_i64 tcg_double = tcg_temp_new_i64();
6373             if (is_signed) {
6374                 gen_helper_vfp_sqtod(tcg_double, tcg_int,
6375                                      tcg_shift, tcg_fpst);
6376             } else {
6377                 gen_helper_vfp_uqtod(tcg_double, tcg_int,
6378                                      tcg_shift, tcg_fpst);
6379             }
6380             if (elements == 1) {
6381                 write_fp_dreg(s, rd, tcg_double);
6382             } else {
6383                 write_vec_element(s, tcg_double, rd, pass, MO_64);
6384             }
6385             tcg_temp_free_i64(tcg_double);
6386         } else {
6387             TCGv_i32 tcg_single = tcg_temp_new_i32();
6388             if (is_signed) {
6389                 gen_helper_vfp_sqtos(tcg_single, tcg_int,
6390                                      tcg_shift, tcg_fpst);
6391             } else {
6392                 gen_helper_vfp_uqtos(tcg_single, tcg_int,
6393                                      tcg_shift, tcg_fpst);
6394             }
6395             if (elements == 1) {
6396                 write_fp_sreg(s, rd, tcg_single);
6397             } else {
6398                 write_vec_element_i32(s, tcg_single, rd, pass, MO_32);
6399             }
6400             tcg_temp_free_i32(tcg_single);
6401         }
6402     }
6403
6404     if (!is_double && elements == 2) {
6405         clear_vec_high(s, rd);
6406     }
6407
6408     tcg_temp_free_i64(tcg_int);
6409     tcg_temp_free_ptr(tcg_fpst);
6410     tcg_temp_free_i32(tcg_shift);
6411 }
6412
6413 /* UCVTF/SCVTF - Integer to FP conversion */
6414 static void handle_simd_shift_intfp_conv(DisasContext *s, bool is_scalar,
6415                                          bool is_q, bool is_u,
6416                                          int immh, int immb, int opcode,
6417                                          int rn, int rd)
6418 {
6419     bool is_double = extract32(immh, 3, 1);
6420     int size = is_double ? MO_64 : MO_32;
6421     int elements;
6422     int immhb = immh << 3 | immb;
6423     int fracbits = (is_double ? 128 : 64) - immhb;
6424
6425     if (!extract32(immh, 2, 2)) {
6426         unallocated_encoding(s);
6427         return;
6428     }
6429
6430     if (is_scalar) {
6431         elements = 1;
6432     } else {
6433         elements = is_double ? 2 : is_q ? 4 : 2;
6434         if (is_double && !is_q) {
6435             unallocated_encoding(s);
6436             return;
6437         }
6438     }
6439
6440     if (!fp_access_check(s)) {
6441         return;
6442     }
6443
6444     /* immh == 0 would be a failure of the decode logic */
6445     g_assert(immh);
6446
6447     handle_simd_intfp_conv(s, rd, rn, elements, !is_u, fracbits, size);
6448 }
6449
6450 /* FCVTZS, FVCVTZU - FP to fixedpoint conversion */
6451 static void handle_simd_shift_fpint_conv(DisasContext *s, bool is_scalar,
6452                                          bool is_q, bool is_u,
6453                                          int immh, int immb, int rn, int rd)
6454 {
6455     bool is_double = extract32(immh, 3, 1);
6456     int immhb = immh << 3 | immb;
6457     int fracbits = (is_double ? 128 : 64) - immhb;
6458     int pass;
6459     TCGv_ptr tcg_fpstatus;
6460     TCGv_i32 tcg_rmode, tcg_shift;
6461
6462     if (!extract32(immh, 2, 2)) {
6463         unallocated_encoding(s);
6464         return;
6465     }
6466
6467     if (!is_scalar && !is_q && is_double) {
6468         unallocated_encoding(s);
6469         return;
6470     }
6471
6472     if (!fp_access_check(s)) {
6473         return;
6474     }
6475
6476     assert(!(is_scalar && is_q));
6477
6478     tcg_rmode = tcg_const_i32(arm_rmode_to_sf(FPROUNDING_ZERO));
6479     gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
6480     tcg_fpstatus = get_fpstatus_ptr();
6481     tcg_shift = tcg_const_i32(fracbits);
6482
6483     if (is_double) {
6484         int maxpass = is_scalar ? 1 : is_q ? 2 : 1;
6485
6486         for (pass = 0; pass < maxpass; pass++) {
6487             TCGv_i64 tcg_op = tcg_temp_new_i64();
6488
6489             read_vec_element(s, tcg_op, rn, pass, MO_64);
6490             if (is_u) {
6491                 gen_helper_vfp_touqd(tcg_op, tcg_op, tcg_shift, tcg_fpstatus);
6492             } else {
6493                 gen_helper_vfp_tosqd(tcg_op, tcg_op, tcg_shift, tcg_fpstatus);
6494             }
6495             write_vec_element(s, tcg_op, rd, pass, MO_64);
6496             tcg_temp_free_i64(tcg_op);
6497         }
6498         if (!is_q) {
6499             clear_vec_high(s, rd);
6500         }
6501     } else {
6502         int maxpass = is_scalar ? 1 : is_q ? 4 : 2;
6503         for (pass = 0; pass < maxpass; pass++) {
6504             TCGv_i32 tcg_op = tcg_temp_new_i32();
6505
6506             read_vec_element_i32(s, tcg_op, rn, pass, MO_32);
6507             if (is_u) {
6508                 gen_helper_vfp_touls(tcg_op, tcg_op, tcg_shift, tcg_fpstatus);
6509             } else {
6510                 gen_helper_vfp_tosls(tcg_op, tcg_op, tcg_shift, tcg_fpstatus);
6511             }
6512             if (is_scalar) {
6513                 write_fp_sreg(s, rd, tcg_op);
6514             } else {
6515                 write_vec_element_i32(s, tcg_op, rd, pass, MO_32);
6516             }
6517             tcg_temp_free_i32(tcg_op);
6518         }
6519         if (!is_q && !is_scalar) {
6520             clear_vec_high(s, rd);
6521         }
6522     }
6523
6524     tcg_temp_free_ptr(tcg_fpstatus);
6525     tcg_temp_free_i32(tcg_shift);
6526     gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
6527     tcg_temp_free_i32(tcg_rmode);
6528 }
6529
6530 /* C3.6.9 AdvSIMD scalar shift by immediate
6531  *  31 30  29 28         23 22  19 18  16 15    11  10 9    5 4    0
6532  * +-----+---+-------------+------+------+--------+---+------+------+
6533  * | 0 1 | U | 1 1 1 1 1 0 | immh | immb | opcode | 1 |  Rn  |  Rd  |
6534  * +-----+---+-------------+------+------+--------+---+------+------+
6535  *
6536  * This is the scalar version so it works on a fixed sized registers
6537  */
6538 static void disas_simd_scalar_shift_imm(DisasContext *s, uint32_t insn)
6539 {
6540     int rd = extract32(insn, 0, 5);
6541     int rn = extract32(insn, 5, 5);
6542     int opcode = extract32(insn, 11, 5);
6543     int immb = extract32(insn, 16, 3);
6544     int immh = extract32(insn, 19, 4);
6545     bool is_u = extract32(insn, 29, 1);
6546
6547     if (immh == 0) {
6548         unallocated_encoding(s);
6549         return;
6550     }
6551
6552     switch (opcode) {
6553     case 0x08: /* SRI */
6554         if (!is_u) {
6555             unallocated_encoding(s);
6556             return;
6557         }
6558         /* fall through */
6559     case 0x00: /* SSHR / USHR */
6560     case 0x02: /* SSRA / USRA */
6561     case 0x04: /* SRSHR / URSHR */
6562     case 0x06: /* SRSRA / URSRA */
6563         handle_scalar_simd_shri(s, is_u, immh, immb, opcode, rn, rd);
6564         break;
6565     case 0x0a: /* SHL / SLI */
6566         handle_scalar_simd_shli(s, is_u, immh, immb, opcode, rn, rd);
6567         break;
6568     case 0x1c: /* SCVTF, UCVTF */
6569         handle_simd_shift_intfp_conv(s, true, false, is_u, immh, immb,
6570                                      opcode, rn, rd);
6571         break;
6572     case 0x10: /* SQSHRUN, SQSHRUN2 */
6573     case 0x11: /* SQRSHRUN, SQRSHRUN2 */
6574         if (!is_u) {
6575             unallocated_encoding(s);
6576             return;
6577         }
6578         handle_vec_simd_sqshrn(s, true, false, false, true,
6579                                immh, immb, opcode, rn, rd);
6580         break;
6581     case 0x12: /* SQSHRN, SQSHRN2, UQSHRN */
6582     case 0x13: /* SQRSHRN, SQRSHRN2, UQRSHRN, UQRSHRN2 */
6583         handle_vec_simd_sqshrn(s, true, false, is_u, is_u,
6584                                immh, immb, opcode, rn, rd);
6585         break;
6586     case 0xc: /* SQSHLU */
6587         if (!is_u) {
6588             unallocated_encoding(s);
6589             return;
6590         }
6591         handle_simd_qshl(s, true, false, false, true, immh, immb, rn, rd);
6592         break;
6593     case 0xe: /* SQSHL, UQSHL */
6594         handle_simd_qshl(s, true, false, is_u, is_u, immh, immb, rn, rd);
6595         break;
6596     case 0x1f: /* FCVTZS, FCVTZU */
6597         handle_simd_shift_fpint_conv(s, true, false, is_u, immh, immb, rn, rd);
6598         break;
6599     default:
6600         unallocated_encoding(s);
6601         break;
6602     }
6603 }
6604
6605 /* C3.6.10 AdvSIMD scalar three different
6606  *  31 30  29 28       24 23  22  21 20  16 15    12 11 10 9    5 4    0
6607  * +-----+---+-----------+------+---+------+--------+-----+------+------+
6608  * | 0 1 | U | 1 1 1 1 0 | size | 1 |  Rm  | opcode | 0 0 |  Rn  |  Rd  |
6609  * +-----+---+-----------+------+---+------+--------+-----+------+------+
6610  */
6611 static void disas_simd_scalar_three_reg_diff(DisasContext *s, uint32_t insn)
6612 {
6613     bool is_u = extract32(insn, 29, 1);
6614     int size = extract32(insn, 22, 2);
6615     int opcode = extract32(insn, 12, 4);
6616     int rm = extract32(insn, 16, 5);
6617     int rn = extract32(insn, 5, 5);
6618     int rd = extract32(insn, 0, 5);
6619
6620     if (is_u) {
6621         unallocated_encoding(s);
6622         return;
6623     }
6624
6625     switch (opcode) {
6626     case 0x9: /* SQDMLAL, SQDMLAL2 */
6627     case 0xb: /* SQDMLSL, SQDMLSL2 */
6628     case 0xd: /* SQDMULL, SQDMULL2 */
6629         if (size == 0 || size == 3) {
6630             unallocated_encoding(s);
6631             return;
6632         }
6633         break;
6634     default:
6635         unallocated_encoding(s);
6636         return;
6637     }
6638
6639     if (!fp_access_check(s)) {
6640         return;
6641     }
6642
6643     if (size == 2) {
6644         TCGv_i64 tcg_op1 = tcg_temp_new_i64();
6645         TCGv_i64 tcg_op2 = tcg_temp_new_i64();
6646         TCGv_i64 tcg_res = tcg_temp_new_i64();
6647
6648         read_vec_element(s, tcg_op1, rn, 0, MO_32 | MO_SIGN);
6649         read_vec_element(s, tcg_op2, rm, 0, MO_32 | MO_SIGN);
6650
6651         tcg_gen_mul_i64(tcg_res, tcg_op1, tcg_op2);
6652         gen_helper_neon_addl_saturate_s64(tcg_res, cpu_env, tcg_res, tcg_res);
6653
6654         switch (opcode) {
6655         case 0xd: /* SQDMULL, SQDMULL2 */
6656             break;
6657         case 0xb: /* SQDMLSL, SQDMLSL2 */
6658             tcg_gen_neg_i64(tcg_res, tcg_res);
6659             /* fall through */
6660         case 0x9: /* SQDMLAL, SQDMLAL2 */
6661             read_vec_element(s, tcg_op1, rd, 0, MO_64);
6662             gen_helper_neon_addl_saturate_s64(tcg_res, cpu_env,
6663                                               tcg_res, tcg_op1);
6664             break;
6665         default:
6666             g_assert_not_reached();
6667         }
6668
6669         write_fp_dreg(s, rd, tcg_res);
6670
6671         tcg_temp_free_i64(tcg_op1);
6672         tcg_temp_free_i64(tcg_op2);
6673         tcg_temp_free_i64(tcg_res);
6674     } else {
6675         TCGv_i32 tcg_op1 = tcg_temp_new_i32();
6676         TCGv_i32 tcg_op2 = tcg_temp_new_i32();
6677         TCGv_i64 tcg_res = tcg_temp_new_i64();
6678
6679         read_vec_element_i32(s, tcg_op1, rn, 0, MO_16);
6680         read_vec_element_i32(s, tcg_op2, rm, 0, MO_16);
6681
6682         gen_helper_neon_mull_s16(tcg_res, tcg_op1, tcg_op2);
6683         gen_helper_neon_addl_saturate_s32(tcg_res, cpu_env, tcg_res, tcg_res);
6684
6685         switch (opcode) {
6686         case 0xd: /* SQDMULL, SQDMULL2 */
6687             break;
6688         case 0xb: /* SQDMLSL, SQDMLSL2 */
6689             gen_helper_neon_negl_u32(tcg_res, tcg_res);
6690             /* fall through */
6691         case 0x9: /* SQDMLAL, SQDMLAL2 */
6692         {
6693             TCGv_i64 tcg_op3 = tcg_temp_new_i64();
6694             read_vec_element(s, tcg_op3, rd, 0, MO_32);
6695             gen_helper_neon_addl_saturate_s32(tcg_res, cpu_env,
6696                                               tcg_res, tcg_op3);
6697             tcg_temp_free_i64(tcg_op3);
6698             break;
6699         }
6700         default:
6701             g_assert_not_reached();
6702         }
6703
6704         tcg_gen_ext32u_i64(tcg_res, tcg_res);
6705         write_fp_dreg(s, rd, tcg_res);
6706
6707         tcg_temp_free_i32(tcg_op1);
6708         tcg_temp_free_i32(tcg_op2);
6709         tcg_temp_free_i64(tcg_res);
6710     }
6711 }
6712
6713 static void handle_3same_64(DisasContext *s, int opcode, bool u,
6714                             TCGv_i64 tcg_rd, TCGv_i64 tcg_rn, TCGv_i64 tcg_rm)
6715 {
6716     /* Handle 64x64->64 opcodes which are shared between the scalar
6717      * and vector 3-same groups. We cover every opcode where size == 3
6718      * is valid in either the three-reg-same (integer, not pairwise)
6719      * or scalar-three-reg-same groups. (Some opcodes are not yet
6720      * implemented.)
6721      */
6722     TCGCond cond;
6723
6724     switch (opcode) {
6725     case 0x1: /* SQADD */
6726         if (u) {
6727             gen_helper_neon_qadd_u64(tcg_rd, cpu_env, tcg_rn, tcg_rm);
6728         } else {
6729             gen_helper_neon_qadd_s64(tcg_rd, cpu_env, tcg_rn, tcg_rm);
6730         }
6731         break;
6732     case 0x5: /* SQSUB */
6733         if (u) {
6734             gen_helper_neon_qsub_u64(tcg_rd, cpu_env, tcg_rn, tcg_rm);
6735         } else {
6736             gen_helper_neon_qsub_s64(tcg_rd, cpu_env, tcg_rn, tcg_rm);
6737         }
6738         break;
6739     case 0x6: /* CMGT, CMHI */
6740         /* 64 bit integer comparison, result = test ? (2^64 - 1) : 0.
6741          * We implement this using setcond (test) and then negating.
6742          */
6743         cond = u ? TCG_COND_GTU : TCG_COND_GT;
6744     do_cmop:
6745         tcg_gen_setcond_i64(cond, tcg_rd, tcg_rn, tcg_rm);
6746         tcg_gen_neg_i64(tcg_rd, tcg_rd);
6747         break;
6748     case 0x7: /* CMGE, CMHS */
6749         cond = u ? TCG_COND_GEU : TCG_COND_GE;
6750         goto do_cmop;
6751     case 0x11: /* CMTST, CMEQ */
6752         if (u) {
6753             cond = TCG_COND_EQ;
6754             goto do_cmop;
6755         }
6756         /* CMTST : test is "if (X & Y != 0)". */
6757         tcg_gen_and_i64(tcg_rd, tcg_rn, tcg_rm);
6758         tcg_gen_setcondi_i64(TCG_COND_NE, tcg_rd, tcg_rd, 0);
6759         tcg_gen_neg_i64(tcg_rd, tcg_rd);
6760         break;
6761     case 0x8: /* SSHL, USHL */
6762         if (u) {
6763             gen_helper_neon_shl_u64(tcg_rd, tcg_rn, tcg_rm);
6764         } else {
6765             gen_helper_neon_shl_s64(tcg_rd, tcg_rn, tcg_rm);
6766         }
6767         break;
6768     case 0x9: /* SQSHL, UQSHL */
6769         if (u) {
6770             gen_helper_neon_qshl_u64(tcg_rd, cpu_env, tcg_rn, tcg_rm);
6771         } else {
6772             gen_helper_neon_qshl_s64(tcg_rd, cpu_env, tcg_rn, tcg_rm);
6773         }
6774         break;
6775     case 0xa: /* SRSHL, URSHL */
6776         if (u) {
6777             gen_helper_neon_rshl_u64(tcg_rd, tcg_rn, tcg_rm);
6778         } else {
6779             gen_helper_neon_rshl_s64(tcg_rd, tcg_rn, tcg_rm);
6780         }
6781         break;
6782     case 0xb: /* SQRSHL, UQRSHL */
6783         if (u) {
6784             gen_helper_neon_qrshl_u64(tcg_rd, cpu_env, tcg_rn, tcg_rm);
6785         } else {
6786             gen_helper_neon_qrshl_s64(tcg_rd, cpu_env, tcg_rn, tcg_rm);
6787         }
6788         break;
6789     case 0x10: /* ADD, SUB */
6790         if (u) {
6791             tcg_gen_sub_i64(tcg_rd, tcg_rn, tcg_rm);
6792         } else {
6793             tcg_gen_add_i64(tcg_rd, tcg_rn, tcg_rm);
6794         }
6795         break;
6796     default:
6797         g_assert_not_reached();
6798     }
6799 }
6800
6801 /* Handle the 3-same-operands float operations; shared by the scalar
6802  * and vector encodings. The caller must filter out any encodings
6803  * not allocated for the encoding it is dealing with.
6804  */
6805 static void handle_3same_float(DisasContext *s, int size, int elements,
6806                                int fpopcode, int rd, int rn, int rm)
6807 {
6808     int pass;
6809     TCGv_ptr fpst = get_fpstatus_ptr();
6810
6811     for (pass = 0; pass < elements; pass++) {
6812         if (size) {
6813             /* Double */
6814             TCGv_i64 tcg_op1 = tcg_temp_new_i64();
6815             TCGv_i64 tcg_op2 = tcg_temp_new_i64();
6816             TCGv_i64 tcg_res = tcg_temp_new_i64();
6817
6818             read_vec_element(s, tcg_op1, rn, pass, MO_64);
6819             read_vec_element(s, tcg_op2, rm, pass, MO_64);
6820
6821             switch (fpopcode) {
6822             case 0x39: /* FMLS */
6823                 /* As usual for ARM, separate negation for fused multiply-add */
6824                 gen_helper_vfp_negd(tcg_op1, tcg_op1);
6825                 /* fall through */
6826             case 0x19: /* FMLA */
6827                 read_vec_element(s, tcg_res, rd, pass, MO_64);
6828                 gen_helper_vfp_muladdd(tcg_res, tcg_op1, tcg_op2,
6829                                        tcg_res, fpst);
6830                 break;
6831             case 0x18: /* FMAXNM */
6832                 gen_helper_vfp_maxnumd(tcg_res, tcg_op1, tcg_op2, fpst);
6833                 break;
6834             case 0x1a: /* FADD */
6835                 gen_helper_vfp_addd(tcg_res, tcg_op1, tcg_op2, fpst);
6836                 break;
6837             case 0x1b: /* FMULX */
6838                 gen_helper_vfp_mulxd(tcg_res, tcg_op1, tcg_op2, fpst);
6839                 break;
6840             case 0x1c: /* FCMEQ */
6841                 gen_helper_neon_ceq_f64(tcg_res, tcg_op1, tcg_op2, fpst);
6842                 break;
6843             case 0x1e: /* FMAX */
6844                 gen_helper_vfp_maxd(tcg_res, tcg_op1, tcg_op2, fpst);
6845                 break;
6846             case 0x1f: /* FRECPS */
6847                 gen_helper_recpsf_f64(tcg_res, tcg_op1, tcg_op2, fpst);
6848                 break;
6849             case 0x38: /* FMINNM */
6850                 gen_helper_vfp_minnumd(tcg_res, tcg_op1, tcg_op2, fpst);
6851                 break;
6852             case 0x3a: /* FSUB */
6853                 gen_helper_vfp_subd(tcg_res, tcg_op1, tcg_op2, fpst);
6854                 break;
6855             case 0x3e: /* FMIN */
6856                 gen_helper_vfp_mind(tcg_res, tcg_op1, tcg_op2, fpst);
6857                 break;
6858             case 0x3f: /* FRSQRTS */
6859                 gen_helper_rsqrtsf_f64(tcg_res, tcg_op1, tcg_op2, fpst);
6860                 break;
6861             case 0x5b: /* FMUL */
6862                 gen_helper_vfp_muld(tcg_res, tcg_op1, tcg_op2, fpst);
6863                 break;
6864             case 0x5c: /* FCMGE */
6865                 gen_helper_neon_cge_f64(tcg_res, tcg_op1, tcg_op2, fpst);
6866                 break;
6867             case 0x5d: /* FACGE */
6868                 gen_helper_neon_acge_f64(tcg_res, tcg_op1, tcg_op2, fpst);
6869                 break;
6870             case 0x5f: /* FDIV */
6871                 gen_helper_vfp_divd(tcg_res, tcg_op1, tcg_op2, fpst);
6872                 break;
6873             case 0x7a: /* FABD */
6874                 gen_helper_vfp_subd(tcg_res, tcg_op1, tcg_op2, fpst);
6875                 gen_helper_vfp_absd(tcg_res, tcg_res);
6876                 break;
6877             case 0x7c: /* FCMGT */
6878                 gen_helper_neon_cgt_f64(tcg_res, tcg_op1, tcg_op2, fpst);
6879                 break;
6880             case 0x7d: /* FACGT */
6881                 gen_helper_neon_acgt_f64(tcg_res, tcg_op1, tcg_op2, fpst);
6882                 break;
6883             default:
6884                 g_assert_not_reached();
6885             }
6886
6887             write_vec_element(s, tcg_res, rd, pass, MO_64);
6888
6889             tcg_temp_free_i64(tcg_res);
6890             tcg_temp_free_i64(tcg_op1);
6891             tcg_temp_free_i64(tcg_op2);
6892         } else {
6893             /* Single */
6894             TCGv_i32 tcg_op1 = tcg_temp_new_i32();
6895             TCGv_i32 tcg_op2 = tcg_temp_new_i32();
6896             TCGv_i32 tcg_res = tcg_temp_new_i32();
6897
6898             read_vec_element_i32(s, tcg_op1, rn, pass, MO_32);
6899             read_vec_element_i32(s, tcg_op2, rm, pass, MO_32);
6900
6901             switch (fpopcode) {
6902             case 0x39: /* FMLS */
6903                 /* As usual for ARM, separate negation for fused multiply-add */
6904                 gen_helper_vfp_negs(tcg_op1, tcg_op1);
6905                 /* fall through */
6906             case 0x19: /* FMLA */
6907                 read_vec_element_i32(s, tcg_res, rd, pass, MO_32);
6908                 gen_helper_vfp_muladds(tcg_res, tcg_op1, tcg_op2,
6909                                        tcg_res, fpst);
6910                 break;
6911             case 0x1a: /* FADD */
6912                 gen_helper_vfp_adds(tcg_res, tcg_op1, tcg_op2, fpst);
6913                 break;
6914             case 0x1b: /* FMULX */
6915                 gen_helper_vfp_mulxs(tcg_res, tcg_op1, tcg_op2, fpst);
6916                 break;
6917             case 0x1c: /* FCMEQ */
6918                 gen_helper_neon_ceq_f32(tcg_res, tcg_op1, tcg_op2, fpst);
6919                 break;
6920             case 0x1e: /* FMAX */
6921                 gen_helper_vfp_maxs(tcg_res, tcg_op1, tcg_op2, fpst);
6922                 break;
6923             case 0x1f: /* FRECPS */
6924                 gen_helper_recpsf_f32(tcg_res, tcg_op1, tcg_op2, fpst);
6925                 break;
6926             case 0x18: /* FMAXNM */
6927                 gen_helper_vfp_maxnums(tcg_res, tcg_op1, tcg_op2, fpst);
6928                 break;
6929             case 0x38: /* FMINNM */
6930                 gen_helper_vfp_minnums(tcg_res, tcg_op1, tcg_op2, fpst);
6931                 break;
6932             case 0x3a: /* FSUB */
6933                 gen_helper_vfp_subs(tcg_res, tcg_op1, tcg_op2, fpst);
6934                 break;
6935             case 0x3e: /* FMIN */
6936                 gen_helper_vfp_mins(tcg_res, tcg_op1, tcg_op2, fpst);
6937                 break;
6938             case 0x3f: /* FRSQRTS */
6939                 gen_helper_rsqrtsf_f32(tcg_res, tcg_op1, tcg_op2, fpst);
6940                 break;
6941             case 0x5b: /* FMUL */
6942                 gen_helper_vfp_muls(tcg_res, tcg_op1, tcg_op2, fpst);
6943                 break;
6944             case 0x5c: /* FCMGE */
6945                 gen_helper_neon_cge_f32(tcg_res, tcg_op1, tcg_op2, fpst);
6946                 break;
6947             case 0x5d: /* FACGE */
6948                 gen_helper_neon_acge_f32(tcg_res, tcg_op1, tcg_op2, fpst);
6949                 break;
6950             case 0x5f: /* FDIV */
6951                 gen_helper_vfp_divs(tcg_res, tcg_op1, tcg_op2, fpst);
6952                 break;
6953             case 0x7a: /* FABD */
6954                 gen_helper_vfp_subs(tcg_res, tcg_op1, tcg_op2, fpst);
6955                 gen_helper_vfp_abss(tcg_res, tcg_res);
6956                 break;
6957             case 0x7c: /* FCMGT */
6958                 gen_helper_neon_cgt_f32(tcg_res, tcg_op1, tcg_op2, fpst);
6959                 break;
6960             case 0x7d: /* FACGT */
6961                 gen_helper_neon_acgt_f32(tcg_res, tcg_op1, tcg_op2, fpst);
6962                 break;
6963             default:
6964                 g_assert_not_reached();
6965             }
6966
6967             if (elements == 1) {
6968                 /* scalar single so clear high part */
6969                 TCGv_i64 tcg_tmp = tcg_temp_new_i64();
6970
6971                 tcg_gen_extu_i32_i64(tcg_tmp, tcg_res);
6972                 write_vec_element(s, tcg_tmp, rd, pass, MO_64);
6973                 tcg_temp_free_i64(tcg_tmp);
6974             } else {
6975                 write_vec_element_i32(s, tcg_res, rd, pass, MO_32);
6976             }
6977
6978             tcg_temp_free_i32(tcg_res);
6979             tcg_temp_free_i32(tcg_op1);
6980             tcg_temp_free_i32(tcg_op2);
6981         }
6982     }
6983
6984     tcg_temp_free_ptr(fpst);
6985
6986     if ((elements << size) < 4) {
6987         /* scalar, or non-quad vector op */
6988         clear_vec_high(s, rd);
6989     }
6990 }
6991
6992 /* C3.6.11 AdvSIMD scalar three same
6993  *  31 30  29 28       24 23  22  21 20  16 15    11  10 9    5 4    0
6994  * +-----+---+-----------+------+---+------+--------+---+------+------+
6995  * | 0 1 | U | 1 1 1 1 0 | size | 1 |  Rm  | opcode | 1 |  Rn  |  Rd  |
6996  * +-----+---+-----------+------+---+------+--------+---+------+------+
6997  */
6998 static void disas_simd_scalar_three_reg_same(DisasContext *s, uint32_t insn)
6999 {
7000     int rd = extract32(insn, 0, 5);
7001     int rn = extract32(insn, 5, 5);
7002     int opcode = extract32(insn, 11, 5);
7003     int rm = extract32(insn, 16, 5);
7004     int size = extract32(insn, 22, 2);
7005     bool u = extract32(insn, 29, 1);
7006     TCGv_i64 tcg_rd;
7007
7008     if (opcode >= 0x18) {
7009         /* Floating point: U, size[1] and opcode indicate operation */
7010         int fpopcode = opcode | (extract32(size, 1, 1) << 5) | (u << 6);
7011         switch (fpopcode) {
7012         case 0x1b: /* FMULX */
7013         case 0x1f: /* FRECPS */
7014         case 0x3f: /* FRSQRTS */
7015         case 0x5d: /* FACGE */
7016         case 0x7d: /* FACGT */
7017         case 0x1c: /* FCMEQ */
7018         case 0x5c: /* FCMGE */
7019         case 0x7c: /* FCMGT */
7020         case 0x7a: /* FABD */
7021             break;
7022         default:
7023             unallocated_encoding(s);
7024             return;
7025         }
7026
7027         if (!fp_access_check(s)) {
7028             return;
7029         }
7030
7031         handle_3same_float(s, extract32(size, 0, 1), 1, fpopcode, rd, rn, rm);
7032         return;
7033     }
7034
7035     switch (opcode) {
7036     case 0x1: /* SQADD, UQADD */
7037     case 0x5: /* SQSUB, UQSUB */
7038     case 0x9: /* SQSHL, UQSHL */
7039     case 0xb: /* SQRSHL, UQRSHL */
7040         break;
7041     case 0x8: /* SSHL, USHL */
7042     case 0xa: /* SRSHL, URSHL */
7043     case 0x6: /* CMGT, CMHI */
7044     case 0x7: /* CMGE, CMHS */
7045     case 0x11: /* CMTST, CMEQ */
7046     case 0x10: /* ADD, SUB (vector) */
7047         if (size != 3) {
7048             unallocated_encoding(s);
7049             return;
7050         }
7051         break;
7052     case 0x16: /* SQDMULH, SQRDMULH (vector) */
7053         if (size != 1 && size != 2) {
7054             unallocated_encoding(s);
7055             return;
7056         }
7057         break;
7058     default:
7059         unallocated_encoding(s);
7060         return;
7061     }
7062
7063     if (!fp_access_check(s)) {
7064         return;
7065     }
7066
7067     tcg_rd = tcg_temp_new_i64();
7068
7069     if (size == 3) {
7070         TCGv_i64 tcg_rn = read_fp_dreg(s, rn);
7071         TCGv_i64 tcg_rm = read_fp_dreg(s, rm);
7072
7073         handle_3same_64(s, opcode, u, tcg_rd, tcg_rn, tcg_rm);
7074         tcg_temp_free_i64(tcg_rn);
7075         tcg_temp_free_i64(tcg_rm);
7076     } else {
7077         /* Do a single operation on the lowest element in the vector.
7078          * We use the standard Neon helpers and rely on 0 OP 0 == 0 with
7079          * no side effects for all these operations.
7080          * OPTME: special-purpose helpers would avoid doing some
7081          * unnecessary work in the helper for the 8 and 16 bit cases.
7082          */
7083         NeonGenTwoOpEnvFn *genenvfn;
7084         TCGv_i32 tcg_rn = tcg_temp_new_i32();
7085         TCGv_i32 tcg_rm = tcg_temp_new_i32();
7086         TCGv_i32 tcg_rd32 = tcg_temp_new_i32();
7087
7088         read_vec_element_i32(s, tcg_rn, rn, 0, size);
7089         read_vec_element_i32(s, tcg_rm, rm, 0, size);
7090
7091         switch (opcode) {
7092         case 0x1: /* SQADD, UQADD */
7093         {
7094             static NeonGenTwoOpEnvFn * const fns[3][2] = {
7095                 { gen_helper_neon_qadd_s8, gen_helper_neon_qadd_u8 },
7096                 { gen_helper_neon_qadd_s16, gen_helper_neon_qadd_u16 },
7097                 { gen_helper_neon_qadd_s32, gen_helper_neon_qadd_u32 },
7098             };
7099             genenvfn = fns[size][u];
7100             break;
7101         }
7102         case 0x5: /* SQSUB, UQSUB */
7103         {
7104             static NeonGenTwoOpEnvFn * const fns[3][2] = {
7105                 { gen_helper_neon_qsub_s8, gen_helper_neon_qsub_u8 },
7106                 { gen_helper_neon_qsub_s16, gen_helper_neon_qsub_u16 },
7107                 { gen_helper_neon_qsub_s32, gen_helper_neon_qsub_u32 },
7108             };
7109             genenvfn = fns[size][u];
7110             break;
7111         }
7112         case 0x9: /* SQSHL, UQSHL */
7113         {
7114             static NeonGenTwoOpEnvFn * const fns[3][2] = {
7115                 { gen_helper_neon_qshl_s8, gen_helper_neon_qshl_u8 },
7116                 { gen_helper_neon_qshl_s16, gen_helper_neon_qshl_u16 },
7117                 { gen_helper_neon_qshl_s32, gen_helper_neon_qshl_u32 },
7118             };
7119             genenvfn = fns[size][u];
7120             break;
7121         }
7122         case 0xb: /* SQRSHL, UQRSHL */
7123         {
7124             static NeonGenTwoOpEnvFn * const fns[3][2] = {
7125                 { gen_helper_neon_qrshl_s8, gen_helper_neon_qrshl_u8 },
7126                 { gen_helper_neon_qrshl_s16, gen_helper_neon_qrshl_u16 },
7127                 { gen_helper_neon_qrshl_s32, gen_helper_neon_qrshl_u32 },
7128             };
7129             genenvfn = fns[size][u];
7130             break;
7131         }
7132         case 0x16: /* SQDMULH, SQRDMULH */
7133         {
7134             static NeonGenTwoOpEnvFn * const fns[2][2] = {
7135                 { gen_helper_neon_qdmulh_s16, gen_helper_neon_qrdmulh_s16 },
7136                 { gen_helper_neon_qdmulh_s32, gen_helper_neon_qrdmulh_s32 },
7137             };
7138             assert(size == 1 || size == 2);
7139             genenvfn = fns[size - 1][u];
7140             break;
7141         }
7142         default:
7143             g_assert_not_reached();
7144         }
7145
7146         genenvfn(tcg_rd32, cpu_env, tcg_rn, tcg_rm);
7147         tcg_gen_extu_i32_i64(tcg_rd, tcg_rd32);
7148         tcg_temp_free_i32(tcg_rd32);
7149         tcg_temp_free_i32(tcg_rn);
7150         tcg_temp_free_i32(tcg_rm);
7151     }
7152
7153     write_fp_dreg(s, rd, tcg_rd);
7154
7155     tcg_temp_free_i64(tcg_rd);
7156 }
7157
7158 static void handle_2misc_64(DisasContext *s, int opcode, bool u,
7159                             TCGv_i64 tcg_rd, TCGv_i64 tcg_rn,
7160                             TCGv_i32 tcg_rmode, TCGv_ptr tcg_fpstatus)
7161 {
7162     /* Handle 64->64 opcodes which are shared between the scalar and
7163      * vector 2-reg-misc groups. We cover every integer opcode where size == 3
7164      * is valid in either group and also the double-precision fp ops.
7165      * The caller only need provide tcg_rmode and tcg_fpstatus if the op
7166      * requires them.
7167      */
7168     TCGCond cond;
7169
7170     switch (opcode) {
7171     case 0x4: /* CLS, CLZ */
7172         if (u) {
7173             gen_helper_clz64(tcg_rd, tcg_rn);
7174         } else {
7175             gen_helper_cls64(tcg_rd, tcg_rn);
7176         }
7177         break;
7178     case 0x5: /* NOT */
7179         /* This opcode is shared with CNT and RBIT but we have earlier
7180          * enforced that size == 3 if and only if this is the NOT insn.
7181          */
7182         tcg_gen_not_i64(tcg_rd, tcg_rn);
7183         break;
7184     case 0x7: /* SQABS, SQNEG */
7185         if (u) {
7186             gen_helper_neon_qneg_s64(tcg_rd, cpu_env, tcg_rn);
7187         } else {
7188             gen_helper_neon_qabs_s64(tcg_rd, cpu_env, tcg_rn);
7189         }
7190         break;
7191     case 0xa: /* CMLT */
7192         /* 64 bit integer comparison against zero, result is
7193          * test ? (2^64 - 1) : 0. We implement via setcond(!test) and
7194          * subtracting 1.
7195          */
7196         cond = TCG_COND_LT;
7197     do_cmop:
7198         tcg_gen_setcondi_i64(cond, tcg_rd, tcg_rn, 0);
7199         tcg_gen_neg_i64(tcg_rd, tcg_rd);
7200         break;
7201     case 0x8: /* CMGT, CMGE */
7202         cond = u ? TCG_COND_GE : TCG_COND_GT;
7203         goto do_cmop;
7204     case 0x9: /* CMEQ, CMLE */
7205         cond = u ? TCG_COND_LE : TCG_COND_EQ;
7206         goto do_cmop;
7207     case 0xb: /* ABS, NEG */
7208         if (u) {
7209             tcg_gen_neg_i64(tcg_rd, tcg_rn);
7210         } else {
7211             TCGv_i64 tcg_zero = tcg_const_i64(0);
7212             tcg_gen_neg_i64(tcg_rd, tcg_rn);
7213             tcg_gen_movcond_i64(TCG_COND_GT, tcg_rd, tcg_rn, tcg_zero,
7214                                 tcg_rn, tcg_rd);
7215             tcg_temp_free_i64(tcg_zero);
7216         }
7217         break;
7218     case 0x2f: /* FABS */
7219         gen_helper_vfp_absd(tcg_rd, tcg_rn);
7220         break;
7221     case 0x6f: /* FNEG */
7222         gen_helper_vfp_negd(tcg_rd, tcg_rn);
7223         break;
7224     case 0x7f: /* FSQRT */
7225         gen_helper_vfp_sqrtd(tcg_rd, tcg_rn, cpu_env);
7226         break;
7227     case 0x1a: /* FCVTNS */
7228     case 0x1b: /* FCVTMS */
7229     case 0x1c: /* FCVTAS */
7230     case 0x3a: /* FCVTPS */
7231     case 0x3b: /* FCVTZS */
7232     {
7233         TCGv_i32 tcg_shift = tcg_const_i32(0);
7234         gen_helper_vfp_tosqd(tcg_rd, tcg_rn, tcg_shift, tcg_fpstatus);
7235         tcg_temp_free_i32(tcg_shift);
7236         break;
7237     }
7238     case 0x5a: /* FCVTNU */
7239     case 0x5b: /* FCVTMU */
7240     case 0x5c: /* FCVTAU */
7241     case 0x7a: /* FCVTPU */
7242     case 0x7b: /* FCVTZU */
7243     {
7244         TCGv_i32 tcg_shift = tcg_const_i32(0);
7245         gen_helper_vfp_touqd(tcg_rd, tcg_rn, tcg_shift, tcg_fpstatus);
7246         tcg_temp_free_i32(tcg_shift);
7247         break;
7248     }
7249     case 0x18: /* FRINTN */
7250     case 0x19: /* FRINTM */
7251     case 0x38: /* FRINTP */
7252     case 0x39: /* FRINTZ */
7253     case 0x58: /* FRINTA */
7254     case 0x79: /* FRINTI */
7255         gen_helper_rintd(tcg_rd, tcg_rn, tcg_fpstatus);
7256         break;
7257     case 0x59: /* FRINTX */
7258         gen_helper_rintd_exact(tcg_rd, tcg_rn, tcg_fpstatus);
7259         break;
7260     default:
7261         g_assert_not_reached();
7262     }
7263 }
7264
7265 static void handle_2misc_fcmp_zero(DisasContext *s, int opcode,
7266                                    bool is_scalar, bool is_u, bool is_q,
7267                                    int size, int rn, int rd)
7268 {
7269     bool is_double = (size == 3);
7270     TCGv_ptr fpst;
7271
7272     if (!fp_access_check(s)) {
7273         return;
7274     }
7275
7276     fpst = get_fpstatus_ptr();
7277
7278     if (is_double) {
7279         TCGv_i64 tcg_op = tcg_temp_new_i64();
7280         TCGv_i64 tcg_zero = tcg_const_i64(0);
7281         TCGv_i64 tcg_res = tcg_temp_new_i64();
7282         NeonGenTwoDoubleOPFn *genfn;
7283         bool swap = false;
7284         int pass;
7285
7286         switch (opcode) {
7287         case 0x2e: /* FCMLT (zero) */
7288             swap = true;
7289             /* fallthrough */
7290         case 0x2c: /* FCMGT (zero) */
7291             genfn = gen_helper_neon_cgt_f64;
7292             break;
7293         case 0x2d: /* FCMEQ (zero) */
7294             genfn = gen_helper_neon_ceq_f64;
7295             break;
7296         case 0x6d: /* FCMLE (zero) */
7297             swap = true;
7298             /* fall through */
7299         case 0x6c: /* FCMGE (zero) */
7300             genfn = gen_helper_neon_cge_f64;
7301             break;
7302         default:
7303             g_assert_not_reached();
7304         }
7305
7306         for (pass = 0; pass < (is_scalar ? 1 : 2); pass++) {
7307             read_vec_element(s, tcg_op, rn, pass, MO_64);
7308             if (swap) {
7309                 genfn(tcg_res, tcg_zero, tcg_op, fpst);
7310             } else {
7311                 genfn(tcg_res, tcg_op, tcg_zero, fpst);
7312             }
7313             write_vec_element(s, tcg_res, rd, pass, MO_64);
7314         }
7315         if (is_scalar) {
7316             clear_vec_high(s, rd);
7317         }
7318
7319         tcg_temp_free_i64(tcg_res);
7320         tcg_temp_free_i64(tcg_zero);
7321         tcg_temp_free_i64(tcg_op);
7322     } else {
7323         TCGv_i32 tcg_op = tcg_temp_new_i32();
7324         TCGv_i32 tcg_zero = tcg_const_i32(0);
7325         TCGv_i32 tcg_res = tcg_temp_new_i32();
7326         NeonGenTwoSingleOPFn *genfn;
7327         bool swap = false;
7328         int pass, maxpasses;
7329
7330         switch (opcode) {
7331         case 0x2e: /* FCMLT (zero) */
7332             swap = true;
7333             /* fall through */
7334         case 0x2c: /* FCMGT (zero) */
7335             genfn = gen_helper_neon_cgt_f32;
7336             break;
7337         case 0x2d: /* FCMEQ (zero) */
7338             genfn = gen_helper_neon_ceq_f32;
7339             break;
7340         case 0x6d: /* FCMLE (zero) */
7341             swap = true;
7342             /* fall through */
7343         case 0x6c: /* FCMGE (zero) */
7344             genfn = gen_helper_neon_cge_f32;
7345             break;
7346         default:
7347             g_assert_not_reached();
7348         }
7349
7350         if (is_scalar) {
7351             maxpasses = 1;
7352         } else {
7353             maxpasses = is_q ? 4 : 2;
7354         }
7355
7356         for (pass = 0; pass < maxpasses; pass++) {
7357             read_vec_element_i32(s, tcg_op, rn, pass, MO_32);
7358             if (swap) {
7359                 genfn(tcg_res, tcg_zero, tcg_op, fpst);
7360             } else {
7361                 genfn(tcg_res, tcg_op, tcg_zero, fpst);
7362             }
7363             if (is_scalar) {
7364                 write_fp_sreg(s, rd, tcg_res);
7365             } else {
7366                 write_vec_element_i32(s, tcg_res, rd, pass, MO_32);
7367             }
7368         }
7369         tcg_temp_free_i32(tcg_res);
7370         tcg_temp_free_i32(tcg_zero);
7371         tcg_temp_free_i32(tcg_op);
7372         if (!is_q && !is_scalar) {
7373             clear_vec_high(s, rd);
7374         }
7375     }
7376
7377     tcg_temp_free_ptr(fpst);
7378 }
7379
7380 static void handle_2misc_reciprocal(DisasContext *s, int opcode,
7381                                     bool is_scalar, bool is_u, bool is_q,
7382                                     int size, int rn, int rd)
7383 {
7384     bool is_double = (size == 3);
7385     TCGv_ptr fpst = get_fpstatus_ptr();
7386
7387     if (is_double) {
7388         TCGv_i64 tcg_op = tcg_temp_new_i64();
7389         TCGv_i64 tcg_res = tcg_temp_new_i64();
7390         int pass;
7391
7392         for (pass = 0; pass < (is_scalar ? 1 : 2); pass++) {
7393             read_vec_element(s, tcg_op, rn, pass, MO_64);
7394             switch (opcode) {
7395             case 0x3d: /* FRECPE */
7396                 gen_helper_recpe_f64(tcg_res, tcg_op, fpst);
7397                 break;
7398             case 0x3f: /* FRECPX */
7399                 gen_helper_frecpx_f64(tcg_res, tcg_op, fpst);
7400                 break;
7401             case 0x7d: /* FRSQRTE */
7402                 gen_helper_rsqrte_f64(tcg_res, tcg_op, fpst);
7403                 break;
7404             default:
7405                 g_assert_not_reached();
7406             }
7407             write_vec_element(s, tcg_res, rd, pass, MO_64);
7408         }
7409         if (is_scalar) {
7410             clear_vec_high(s, rd);
7411         }
7412
7413         tcg_temp_free_i64(tcg_res);
7414         tcg_temp_free_i64(tcg_op);
7415     } else {
7416         TCGv_i32 tcg_op = tcg_temp_new_i32();
7417         TCGv_i32 tcg_res = tcg_temp_new_i32();
7418         int pass, maxpasses;
7419
7420         if (is_scalar) {
7421             maxpasses = 1;
7422         } else {
7423             maxpasses = is_q ? 4 : 2;
7424         }
7425
7426         for (pass = 0; pass < maxpasses; pass++) {
7427             read_vec_element_i32(s, tcg_op, rn, pass, MO_32);
7428
7429             switch (opcode) {
7430             case 0x3c: /* URECPE */
7431                 gen_helper_recpe_u32(tcg_res, tcg_op, fpst);
7432                 break;
7433             case 0x3d: /* FRECPE */
7434                 gen_helper_recpe_f32(tcg_res, tcg_op, fpst);
7435                 break;
7436             case 0x3f: /* FRECPX */
7437                 gen_helper_frecpx_f32(tcg_res, tcg_op, fpst);
7438                 break;
7439             case 0x7d: /* FRSQRTE */
7440                 gen_helper_rsqrte_f32(tcg_res, tcg_op, fpst);
7441                 break;
7442             default:
7443                 g_assert_not_reached();
7444             }
7445
7446             if (is_scalar) {
7447                 write_fp_sreg(s, rd, tcg_res);
7448             } else {
7449                 write_vec_element_i32(s, tcg_res, rd, pass, MO_32);
7450             }
7451         }
7452         tcg_temp_free_i32(tcg_res);
7453         tcg_temp_free_i32(tcg_op);
7454         if (!is_q && !is_scalar) {
7455             clear_vec_high(s, rd);
7456         }
7457     }
7458     tcg_temp_free_ptr(fpst);
7459 }
7460
7461 static void handle_2misc_narrow(DisasContext *s, bool scalar,
7462                                 int opcode, bool u, bool is_q,
7463                                 int size, int rn, int rd)
7464 {
7465     /* Handle 2-reg-misc ops which are narrowing (so each 2*size element
7466      * in the source becomes a size element in the destination).
7467      */
7468     int pass;
7469     TCGv_i32 tcg_res[2];
7470     int destelt = is_q ? 2 : 0;
7471     int passes = scalar ? 1 : 2;
7472
7473     if (scalar) {
7474         tcg_res[1] = tcg_const_i32(0);
7475     }
7476
7477     for (pass = 0; pass < passes; pass++) {
7478         TCGv_i64 tcg_op = tcg_temp_new_i64();
7479         NeonGenNarrowFn *genfn = NULL;
7480         NeonGenNarrowEnvFn *genenvfn = NULL;
7481
7482         if (scalar) {
7483             read_vec_element(s, tcg_op, rn, pass, size + 1);
7484         } else {
7485             read_vec_element(s, tcg_op, rn, pass, MO_64);
7486         }
7487         tcg_res[pass] = tcg_temp_new_i32();
7488
7489         switch (opcode) {
7490         case 0x12: /* XTN, SQXTUN */
7491         {
7492             static NeonGenNarrowFn * const xtnfns[3] = {
7493                 gen_helper_neon_narrow_u8,
7494                 gen_helper_neon_narrow_u16,
7495                 tcg_gen_trunc_i64_i32,
7496             };
7497             static NeonGenNarrowEnvFn * const sqxtunfns[3] = {
7498                 gen_helper_neon_unarrow_sat8,
7499                 gen_helper_neon_unarrow_sat16,
7500                 gen_helper_neon_unarrow_sat32,
7501             };
7502             if (u) {
7503                 genenvfn = sqxtunfns[size];
7504             } else {
7505                 genfn = xtnfns[size];
7506             }
7507             break;
7508         }
7509         case 0x14: /* SQXTN, UQXTN */
7510         {
7511             static NeonGenNarrowEnvFn * const fns[3][2] = {
7512                 { gen_helper_neon_narrow_sat_s8,
7513                   gen_helper_neon_narrow_sat_u8 },
7514                 { gen_helper_neon_narrow_sat_s16,
7515                   gen_helper_neon_narrow_sat_u16 },
7516                 { gen_helper_neon_narrow_sat_s32,
7517                   gen_helper_neon_narrow_sat_u32 },
7518             };
7519             genenvfn = fns[size][u];
7520             break;
7521         }
7522         case 0x16: /* FCVTN, FCVTN2 */
7523             /* 32 bit to 16 bit or 64 bit to 32 bit float conversion */
7524             if (size == 2) {
7525                 gen_helper_vfp_fcvtsd(tcg_res[pass], tcg_op, cpu_env);
7526             } else {
7527                 TCGv_i32 tcg_lo = tcg_temp_new_i32();
7528                 TCGv_i32 tcg_hi = tcg_temp_new_i32();
7529                 tcg_gen_trunc_i64_i32(tcg_lo, tcg_op);
7530                 gen_helper_vfp_fcvt_f32_to_f16(tcg_lo, tcg_lo, cpu_env);
7531                 tcg_gen_shri_i64(tcg_op, tcg_op, 32);
7532                 tcg_gen_trunc_i64_i32(tcg_hi, tcg_op);
7533                 gen_helper_vfp_fcvt_f32_to_f16(tcg_hi, tcg_hi, cpu_env);
7534                 tcg_gen_deposit_i32(tcg_res[pass], tcg_lo, tcg_hi, 16, 16);
7535                 tcg_temp_free_i32(tcg_lo);
7536                 tcg_temp_free_i32(tcg_hi);
7537             }
7538             break;
7539         case 0x56:  /* FCVTXN, FCVTXN2 */
7540             /* 64 bit to 32 bit float conversion
7541              * with von Neumann rounding (round to odd)
7542              */
7543             assert(size == 2);
7544             gen_helper_fcvtx_f64_to_f32(tcg_res[pass], tcg_op, cpu_env);
7545             break;
7546         default:
7547             g_assert_not_reached();
7548         }
7549
7550         if (genfn) {
7551             genfn(tcg_res[pass], tcg_op);
7552         } else if (genenvfn) {
7553             genenvfn(tcg_res[pass], cpu_env, tcg_op);
7554         }
7555
7556         tcg_temp_free_i64(tcg_op);
7557     }
7558
7559     for (pass = 0; pass < 2; pass++) {
7560         write_vec_element_i32(s, tcg_res[pass], rd, destelt + pass, MO_32);
7561         tcg_temp_free_i32(tcg_res[pass]);
7562     }
7563     if (!is_q) {
7564         clear_vec_high(s, rd);
7565     }
7566 }
7567
7568 /* Remaining saturating accumulating ops */
7569 static void handle_2misc_satacc(DisasContext *s, bool is_scalar, bool is_u,
7570                                 bool is_q, int size, int rn, int rd)
7571 {
7572     bool is_double = (size == 3);
7573
7574     if (is_double) {
7575         TCGv_i64 tcg_rn = tcg_temp_new_i64();
7576         TCGv_i64 tcg_rd = tcg_temp_new_i64();
7577         int pass;
7578
7579         for (pass = 0; pass < (is_scalar ? 1 : 2); pass++) {
7580             read_vec_element(s, tcg_rn, rn, pass, MO_64);
7581             read_vec_element(s, tcg_rd, rd, pass, MO_64);
7582
7583             if (is_u) { /* USQADD */
7584                 gen_helper_neon_uqadd_s64(tcg_rd, cpu_env, tcg_rn, tcg_rd);
7585             } else { /* SUQADD */
7586                 gen_helper_neon_sqadd_u64(tcg_rd, cpu_env, tcg_rn, tcg_rd);
7587             }
7588             write_vec_element(s, tcg_rd, rd, pass, MO_64);
7589         }
7590         if (is_scalar) {
7591             clear_vec_high(s, rd);
7592         }
7593
7594         tcg_temp_free_i64(tcg_rd);
7595         tcg_temp_free_i64(tcg_rn);
7596     } else {
7597         TCGv_i32 tcg_rn = tcg_temp_new_i32();
7598         TCGv_i32 tcg_rd = tcg_temp_new_i32();
7599         int pass, maxpasses;
7600
7601         if (is_scalar) {
7602             maxpasses = 1;
7603         } else {
7604             maxpasses = is_q ? 4 : 2;
7605         }
7606
7607         for (pass = 0; pass < maxpasses; pass++) {
7608             if (is_scalar) {
7609                 read_vec_element_i32(s, tcg_rn, rn, pass, size);
7610                 read_vec_element_i32(s, tcg_rd, rd, pass, size);
7611             } else {
7612                 read_vec_element_i32(s, tcg_rn, rn, pass, MO_32);
7613                 read_vec_element_i32(s, tcg_rd, rd, pass, MO_32);
7614             }
7615
7616             if (is_u) { /* USQADD */
7617                 switch (size) {
7618                 case 0:
7619                     gen_helper_neon_uqadd_s8(tcg_rd, cpu_env, tcg_rn, tcg_rd);
7620                     break;
7621                 case 1:
7622                     gen_helper_neon_uqadd_s16(tcg_rd, cpu_env, tcg_rn, tcg_rd);
7623                     break;
7624                 case 2:
7625                     gen_helper_neon_uqadd_s32(tcg_rd, cpu_env, tcg_rn, tcg_rd);
7626                     break;
7627                 default:
7628                     g_assert_not_reached();
7629                 }
7630             } else { /* SUQADD */
7631                 switch (size) {
7632                 case 0:
7633                     gen_helper_neon_sqadd_u8(tcg_rd, cpu_env, tcg_rn, tcg_rd);
7634                     break;
7635                 case 1:
7636                     gen_helper_neon_sqadd_u16(tcg_rd, cpu_env, tcg_rn, tcg_rd);
7637                     break;
7638                 case 2:
7639                     gen_helper_neon_sqadd_u32(tcg_rd, cpu_env, tcg_rn, tcg_rd);
7640                     break;
7641                 default:
7642                     g_assert_not_reached();
7643                 }
7644             }
7645
7646             if (is_scalar) {
7647                 TCGv_i64 tcg_zero = tcg_const_i64(0);
7648                 write_vec_element(s, tcg_zero, rd, 0, MO_64);
7649                 tcg_temp_free_i64(tcg_zero);
7650             }
7651             write_vec_element_i32(s, tcg_rd, rd, pass, MO_32);
7652         }
7653
7654         if (!is_q) {
7655             clear_vec_high(s, rd);
7656         }
7657
7658         tcg_temp_free_i32(tcg_rd);
7659         tcg_temp_free_i32(tcg_rn);
7660     }
7661 }
7662
7663 /* C3.6.12 AdvSIMD scalar two reg misc
7664  *  31 30  29 28       24 23  22 21       17 16    12 11 10 9    5 4    0
7665  * +-----+---+-----------+------+-----------+--------+-----+------+------+
7666  * | 0 1 | U | 1 1 1 1 0 | size | 1 0 0 0 0 | opcode | 1 0 |  Rn  |  Rd  |
7667  * +-----+---+-----------+------+-----------+--------+-----+------+------+
7668  */
7669 static void disas_simd_scalar_two_reg_misc(DisasContext *s, uint32_t insn)
7670 {
7671     int rd = extract32(insn, 0, 5);
7672     int rn = extract32(insn, 5, 5);
7673     int opcode = extract32(insn, 12, 5);
7674     int size = extract32(insn, 22, 2);
7675     bool u = extract32(insn, 29, 1);
7676     bool is_fcvt = false;
7677     int rmode;
7678     TCGv_i32 tcg_rmode;
7679     TCGv_ptr tcg_fpstatus;
7680
7681     switch (opcode) {
7682     case 0x3: /* USQADD / SUQADD*/
7683         if (!fp_access_check(s)) {
7684             return;
7685         }
7686         handle_2misc_satacc(s, true, u, false, size, rn, rd);
7687         return;
7688     case 0x7: /* SQABS / SQNEG */
7689         break;
7690     case 0xa: /* CMLT */
7691         if (u) {
7692             unallocated_encoding(s);
7693             return;
7694         }
7695         /* fall through */
7696     case 0x8: /* CMGT, CMGE */
7697     case 0x9: /* CMEQ, CMLE */
7698     case 0xb: /* ABS, NEG */
7699         if (size != 3) {
7700             unallocated_encoding(s);
7701             return;
7702         }
7703         break;
7704     case 0x12: /* SQXTUN */
7705         if (!u) {
7706             unallocated_encoding(s);
7707             return;
7708         }
7709         /* fall through */
7710     case 0x14: /* SQXTN, UQXTN */
7711         if (size == 3) {
7712             unallocated_encoding(s);
7713             return;
7714         }
7715         if (!fp_access_check(s)) {
7716             return;
7717         }
7718         handle_2misc_narrow(s, true, opcode, u, false, size, rn, rd);
7719         return;
7720     case 0xc ... 0xf:
7721     case 0x16 ... 0x1d:
7722     case 0x1f:
7723         /* Floating point: U, size[1] and opcode indicate operation;
7724          * size[0] indicates single or double precision.
7725          */
7726         opcode |= (extract32(size, 1, 1) << 5) | (u << 6);
7727         size = extract32(size, 0, 1) ? 3 : 2;
7728         switch (opcode) {
7729         case 0x2c: /* FCMGT (zero) */
7730         case 0x2d: /* FCMEQ (zero) */
7731         case 0x2e: /* FCMLT (zero) */
7732         case 0x6c: /* FCMGE (zero) */
7733         case 0x6d: /* FCMLE (zero) */
7734             handle_2misc_fcmp_zero(s, opcode, true, u, true, size, rn, rd);
7735             return;
7736         case 0x1d: /* SCVTF */
7737         case 0x5d: /* UCVTF */
7738         {
7739             bool is_signed = (opcode == 0x1d);
7740             if (!fp_access_check(s)) {
7741                 return;
7742             }
7743             handle_simd_intfp_conv(s, rd, rn, 1, is_signed, 0, size);
7744             return;
7745         }
7746         case 0x3d: /* FRECPE */
7747         case 0x3f: /* FRECPX */
7748         case 0x7d: /* FRSQRTE */
7749             if (!fp_access_check(s)) {
7750                 return;
7751             }
7752             handle_2misc_reciprocal(s, opcode, true, u, true, size, rn, rd);
7753             return;
7754         case 0x1a: /* FCVTNS */
7755         case 0x1b: /* FCVTMS */
7756         case 0x3a: /* FCVTPS */
7757         case 0x3b: /* FCVTZS */
7758         case 0x5a: /* FCVTNU */
7759         case 0x5b: /* FCVTMU */
7760         case 0x7a: /* FCVTPU */
7761         case 0x7b: /* FCVTZU */
7762             is_fcvt = true;
7763             rmode = extract32(opcode, 5, 1) | (extract32(opcode, 0, 1) << 1);
7764             break;
7765         case 0x1c: /* FCVTAS */
7766         case 0x5c: /* FCVTAU */
7767             /* TIEAWAY doesn't fit in the usual rounding mode encoding */
7768             is_fcvt = true;
7769             rmode = FPROUNDING_TIEAWAY;
7770             break;
7771         case 0x56: /* FCVTXN, FCVTXN2 */
7772             if (size == 2) {
7773                 unallocated_encoding(s);
7774                 return;
7775             }
7776             if (!fp_access_check(s)) {
7777                 return;
7778             }
7779             handle_2misc_narrow(s, true, opcode, u, false, size - 1, rn, rd);
7780             return;
7781         default:
7782             unallocated_encoding(s);
7783             return;
7784         }
7785         break;
7786     default:
7787         unallocated_encoding(s);
7788         return;
7789     }
7790
7791     if (!fp_access_check(s)) {
7792         return;
7793     }
7794
7795     if (is_fcvt) {
7796         tcg_rmode = tcg_const_i32(arm_rmode_to_sf(rmode));
7797         gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
7798         tcg_fpstatus = get_fpstatus_ptr();
7799     } else {
7800         TCGV_UNUSED_I32(tcg_rmode);
7801         TCGV_UNUSED_PTR(tcg_fpstatus);
7802     }
7803
7804     if (size == 3) {
7805         TCGv_i64 tcg_rn = read_fp_dreg(s, rn);
7806         TCGv_i64 tcg_rd = tcg_temp_new_i64();
7807
7808         handle_2misc_64(s, opcode, u, tcg_rd, tcg_rn, tcg_rmode, tcg_fpstatus);
7809         write_fp_dreg(s, rd, tcg_rd);
7810         tcg_temp_free_i64(tcg_rd);
7811         tcg_temp_free_i64(tcg_rn);
7812     } else {
7813         TCGv_i32 tcg_rn = tcg_temp_new_i32();
7814         TCGv_i32 tcg_rd = tcg_temp_new_i32();
7815
7816         read_vec_element_i32(s, tcg_rn, rn, 0, size);
7817
7818         switch (opcode) {
7819         case 0x7: /* SQABS, SQNEG */
7820         {
7821             NeonGenOneOpEnvFn *genfn;
7822             static NeonGenOneOpEnvFn * const fns[3][2] = {
7823                 { gen_helper_neon_qabs_s8, gen_helper_neon_qneg_s8 },
7824                 { gen_helper_neon_qabs_s16, gen_helper_neon_qneg_s16 },
7825                 { gen_helper_neon_qabs_s32, gen_helper_neon_qneg_s32 },
7826             };
7827             genfn = fns[size][u];
7828             genfn(tcg_rd, cpu_env, tcg_rn);
7829             break;
7830         }
7831         case 0x1a: /* FCVTNS */
7832         case 0x1b: /* FCVTMS */
7833         case 0x1c: /* FCVTAS */
7834         case 0x3a: /* FCVTPS */
7835         case 0x3b: /* FCVTZS */
7836         {
7837             TCGv_i32 tcg_shift = tcg_const_i32(0);
7838             gen_helper_vfp_tosls(tcg_rd, tcg_rn, tcg_shift, tcg_fpstatus);
7839             tcg_temp_free_i32(tcg_shift);
7840             break;
7841         }
7842         case 0x5a: /* FCVTNU */
7843         case 0x5b: /* FCVTMU */
7844         case 0x5c: /* FCVTAU */
7845         case 0x7a: /* FCVTPU */
7846         case 0x7b: /* FCVTZU */
7847         {
7848             TCGv_i32 tcg_shift = tcg_const_i32(0);
7849             gen_helper_vfp_touls(tcg_rd, tcg_rn, tcg_shift, tcg_fpstatus);
7850             tcg_temp_free_i32(tcg_shift);
7851             break;
7852         }
7853         default:
7854             g_assert_not_reached();
7855         }
7856
7857         write_fp_sreg(s, rd, tcg_rd);
7858         tcg_temp_free_i32(tcg_rd);
7859         tcg_temp_free_i32(tcg_rn);
7860     }
7861
7862     if (is_fcvt) {
7863         gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
7864         tcg_temp_free_i32(tcg_rmode);
7865         tcg_temp_free_ptr(tcg_fpstatus);
7866     }
7867 }
7868
7869 /* SSHR[RA]/USHR[RA] - Vector shift right (optional rounding/accumulate) */
7870 static void handle_vec_simd_shri(DisasContext *s, bool is_q, bool is_u,
7871                                  int immh, int immb, int opcode, int rn, int rd)
7872 {
7873     int size = 32 - clz32(immh) - 1;
7874     int immhb = immh << 3 | immb;
7875     int shift = 2 * (8 << size) - immhb;
7876     bool accumulate = false;
7877     bool round = false;
7878     bool insert = false;
7879     int dsize = is_q ? 128 : 64;
7880     int esize = 8 << size;
7881     int elements = dsize/esize;
7882     TCGMemOp memop = size | (is_u ? 0 : MO_SIGN);
7883     TCGv_i64 tcg_rn = new_tmp_a64(s);
7884     TCGv_i64 tcg_rd = new_tmp_a64(s);
7885     TCGv_i64 tcg_round;
7886     int i;
7887
7888     if (extract32(immh, 3, 1) && !is_q) {
7889         unallocated_encoding(s);
7890         return;
7891     }
7892
7893     if (size > 3 && !is_q) {
7894         unallocated_encoding(s);
7895         return;
7896     }
7897
7898     if (!fp_access_check(s)) {
7899         return;
7900     }
7901
7902     switch (opcode) {
7903     case 0x02: /* SSRA / USRA (accumulate) */
7904         accumulate = true;
7905         break;
7906     case 0x04: /* SRSHR / URSHR (rounding) */
7907         round = true;
7908         break;
7909     case 0x06: /* SRSRA / URSRA (accum + rounding) */
7910         accumulate = round = true;
7911         break;
7912     case 0x08: /* SRI */
7913         insert = true;
7914         break;
7915     }
7916
7917     if (round) {
7918         uint64_t round_const = 1ULL << (shift - 1);
7919         tcg_round = tcg_const_i64(round_const);
7920     } else {
7921         TCGV_UNUSED_I64(tcg_round);
7922     }
7923
7924     for (i = 0; i < elements; i++) {
7925         read_vec_element(s, tcg_rn, rn, i, memop);
7926         if (accumulate || insert) {
7927             read_vec_element(s, tcg_rd, rd, i, memop);
7928         }
7929
7930         if (insert) {
7931             handle_shri_with_ins(tcg_rd, tcg_rn, size, shift);
7932         } else {
7933             handle_shri_with_rndacc(tcg_rd, tcg_rn, tcg_round,
7934                                     accumulate, is_u, size, shift);
7935         }
7936
7937         write_vec_element(s, tcg_rd, rd, i, size);
7938     }
7939
7940     if (!is_q) {
7941         clear_vec_high(s, rd);
7942     }
7943
7944     if (round) {
7945         tcg_temp_free_i64(tcg_round);
7946     }
7947 }
7948
7949 /* SHL/SLI - Vector shift left */
7950 static void handle_vec_simd_shli(DisasContext *s, bool is_q, bool insert,
7951                                 int immh, int immb, int opcode, int rn, int rd)
7952 {
7953     int size = 32 - clz32(immh) - 1;
7954     int immhb = immh << 3 | immb;
7955     int shift = immhb - (8 << size);
7956     int dsize = is_q ? 128 : 64;
7957     int esize = 8 << size;
7958     int elements = dsize/esize;
7959     TCGv_i64 tcg_rn = new_tmp_a64(s);
7960     TCGv_i64 tcg_rd = new_tmp_a64(s);
7961     int i;
7962
7963     if (extract32(immh, 3, 1) && !is_q) {
7964         unallocated_encoding(s);
7965         return;
7966     }
7967
7968     if (size > 3 && !is_q) {
7969         unallocated_encoding(s);
7970         return;
7971     }
7972
7973     if (!fp_access_check(s)) {
7974         return;
7975     }
7976
7977     for (i = 0; i < elements; i++) {
7978         read_vec_element(s, tcg_rn, rn, i, size);
7979         if (insert) {
7980             read_vec_element(s, tcg_rd, rd, i, size);
7981         }
7982
7983         handle_shli_with_ins(tcg_rd, tcg_rn, insert, shift);
7984
7985         write_vec_element(s, tcg_rd, rd, i, size);
7986     }
7987
7988     if (!is_q) {
7989         clear_vec_high(s, rd);
7990     }
7991 }
7992
7993 /* USHLL/SHLL - Vector shift left with widening */
7994 static void handle_vec_simd_wshli(DisasContext *s, bool is_q, bool is_u,
7995                                  int immh, int immb, int opcode, int rn, int rd)
7996 {
7997     int size = 32 - clz32(immh) - 1;
7998     int immhb = immh << 3 | immb;
7999     int shift = immhb - (8 << size);
8000     int dsize = 64;
8001     int esize = 8 << size;
8002     int elements = dsize/esize;
8003     TCGv_i64 tcg_rn = new_tmp_a64(s);
8004     TCGv_i64 tcg_rd = new_tmp_a64(s);
8005     int i;
8006
8007     if (size >= 3) {
8008         unallocated_encoding(s);
8009         return;
8010     }
8011
8012     if (!fp_access_check(s)) {
8013         return;
8014     }
8015
8016     /* For the LL variants the store is larger than the load,
8017      * so if rd == rn we would overwrite parts of our input.
8018      * So load everything right now and use shifts in the main loop.
8019      */
8020     read_vec_element(s, tcg_rn, rn, is_q ? 1 : 0, MO_64);
8021
8022     for (i = 0; i < elements; i++) {
8023         tcg_gen_shri_i64(tcg_rd, tcg_rn, i * esize);
8024         ext_and_shift_reg(tcg_rd, tcg_rd, size | (!is_u << 2), 0);
8025         tcg_gen_shli_i64(tcg_rd, tcg_rd, shift);
8026         write_vec_element(s, tcg_rd, rd, i, size + 1);
8027     }
8028 }
8029
8030 /* SHRN/RSHRN - Shift right with narrowing (and potential rounding) */
8031 static void handle_vec_simd_shrn(DisasContext *s, bool is_q,
8032                                  int immh, int immb, int opcode, int rn, int rd)
8033 {
8034     int immhb = immh << 3 | immb;
8035     int size = 32 - clz32(immh) - 1;
8036     int dsize = 64;
8037     int esize = 8 << size;
8038     int elements = dsize/esize;
8039     int shift = (2 * esize) - immhb;
8040     bool round = extract32(opcode, 0, 1);
8041     TCGv_i64 tcg_rn, tcg_rd, tcg_final;
8042     TCGv_i64 tcg_round;
8043     int i;
8044
8045     if (extract32(immh, 3, 1)) {
8046         unallocated_encoding(s);
8047         return;
8048     }
8049
8050     if (!fp_access_check(s)) {
8051         return;
8052     }
8053
8054     tcg_rn = tcg_temp_new_i64();
8055     tcg_rd = tcg_temp_new_i64();
8056     tcg_final = tcg_temp_new_i64();
8057     read_vec_element(s, tcg_final, rd, is_q ? 1 : 0, MO_64);
8058
8059     if (round) {
8060         uint64_t round_const = 1ULL << (shift - 1);
8061         tcg_round = tcg_const_i64(round_const);
8062     } else {
8063         TCGV_UNUSED_I64(tcg_round);
8064     }
8065
8066     for (i = 0; i < elements; i++) {
8067         read_vec_element(s, tcg_rn, rn, i, size+1);
8068         handle_shri_with_rndacc(tcg_rd, tcg_rn, tcg_round,
8069                                 false, true, size+1, shift);
8070
8071         tcg_gen_deposit_i64(tcg_final, tcg_final, tcg_rd, esize * i, esize);
8072     }
8073
8074     if (!is_q) {
8075         clear_vec_high(s, rd);
8076         write_vec_element(s, tcg_final, rd, 0, MO_64);
8077     } else {
8078         write_vec_element(s, tcg_final, rd, 1, MO_64);
8079     }
8080
8081     if (round) {
8082         tcg_temp_free_i64(tcg_round);
8083     }
8084     tcg_temp_free_i64(tcg_rn);
8085     tcg_temp_free_i64(tcg_rd);
8086     tcg_temp_free_i64(tcg_final);
8087     return;
8088 }
8089
8090
8091 /* C3.6.14 AdvSIMD shift by immediate
8092  *  31  30   29 28         23 22  19 18  16 15    11  10 9    5 4    0
8093  * +---+---+---+-------------+------+------+--------+---+------+------+
8094  * | 0 | Q | U | 0 1 1 1 1 0 | immh | immb | opcode | 1 |  Rn  |  Rd  |
8095  * +---+---+---+-------------+------+------+--------+---+------+------+
8096  */
8097 static void disas_simd_shift_imm(DisasContext *s, uint32_t insn)
8098 {
8099     int rd = extract32(insn, 0, 5);
8100     int rn = extract32(insn, 5, 5);
8101     int opcode = extract32(insn, 11, 5);
8102     int immb = extract32(insn, 16, 3);
8103     int immh = extract32(insn, 19, 4);
8104     bool is_u = extract32(insn, 29, 1);
8105     bool is_q = extract32(insn, 30, 1);
8106
8107     switch (opcode) {
8108     case 0x08: /* SRI */
8109         if (!is_u) {
8110             unallocated_encoding(s);
8111             return;
8112         }
8113         /* fall through */
8114     case 0x00: /* SSHR / USHR */
8115     case 0x02: /* SSRA / USRA (accumulate) */
8116     case 0x04: /* SRSHR / URSHR (rounding) */
8117     case 0x06: /* SRSRA / URSRA (accum + rounding) */
8118         handle_vec_simd_shri(s, is_q, is_u, immh, immb, opcode, rn, rd);
8119         break;
8120     case 0x0a: /* SHL / SLI */
8121         handle_vec_simd_shli(s, is_q, is_u, immh, immb, opcode, rn, rd);
8122         break;
8123     case 0x10: /* SHRN */
8124     case 0x11: /* RSHRN / SQRSHRUN */
8125         if (is_u) {
8126             handle_vec_simd_sqshrn(s, false, is_q, false, true, immh, immb,
8127                                    opcode, rn, rd);
8128         } else {
8129             handle_vec_simd_shrn(s, is_q, immh, immb, opcode, rn, rd);
8130         }
8131         break;
8132     case 0x12: /* SQSHRN / UQSHRN */
8133     case 0x13: /* SQRSHRN / UQRSHRN */
8134         handle_vec_simd_sqshrn(s, false, is_q, is_u, is_u, immh, immb,
8135                                opcode, rn, rd);
8136         break;
8137     case 0x14: /* SSHLL / USHLL */
8138         handle_vec_simd_wshli(s, is_q, is_u, immh, immb, opcode, rn, rd);
8139         break;
8140     case 0x1c: /* SCVTF / UCVTF */
8141         handle_simd_shift_intfp_conv(s, false, is_q, is_u, immh, immb,
8142                                      opcode, rn, rd);
8143         break;
8144     case 0xc: /* SQSHLU */
8145         if (!is_u) {
8146             unallocated_encoding(s);
8147             return;
8148         }
8149         handle_simd_qshl(s, false, is_q, false, true, immh, immb, rn, rd);
8150         break;
8151     case 0xe: /* SQSHL, UQSHL */
8152         handle_simd_qshl(s, false, is_q, is_u, is_u, immh, immb, rn, rd);
8153         break;
8154     case 0x1f: /* FCVTZS/ FCVTZU */
8155         handle_simd_shift_fpint_conv(s, false, is_q, is_u, immh, immb, rn, rd);
8156         return;
8157     default:
8158         unallocated_encoding(s);
8159         return;
8160     }
8161 }
8162
8163 /* Generate code to do a "long" addition or subtraction, ie one done in
8164  * TCGv_i64 on vector lanes twice the width specified by size.
8165  */
8166 static void gen_neon_addl(int size, bool is_sub, TCGv_i64 tcg_res,
8167                           TCGv_i64 tcg_op1, TCGv_i64 tcg_op2)
8168 {
8169     static NeonGenTwo64OpFn * const fns[3][2] = {
8170         { gen_helper_neon_addl_u16, gen_helper_neon_subl_u16 },
8171         { gen_helper_neon_addl_u32, gen_helper_neon_subl_u32 },
8172         { tcg_gen_add_i64, tcg_gen_sub_i64 },
8173     };
8174     NeonGenTwo64OpFn *genfn;
8175     assert(size < 3);
8176
8177     genfn = fns[size][is_sub];
8178     genfn(tcg_res, tcg_op1, tcg_op2);
8179 }
8180
8181 static void handle_3rd_widening(DisasContext *s, int is_q, int is_u, int size,
8182                                 int opcode, int rd, int rn, int rm)
8183 {
8184     /* 3-reg-different widening insns: 64 x 64 -> 128 */
8185     TCGv_i64 tcg_res[2];
8186     int pass, accop;
8187
8188     tcg_res[0] = tcg_temp_new_i64();
8189     tcg_res[1] = tcg_temp_new_i64();
8190
8191     /* Does this op do an adding accumulate, a subtracting accumulate,
8192      * or no accumulate at all?
8193      */
8194     switch (opcode) {
8195     case 5:
8196     case 8:
8197     case 9:
8198         accop = 1;
8199         break;
8200     case 10:
8201     case 11:
8202         accop = -1;
8203         break;
8204     default:
8205         accop = 0;
8206         break;
8207     }
8208
8209     if (accop != 0) {
8210         read_vec_element(s, tcg_res[0], rd, 0, MO_64);
8211         read_vec_element(s, tcg_res[1], rd, 1, MO_64);
8212     }
8213
8214     /* size == 2 means two 32x32->64 operations; this is worth special
8215      * casing because we can generally handle it inline.
8216      */
8217     if (size == 2) {
8218         for (pass = 0; pass < 2; pass++) {
8219             TCGv_i64 tcg_op1 = tcg_temp_new_i64();
8220             TCGv_i64 tcg_op2 = tcg_temp_new_i64();
8221             TCGv_i64 tcg_passres;
8222             TCGMemOp memop = MO_32 | (is_u ? 0 : MO_SIGN);
8223
8224             int elt = pass + is_q * 2;
8225
8226             read_vec_element(s, tcg_op1, rn, elt, memop);
8227             read_vec_element(s, tcg_op2, rm, elt, memop);
8228
8229             if (accop == 0) {
8230                 tcg_passres = tcg_res[pass];
8231             } else {
8232                 tcg_passres = tcg_temp_new_i64();
8233             }
8234
8235             switch (opcode) {
8236             case 0: /* SADDL, SADDL2, UADDL, UADDL2 */
8237                 tcg_gen_add_i64(tcg_passres, tcg_op1, tcg_op2);
8238                 break;
8239             case 2: /* SSUBL, SSUBL2, USUBL, USUBL2 */
8240                 tcg_gen_sub_i64(tcg_passres, tcg_op1, tcg_op2);
8241                 break;
8242             case 5: /* SABAL, SABAL2, UABAL, UABAL2 */
8243             case 7: /* SABDL, SABDL2, UABDL, UABDL2 */
8244             {
8245                 TCGv_i64 tcg_tmp1 = tcg_temp_new_i64();
8246                 TCGv_i64 tcg_tmp2 = tcg_temp_new_i64();
8247
8248                 tcg_gen_sub_i64(tcg_tmp1, tcg_op1, tcg_op2);
8249                 tcg_gen_sub_i64(tcg_tmp2, tcg_op2, tcg_op1);
8250                 tcg_gen_movcond_i64(is_u ? TCG_COND_GEU : TCG_COND_GE,
8251                                     tcg_passres,
8252                                     tcg_op1, tcg_op2, tcg_tmp1, tcg_tmp2);
8253                 tcg_temp_free_i64(tcg_tmp1);
8254                 tcg_temp_free_i64(tcg_tmp2);
8255                 break;
8256             }
8257             case 8: /* SMLAL, SMLAL2, UMLAL, UMLAL2 */
8258             case 10: /* SMLSL, SMLSL2, UMLSL, UMLSL2 */
8259             case 12: /* UMULL, UMULL2, SMULL, SMULL2 */
8260                 tcg_gen_mul_i64(tcg_passres, tcg_op1, tcg_op2);
8261                 break;
8262             case 9: /* SQDMLAL, SQDMLAL2 */
8263             case 11: /* SQDMLSL, SQDMLSL2 */
8264             case 13: /* SQDMULL, SQDMULL2 */
8265                 tcg_gen_mul_i64(tcg_passres, tcg_op1, tcg_op2);
8266                 gen_helper_neon_addl_saturate_s64(tcg_passres, cpu_env,
8267                                                   tcg_passres, tcg_passres);
8268                 break;
8269             default:
8270                 g_assert_not_reached();
8271             }
8272
8273             if (opcode == 9 || opcode == 11) {
8274                 /* saturating accumulate ops */
8275                 if (accop < 0) {
8276                     tcg_gen_neg_i64(tcg_passres, tcg_passres);
8277                 }
8278                 gen_helper_neon_addl_saturate_s64(tcg_res[pass], cpu_env,
8279                                                   tcg_res[pass], tcg_passres);
8280             } else if (accop > 0) {
8281                 tcg_gen_add_i64(tcg_res[pass], tcg_res[pass], tcg_passres);
8282             } else if (accop < 0) {
8283                 tcg_gen_sub_i64(tcg_res[pass], tcg_res[pass], tcg_passres);
8284             }
8285
8286             if (accop != 0) {
8287                 tcg_temp_free_i64(tcg_passres);
8288             }
8289
8290             tcg_temp_free_i64(tcg_op1);
8291             tcg_temp_free_i64(tcg_op2);
8292         }
8293     } else {
8294         /* size 0 or 1, generally helper functions */
8295         for (pass = 0; pass < 2; pass++) {
8296             TCGv_i32 tcg_op1 = tcg_temp_new_i32();
8297             TCGv_i32 tcg_op2 = tcg_temp_new_i32();
8298             TCGv_i64 tcg_passres;
8299             int elt = pass + is_q * 2;
8300
8301             read_vec_element_i32(s, tcg_op1, rn, elt, MO_32);
8302             read_vec_element_i32(s, tcg_op2, rm, elt, MO_32);
8303
8304             if (accop == 0) {
8305                 tcg_passres = tcg_res[pass];
8306             } else {
8307                 tcg_passres = tcg_temp_new_i64();
8308             }
8309
8310             switch (opcode) {
8311             case 0: /* SADDL, SADDL2, UADDL, UADDL2 */
8312             case 2: /* SSUBL, SSUBL2, USUBL, USUBL2 */
8313             {
8314                 TCGv_i64 tcg_op2_64 = tcg_temp_new_i64();
8315                 static NeonGenWidenFn * const widenfns[2][2] = {
8316                     { gen_helper_neon_widen_s8, gen_helper_neon_widen_u8 },
8317                     { gen_helper_neon_widen_s16, gen_helper_neon_widen_u16 },
8318                 };
8319                 NeonGenWidenFn *widenfn = widenfns[size][is_u];
8320
8321                 widenfn(tcg_op2_64, tcg_op2);
8322                 widenfn(tcg_passres, tcg_op1);
8323                 gen_neon_addl(size, (opcode == 2), tcg_passres,
8324                               tcg_passres, tcg_op2_64);
8325                 tcg_temp_free_i64(tcg_op2_64);
8326                 break;
8327             }
8328             case 5: /* SABAL, SABAL2, UABAL, UABAL2 */
8329             case 7: /* SABDL, SABDL2, UABDL, UABDL2 */
8330                 if (size == 0) {
8331                     if (is_u) {
8332                         gen_helper_neon_abdl_u16(tcg_passres, tcg_op1, tcg_op2);
8333                     } else {
8334                         gen_helper_neon_abdl_s16(tcg_passres, tcg_op1, tcg_op2);
8335                     }
8336                 } else {
8337                     if (is_u) {
8338                         gen_helper_neon_abdl_u32(tcg_passres, tcg_op1, tcg_op2);
8339                     } else {
8340                         gen_helper_neon_abdl_s32(tcg_passres, tcg_op1, tcg_op2);
8341                     }
8342                 }
8343                 break;
8344             case 8: /* SMLAL, SMLAL2, UMLAL, UMLAL2 */
8345             case 10: /* SMLSL, SMLSL2, UMLSL, UMLSL2 */
8346             case 12: /* UMULL, UMULL2, SMULL, SMULL2 */
8347                 if (size == 0) {
8348                     if (is_u) {
8349                         gen_helper_neon_mull_u8(tcg_passres, tcg_op1, tcg_op2);
8350                     } else {
8351                         gen_helper_neon_mull_s8(tcg_passres, tcg_op1, tcg_op2);
8352                     }
8353                 } else {
8354                     if (is_u) {
8355                         gen_helper_neon_mull_u16(tcg_passres, tcg_op1, tcg_op2);
8356                     } else {
8357                         gen_helper_neon_mull_s16(tcg_passres, tcg_op1, tcg_op2);
8358                     }
8359                 }
8360                 break;
8361             case 9: /* SQDMLAL, SQDMLAL2 */
8362             case 11: /* SQDMLSL, SQDMLSL2 */
8363             case 13: /* SQDMULL, SQDMULL2 */
8364                 assert(size == 1);
8365                 gen_helper_neon_mull_s16(tcg_passres, tcg_op1, tcg_op2);
8366                 gen_helper_neon_addl_saturate_s32(tcg_passres, cpu_env,
8367                                                   tcg_passres, tcg_passres);
8368                 break;
8369             case 14: /* PMULL */
8370                 assert(size == 0);
8371                 gen_helper_neon_mull_p8(tcg_passres, tcg_op1, tcg_op2);
8372                 break;
8373             default:
8374                 g_assert_not_reached();
8375             }
8376             tcg_temp_free_i32(tcg_op1);
8377             tcg_temp_free_i32(tcg_op2);
8378
8379             if (accop != 0) {
8380                 if (opcode == 9 || opcode == 11) {
8381                     /* saturating accumulate ops */
8382                     if (accop < 0) {
8383                         gen_helper_neon_negl_u32(tcg_passres, tcg_passres);
8384                     }
8385                     gen_helper_neon_addl_saturate_s32(tcg_res[pass], cpu_env,
8386                                                       tcg_res[pass],
8387                                                       tcg_passres);
8388                 } else {
8389                     gen_neon_addl(size, (accop < 0), tcg_res[pass],
8390                                   tcg_res[pass], tcg_passres);
8391                 }
8392                 tcg_temp_free_i64(tcg_passres);
8393             }
8394         }
8395     }
8396
8397     write_vec_element(s, tcg_res[0], rd, 0, MO_64);
8398     write_vec_element(s, tcg_res[1], rd, 1, MO_64);
8399     tcg_temp_free_i64(tcg_res[0]);
8400     tcg_temp_free_i64(tcg_res[1]);
8401 }
8402
8403 static void handle_3rd_wide(DisasContext *s, int is_q, int is_u, int size,
8404                             int opcode, int rd, int rn, int rm)
8405 {
8406     TCGv_i64 tcg_res[2];
8407     int part = is_q ? 2 : 0;
8408     int pass;
8409
8410     for (pass = 0; pass < 2; pass++) {
8411         TCGv_i64 tcg_op1 = tcg_temp_new_i64();
8412         TCGv_i32 tcg_op2 = tcg_temp_new_i32();
8413         TCGv_i64 tcg_op2_wide = tcg_temp_new_i64();
8414         static NeonGenWidenFn * const widenfns[3][2] = {
8415             { gen_helper_neon_widen_s8, gen_helper_neon_widen_u8 },
8416             { gen_helper_neon_widen_s16, gen_helper_neon_widen_u16 },
8417             { tcg_gen_ext_i32_i64, tcg_gen_extu_i32_i64 },
8418         };
8419         NeonGenWidenFn *widenfn = widenfns[size][is_u];
8420
8421         read_vec_element(s, tcg_op1, rn, pass, MO_64);
8422         read_vec_element_i32(s, tcg_op2, rm, part + pass, MO_32);
8423         widenfn(tcg_op2_wide, tcg_op2);
8424         tcg_temp_free_i32(tcg_op2);
8425         tcg_res[pass] = tcg_temp_new_i64();
8426         gen_neon_addl(size, (opcode == 3),
8427                       tcg_res[pass], tcg_op1, tcg_op2_wide);
8428         tcg_temp_free_i64(tcg_op1);
8429         tcg_temp_free_i64(tcg_op2_wide);
8430     }
8431
8432     for (pass = 0; pass < 2; pass++) {
8433         write_vec_element(s, tcg_res[pass], rd, pass, MO_64);
8434         tcg_temp_free_i64(tcg_res[pass]);
8435     }
8436 }
8437
8438 static void do_narrow_high_u32(TCGv_i32 res, TCGv_i64 in)
8439 {
8440     tcg_gen_shri_i64(in, in, 32);
8441     tcg_gen_trunc_i64_i32(res, in);
8442 }
8443
8444 static void do_narrow_round_high_u32(TCGv_i32 res, TCGv_i64 in)
8445 {
8446     tcg_gen_addi_i64(in, in, 1U << 31);
8447     do_narrow_high_u32(res, in);
8448 }
8449
8450 static void handle_3rd_narrowing(DisasContext *s, int is_q, int is_u, int size,
8451                                  int opcode, int rd, int rn, int rm)
8452 {
8453     TCGv_i32 tcg_res[2];
8454     int part = is_q ? 2 : 0;
8455     int pass;
8456
8457     for (pass = 0; pass < 2; pass++) {
8458         TCGv_i64 tcg_op1 = tcg_temp_new_i64();
8459         TCGv_i64 tcg_op2 = tcg_temp_new_i64();
8460         TCGv_i64 tcg_wideres = tcg_temp_new_i64();
8461         static NeonGenNarrowFn * const narrowfns[3][2] = {
8462             { gen_helper_neon_narrow_high_u8,
8463               gen_helper_neon_narrow_round_high_u8 },
8464             { gen_helper_neon_narrow_high_u16,
8465               gen_helper_neon_narrow_round_high_u16 },
8466             { do_narrow_high_u32, do_narrow_round_high_u32 },
8467         };
8468         NeonGenNarrowFn *gennarrow = narrowfns[size][is_u];
8469
8470         read_vec_element(s, tcg_op1, rn, pass, MO_64);
8471         read_vec_element(s, tcg_op2, rm, pass, MO_64);
8472
8473         gen_neon_addl(size, (opcode == 6), tcg_wideres, tcg_op1, tcg_op2);
8474
8475         tcg_temp_free_i64(tcg_op1);
8476         tcg_temp_free_i64(tcg_op2);
8477
8478         tcg_res[pass] = tcg_temp_new_i32();
8479         gennarrow(tcg_res[pass], tcg_wideres);
8480         tcg_temp_free_i64(tcg_wideres);
8481     }
8482
8483     for (pass = 0; pass < 2; pass++) {
8484         write_vec_element_i32(s, tcg_res[pass], rd, pass + part, MO_32);
8485         tcg_temp_free_i32(tcg_res[pass]);
8486     }
8487     if (!is_q) {
8488         clear_vec_high(s, rd);
8489     }
8490 }
8491
8492 static void handle_pmull_64(DisasContext *s, int is_q, int rd, int rn, int rm)
8493 {
8494     /* PMULL of 64 x 64 -> 128 is an odd special case because it
8495      * is the only three-reg-diff instruction which produces a
8496      * 128-bit wide result from a single operation. However since
8497      * it's possible to calculate the two halves more or less
8498      * separately we just use two helper calls.
8499      */
8500     TCGv_i64 tcg_op1 = tcg_temp_new_i64();
8501     TCGv_i64 tcg_op2 = tcg_temp_new_i64();
8502     TCGv_i64 tcg_res = tcg_temp_new_i64();
8503
8504     read_vec_element(s, tcg_op1, rn, is_q, MO_64);
8505     read_vec_element(s, tcg_op2, rm, is_q, MO_64);
8506     gen_helper_neon_pmull_64_lo(tcg_res, tcg_op1, tcg_op2);
8507     write_vec_element(s, tcg_res, rd, 0, MO_64);
8508     gen_helper_neon_pmull_64_hi(tcg_res, tcg_op1, tcg_op2);
8509     write_vec_element(s, tcg_res, rd, 1, MO_64);
8510
8511     tcg_temp_free_i64(tcg_op1);
8512     tcg_temp_free_i64(tcg_op2);
8513     tcg_temp_free_i64(tcg_res);
8514 }
8515
8516 /* C3.6.15 AdvSIMD three different
8517  *   31  30  29 28       24 23  22  21 20  16 15    12 11 10 9    5 4    0
8518  * +---+---+---+-----------+------+---+------+--------+-----+------+------+
8519  * | 0 | Q | U | 0 1 1 1 0 | size | 1 |  Rm  | opcode | 0 0 |  Rn  |  Rd  |
8520  * +---+---+---+-----------+------+---+------+--------+-----+------+------+
8521  */
8522 static void disas_simd_three_reg_diff(DisasContext *s, uint32_t insn)
8523 {
8524     /* Instructions in this group fall into three basic classes
8525      * (in each case with the operation working on each element in
8526      * the input vectors):
8527      * (1) widening 64 x 64 -> 128 (with possibly Vd as an extra
8528      *     128 bit input)
8529      * (2) wide 64 x 128 -> 128
8530      * (3) narrowing 128 x 128 -> 64
8531      * Here we do initial decode, catch unallocated cases and
8532      * dispatch to separate functions for each class.
8533      */
8534     int is_q = extract32(insn, 30, 1);
8535     int is_u = extract32(insn, 29, 1);
8536     int size = extract32(insn, 22, 2);
8537     int opcode = extract32(insn, 12, 4);
8538     int rm = extract32(insn, 16, 5);
8539     int rn = extract32(insn, 5, 5);
8540     int rd = extract32(insn, 0, 5);
8541
8542     switch (opcode) {
8543     case 1: /* SADDW, SADDW2, UADDW, UADDW2 */
8544     case 3: /* SSUBW, SSUBW2, USUBW, USUBW2 */
8545         /* 64 x 128 -> 128 */
8546         if (size == 3) {
8547             unallocated_encoding(s);
8548             return;
8549         }
8550         if (!fp_access_check(s)) {
8551             return;
8552         }
8553         handle_3rd_wide(s, is_q, is_u, size, opcode, rd, rn, rm);
8554         break;
8555     case 4: /* ADDHN, ADDHN2, RADDHN, RADDHN2 */
8556     case 6: /* SUBHN, SUBHN2, RSUBHN, RSUBHN2 */
8557         /* 128 x 128 -> 64 */
8558         if (size == 3) {
8559             unallocated_encoding(s);
8560             return;
8561         }
8562         if (!fp_access_check(s)) {
8563             return;
8564         }
8565         handle_3rd_narrowing(s, is_q, is_u, size, opcode, rd, rn, rm);
8566         break;
8567     case 14: /* PMULL, PMULL2 */
8568         if (is_u || size == 1 || size == 2) {
8569             unallocated_encoding(s);
8570             return;
8571         }
8572         if (size == 3) {
8573             if (!arm_dc_feature(s, ARM_FEATURE_V8_AES)) {
8574                 unallocated_encoding(s);
8575                 return;
8576             }
8577             if (!fp_access_check(s)) {
8578                 return;
8579             }
8580             handle_pmull_64(s, is_q, rd, rn, rm);
8581             return;
8582         }
8583         goto is_widening;
8584     case 9: /* SQDMLAL, SQDMLAL2 */
8585     case 11: /* SQDMLSL, SQDMLSL2 */
8586     case 13: /* SQDMULL, SQDMULL2 */
8587         if (is_u || size == 0) {
8588             unallocated_encoding(s);
8589             return;
8590         }
8591         /* fall through */
8592     case 0: /* SADDL, SADDL2, UADDL, UADDL2 */
8593     case 2: /* SSUBL, SSUBL2, USUBL, USUBL2 */
8594     case 5: /* SABAL, SABAL2, UABAL, UABAL2 */
8595     case 7: /* SABDL, SABDL2, UABDL, UABDL2 */
8596     case 8: /* SMLAL, SMLAL2, UMLAL, UMLAL2 */
8597     case 10: /* SMLSL, SMLSL2, UMLSL, UMLSL2 */
8598     case 12: /* SMULL, SMULL2, UMULL, UMULL2 */
8599         /* 64 x 64 -> 128 */
8600         if (size == 3) {
8601             unallocated_encoding(s);
8602             return;
8603         }
8604     is_widening:
8605         if (!fp_access_check(s)) {
8606             return;
8607         }
8608
8609         handle_3rd_widening(s, is_q, is_u, size, opcode, rd, rn, rm);
8610         break;
8611     default:
8612         /* opcode 15 not allocated */
8613         unallocated_encoding(s);
8614         break;
8615     }
8616 }
8617
8618 /* Logic op (opcode == 3) subgroup of C3.6.16. */
8619 static void disas_simd_3same_logic(DisasContext *s, uint32_t insn)
8620 {
8621     int rd = extract32(insn, 0, 5);
8622     int rn = extract32(insn, 5, 5);
8623     int rm = extract32(insn, 16, 5);
8624     int size = extract32(insn, 22, 2);
8625     bool is_u = extract32(insn, 29, 1);
8626     bool is_q = extract32(insn, 30, 1);
8627     TCGv_i64 tcg_op1, tcg_op2, tcg_res[2];
8628     int pass;
8629
8630     if (!fp_access_check(s)) {
8631         return;
8632     }
8633
8634     tcg_op1 = tcg_temp_new_i64();
8635     tcg_op2 = tcg_temp_new_i64();
8636     tcg_res[0] = tcg_temp_new_i64();
8637     tcg_res[1] = tcg_temp_new_i64();
8638
8639     for (pass = 0; pass < (is_q ? 2 : 1); pass++) {
8640         read_vec_element(s, tcg_op1, rn, pass, MO_64);
8641         read_vec_element(s, tcg_op2, rm, pass, MO_64);
8642
8643         if (!is_u) {
8644             switch (size) {
8645             case 0: /* AND */
8646                 tcg_gen_and_i64(tcg_res[pass], tcg_op1, tcg_op2);
8647                 break;
8648             case 1: /* BIC */
8649                 tcg_gen_andc_i64(tcg_res[pass], tcg_op1, tcg_op2);
8650                 break;
8651             case 2: /* ORR */
8652                 tcg_gen_or_i64(tcg_res[pass], tcg_op1, tcg_op2);
8653                 break;
8654             case 3: /* ORN */
8655                 tcg_gen_orc_i64(tcg_res[pass], tcg_op1, tcg_op2);
8656                 break;
8657             }
8658         } else {
8659             if (size != 0) {
8660                 /* B* ops need res loaded to operate on */
8661                 read_vec_element(s, tcg_res[pass], rd, pass, MO_64);
8662             }
8663
8664             switch (size) {
8665             case 0: /* EOR */
8666                 tcg_gen_xor_i64(tcg_res[pass], tcg_op1, tcg_op2);
8667                 break;
8668             case 1: /* BSL bitwise select */
8669                 tcg_gen_xor_i64(tcg_op1, tcg_op1, tcg_op2);
8670                 tcg_gen_and_i64(tcg_op1, tcg_op1, tcg_res[pass]);
8671                 tcg_gen_xor_i64(tcg_res[pass], tcg_op2, tcg_op1);
8672                 break;
8673             case 2: /* BIT, bitwise insert if true */
8674                 tcg_gen_xor_i64(tcg_op1, tcg_op1, tcg_res[pass]);
8675                 tcg_gen_and_i64(tcg_op1, tcg_op1, tcg_op2);
8676                 tcg_gen_xor_i64(tcg_res[pass], tcg_res[pass], tcg_op1);
8677                 break;
8678             case 3: /* BIF, bitwise insert if false */
8679                 tcg_gen_xor_i64(tcg_op1, tcg_op1, tcg_res[pass]);
8680                 tcg_gen_andc_i64(tcg_op1, tcg_op1, tcg_op2);
8681                 tcg_gen_xor_i64(tcg_res[pass], tcg_res[pass], tcg_op1);
8682                 break;
8683             }
8684         }
8685     }
8686
8687     write_vec_element(s, tcg_res[0], rd, 0, MO_64);
8688     if (!is_q) {
8689         tcg_gen_movi_i64(tcg_res[1], 0);
8690     }
8691     write_vec_element(s, tcg_res[1], rd, 1, MO_64);
8692
8693     tcg_temp_free_i64(tcg_op1);
8694     tcg_temp_free_i64(tcg_op2);
8695     tcg_temp_free_i64(tcg_res[0]);
8696     tcg_temp_free_i64(tcg_res[1]);
8697 }
8698
8699 /* Helper functions for 32 bit comparisons */
8700 static void gen_max_s32(TCGv_i32 res, TCGv_i32 op1, TCGv_i32 op2)
8701 {
8702     tcg_gen_movcond_i32(TCG_COND_GE, res, op1, op2, op1, op2);
8703 }
8704
8705 static void gen_max_u32(TCGv_i32 res, TCGv_i32 op1, TCGv_i32 op2)
8706 {
8707     tcg_gen_movcond_i32(TCG_COND_GEU, res, op1, op2, op1, op2);
8708 }
8709
8710 static void gen_min_s32(TCGv_i32 res, TCGv_i32 op1, TCGv_i32 op2)
8711 {
8712     tcg_gen_movcond_i32(TCG_COND_LE, res, op1, op2, op1, op2);
8713 }
8714
8715 static void gen_min_u32(TCGv_i32 res, TCGv_i32 op1, TCGv_i32 op2)
8716 {
8717     tcg_gen_movcond_i32(TCG_COND_LEU, res, op1, op2, op1, op2);
8718 }
8719
8720 /* Pairwise op subgroup of C3.6.16.
8721  *
8722  * This is called directly or via the handle_3same_float for float pairwise
8723  * operations where the opcode and size are calculated differently.
8724  */
8725 static void handle_simd_3same_pair(DisasContext *s, int is_q, int u, int opcode,
8726                                    int size, int rn, int rm, int rd)
8727 {
8728     TCGv_ptr fpst;
8729     int pass;
8730
8731     /* Floating point operations need fpst */
8732     if (opcode >= 0x58) {
8733         fpst = get_fpstatus_ptr();
8734     } else {
8735         TCGV_UNUSED_PTR(fpst);
8736     }
8737
8738     if (!fp_access_check(s)) {
8739         return;
8740     }
8741
8742     /* These operations work on the concatenated rm:rn, with each pair of
8743      * adjacent elements being operated on to produce an element in the result.
8744      */
8745     if (size == 3) {
8746         TCGv_i64 tcg_res[2];
8747
8748         for (pass = 0; pass < 2; pass++) {
8749             TCGv_i64 tcg_op1 = tcg_temp_new_i64();
8750             TCGv_i64 tcg_op2 = tcg_temp_new_i64();
8751             int passreg = (pass == 0) ? rn : rm;
8752
8753             read_vec_element(s, tcg_op1, passreg, 0, MO_64);
8754             read_vec_element(s, tcg_op2, passreg, 1, MO_64);
8755             tcg_res[pass] = tcg_temp_new_i64();
8756
8757             switch (opcode) {
8758             case 0x17: /* ADDP */
8759                 tcg_gen_add_i64(tcg_res[pass], tcg_op1, tcg_op2);
8760                 break;
8761             case 0x58: /* FMAXNMP */
8762                 gen_helper_vfp_maxnumd(tcg_res[pass], tcg_op1, tcg_op2, fpst);
8763                 break;
8764             case 0x5a: /* FADDP */
8765                 gen_helper_vfp_addd(tcg_res[pass], tcg_op1, tcg_op2, fpst);
8766                 break;
8767             case 0x5e: /* FMAXP */
8768                 gen_helper_vfp_maxd(tcg_res[pass], tcg_op1, tcg_op2, fpst);
8769                 break;
8770             case 0x78: /* FMINNMP */
8771                 gen_helper_vfp_minnumd(tcg_res[pass], tcg_op1, tcg_op2, fpst);
8772                 break;
8773             case 0x7e: /* FMINP */
8774                 gen_helper_vfp_mind(tcg_res[pass], tcg_op1, tcg_op2, fpst);
8775                 break;
8776             default:
8777                 g_assert_not_reached();
8778             }
8779
8780             tcg_temp_free_i64(tcg_op1);
8781             tcg_temp_free_i64(tcg_op2);
8782         }
8783
8784         for (pass = 0; pass < 2; pass++) {
8785             write_vec_element(s, tcg_res[pass], rd, pass, MO_64);
8786             tcg_temp_free_i64(tcg_res[pass]);
8787         }
8788     } else {
8789         int maxpass = is_q ? 4 : 2;
8790         TCGv_i32 tcg_res[4];
8791
8792         for (pass = 0; pass < maxpass; pass++) {
8793             TCGv_i32 tcg_op1 = tcg_temp_new_i32();
8794             TCGv_i32 tcg_op2 = tcg_temp_new_i32();
8795             NeonGenTwoOpFn *genfn = NULL;
8796             int passreg = pass < (maxpass / 2) ? rn : rm;
8797             int passelt = (is_q && (pass & 1)) ? 2 : 0;
8798
8799             read_vec_element_i32(s, tcg_op1, passreg, passelt, MO_32);
8800             read_vec_element_i32(s, tcg_op2, passreg, passelt + 1, MO_32);
8801             tcg_res[pass] = tcg_temp_new_i32();
8802
8803             switch (opcode) {
8804             case 0x17: /* ADDP */
8805             {
8806                 static NeonGenTwoOpFn * const fns[3] = {
8807                     gen_helper_neon_padd_u8,
8808                     gen_helper_neon_padd_u16,
8809                     tcg_gen_add_i32,
8810                 };
8811                 genfn = fns[size];
8812                 break;
8813             }
8814             case 0x14: /* SMAXP, UMAXP */
8815             {
8816                 static NeonGenTwoOpFn * const fns[3][2] = {
8817                     { gen_helper_neon_pmax_s8, gen_helper_neon_pmax_u8 },
8818                     { gen_helper_neon_pmax_s16, gen_helper_neon_pmax_u16 },
8819                     { gen_max_s32, gen_max_u32 },
8820                 };
8821                 genfn = fns[size][u];
8822                 break;
8823             }
8824             case 0x15: /* SMINP, UMINP */
8825             {
8826                 static NeonGenTwoOpFn * const fns[3][2] = {
8827                     { gen_helper_neon_pmin_s8, gen_helper_neon_pmin_u8 },
8828                     { gen_helper_neon_pmin_s16, gen_helper_neon_pmin_u16 },
8829                     { gen_min_s32, gen_min_u32 },
8830                 };
8831                 genfn = fns[size][u];
8832                 break;
8833             }
8834             /* The FP operations are all on single floats (32 bit) */
8835             case 0x58: /* FMAXNMP */
8836                 gen_helper_vfp_maxnums(tcg_res[pass], tcg_op1, tcg_op2, fpst);
8837                 break;
8838             case 0x5a: /* FADDP */
8839                 gen_helper_vfp_adds(tcg_res[pass], tcg_op1, tcg_op2, fpst);
8840                 break;
8841             case 0x5e: /* FMAXP */
8842                 gen_helper_vfp_maxs(tcg_res[pass], tcg_op1, tcg_op2, fpst);
8843                 break;
8844             case 0x78: /* FMINNMP */
8845                 gen_helper_vfp_minnums(tcg_res[pass], tcg_op1, tcg_op2, fpst);
8846                 break;
8847             case 0x7e: /* FMINP */
8848                 gen_helper_vfp_mins(tcg_res[pass], tcg_op1, tcg_op2, fpst);
8849                 break;
8850             default:
8851                 g_assert_not_reached();
8852             }
8853
8854             /* FP ops called directly, otherwise call now */
8855             if (genfn) {
8856                 genfn(tcg_res[pass], tcg_op1, tcg_op2);
8857             }
8858
8859             tcg_temp_free_i32(tcg_op1);
8860             tcg_temp_free_i32(tcg_op2);
8861         }
8862
8863         for (pass = 0; pass < maxpass; pass++) {
8864             write_vec_element_i32(s, tcg_res[pass], rd, pass, MO_32);
8865             tcg_temp_free_i32(tcg_res[pass]);
8866         }
8867         if (!is_q) {
8868             clear_vec_high(s, rd);
8869         }
8870     }
8871
8872     if (!TCGV_IS_UNUSED_PTR(fpst)) {
8873         tcg_temp_free_ptr(fpst);
8874     }
8875 }
8876
8877 /* Floating point op subgroup of C3.6.16. */
8878 static void disas_simd_3same_float(DisasContext *s, uint32_t insn)
8879 {
8880     /* For floating point ops, the U, size[1] and opcode bits
8881      * together indicate the operation. size[0] indicates single
8882      * or double.
8883      */
8884     int fpopcode = extract32(insn, 11, 5)
8885         | (extract32(insn, 23, 1) << 5)
8886         | (extract32(insn, 29, 1) << 6);
8887     int is_q = extract32(insn, 30, 1);
8888     int size = extract32(insn, 22, 1);
8889     int rm = extract32(insn, 16, 5);
8890     int rn = extract32(insn, 5, 5);
8891     int rd = extract32(insn, 0, 5);
8892
8893     int datasize = is_q ? 128 : 64;
8894     int esize = 32 << size;
8895     int elements = datasize / esize;
8896
8897     if (size == 1 && !is_q) {
8898         unallocated_encoding(s);
8899         return;
8900     }
8901
8902     switch (fpopcode) {
8903     case 0x58: /* FMAXNMP */
8904     case 0x5a: /* FADDP */
8905     case 0x5e: /* FMAXP */
8906     case 0x78: /* FMINNMP */
8907     case 0x7e: /* FMINP */
8908         if (size && !is_q) {
8909             unallocated_encoding(s);
8910             return;
8911         }
8912         handle_simd_3same_pair(s, is_q, 0, fpopcode, size ? MO_64 : MO_32,
8913                                rn, rm, rd);
8914         return;
8915     case 0x1b: /* FMULX */
8916     case 0x1f: /* FRECPS */
8917     case 0x3f: /* FRSQRTS */
8918     case 0x5d: /* FACGE */
8919     case 0x7d: /* FACGT */
8920     case 0x19: /* FMLA */
8921     case 0x39: /* FMLS */
8922     case 0x18: /* FMAXNM */
8923     case 0x1a: /* FADD */
8924     case 0x1c: /* FCMEQ */
8925     case 0x1e: /* FMAX */
8926     case 0x38: /* FMINNM */
8927     case 0x3a: /* FSUB */
8928     case 0x3e: /* FMIN */
8929     case 0x5b: /* FMUL */
8930     case 0x5c: /* FCMGE */
8931     case 0x5f: /* FDIV */
8932     case 0x7a: /* FABD */
8933     case 0x7c: /* FCMGT */
8934         if (!fp_access_check(s)) {
8935             return;
8936         }
8937
8938         handle_3same_float(s, size, elements, fpopcode, rd, rn, rm);
8939         return;
8940     default:
8941         unallocated_encoding(s);
8942         return;
8943     }
8944 }
8945
8946 /* Integer op subgroup of C3.6.16. */
8947 static void disas_simd_3same_int(DisasContext *s, uint32_t insn)
8948 {
8949     int is_q = extract32(insn, 30, 1);
8950     int u = extract32(insn, 29, 1);
8951     int size = extract32(insn, 22, 2);
8952     int opcode = extract32(insn, 11, 5);
8953     int rm = extract32(insn, 16, 5);
8954     int rn = extract32(insn, 5, 5);
8955     int rd = extract32(insn, 0, 5);
8956     int pass;
8957
8958     switch (opcode) {
8959     case 0x13: /* MUL, PMUL */
8960         if (u && size != 0) {
8961             unallocated_encoding(s);
8962             return;
8963         }
8964         /* fall through */
8965     case 0x0: /* SHADD, UHADD */
8966     case 0x2: /* SRHADD, URHADD */
8967     case 0x4: /* SHSUB, UHSUB */
8968     case 0xc: /* SMAX, UMAX */
8969     case 0xd: /* SMIN, UMIN */
8970     case 0xe: /* SABD, UABD */
8971     case 0xf: /* SABA, UABA */
8972     case 0x12: /* MLA, MLS */
8973         if (size == 3) {
8974             unallocated_encoding(s);
8975             return;
8976         }
8977         break;
8978     case 0x16: /* SQDMULH, SQRDMULH */
8979         if (size == 0 || size == 3) {
8980             unallocated_encoding(s);
8981             return;
8982         }
8983         break;
8984     default:
8985         if (size == 3 && !is_q) {
8986             unallocated_encoding(s);
8987             return;
8988         }
8989         break;
8990     }
8991
8992     if (!fp_access_check(s)) {
8993         return;
8994     }
8995
8996     if (size == 3) {
8997         for (pass = 0; pass < (is_q ? 2 : 1); pass++) {
8998             TCGv_i64 tcg_op1 = tcg_temp_new_i64();
8999             TCGv_i64 tcg_op2 = tcg_temp_new_i64();
9000             TCGv_i64 tcg_res = tcg_temp_new_i64();
9001
9002             read_vec_element(s, tcg_op1, rn, pass, MO_64);
9003             read_vec_element(s, tcg_op2, rm, pass, MO_64);
9004
9005             handle_3same_64(s, opcode, u, tcg_res, tcg_op1, tcg_op2);
9006
9007             write_vec_element(s, tcg_res, rd, pass, MO_64);
9008
9009             tcg_temp_free_i64(tcg_res);
9010             tcg_temp_free_i64(tcg_op1);
9011             tcg_temp_free_i64(tcg_op2);
9012         }
9013     } else {
9014         for (pass = 0; pass < (is_q ? 4 : 2); pass++) {
9015             TCGv_i32 tcg_op1 = tcg_temp_new_i32();
9016             TCGv_i32 tcg_op2 = tcg_temp_new_i32();
9017             TCGv_i32 tcg_res = tcg_temp_new_i32();
9018             NeonGenTwoOpFn *genfn = NULL;
9019             NeonGenTwoOpEnvFn *genenvfn = NULL;
9020
9021             read_vec_element_i32(s, tcg_op1, rn, pass, MO_32);
9022             read_vec_element_i32(s, tcg_op2, rm, pass, MO_32);
9023
9024             switch (opcode) {
9025             case 0x0: /* SHADD, UHADD */
9026             {
9027                 static NeonGenTwoOpFn * const fns[3][2] = {
9028                     { gen_helper_neon_hadd_s8, gen_helper_neon_hadd_u8 },
9029                     { gen_helper_neon_hadd_s16, gen_helper_neon_hadd_u16 },
9030                     { gen_helper_neon_hadd_s32, gen_helper_neon_hadd_u32 },
9031                 };
9032                 genfn = fns[size][u];
9033                 break;
9034             }
9035             case 0x1: /* SQADD, UQADD */
9036             {
9037                 static NeonGenTwoOpEnvFn * const fns[3][2] = {
9038                     { gen_helper_neon_qadd_s8, gen_helper_neon_qadd_u8 },
9039                     { gen_helper_neon_qadd_s16, gen_helper_neon_qadd_u16 },
9040                     { gen_helper_neon_qadd_s32, gen_helper_neon_qadd_u32 },
9041                 };
9042                 genenvfn = fns[size][u];
9043                 break;
9044             }
9045             case 0x2: /* SRHADD, URHADD */
9046             {
9047                 static NeonGenTwoOpFn * const fns[3][2] = {
9048                     { gen_helper_neon_rhadd_s8, gen_helper_neon_rhadd_u8 },
9049                     { gen_helper_neon_rhadd_s16, gen_helper_neon_rhadd_u16 },
9050                     { gen_helper_neon_rhadd_s32, gen_helper_neon_rhadd_u32 },
9051                 };
9052                 genfn = fns[size][u];
9053                 break;
9054             }
9055             case 0x4: /* SHSUB, UHSUB */
9056             {
9057                 static NeonGenTwoOpFn * const fns[3][2] = {
9058                     { gen_helper_neon_hsub_s8, gen_helper_neon_hsub_u8 },
9059                     { gen_helper_neon_hsub_s16, gen_helper_neon_hsub_u16 },
9060                     { gen_helper_neon_hsub_s32, gen_helper_neon_hsub_u32 },
9061                 };
9062                 genfn = fns[size][u];
9063                 break;
9064             }
9065             case 0x5: /* SQSUB, UQSUB */
9066             {
9067                 static NeonGenTwoOpEnvFn * const fns[3][2] = {
9068                     { gen_helper_neon_qsub_s8, gen_helper_neon_qsub_u8 },
9069                     { gen_helper_neon_qsub_s16, gen_helper_neon_qsub_u16 },
9070                     { gen_helper_neon_qsub_s32, gen_helper_neon_qsub_u32 },
9071                 };
9072                 genenvfn = fns[size][u];
9073                 break;
9074             }
9075             case 0x6: /* CMGT, CMHI */
9076             {
9077                 static NeonGenTwoOpFn * const fns[3][2] = {
9078                     { gen_helper_neon_cgt_s8, gen_helper_neon_cgt_u8 },
9079                     { gen_helper_neon_cgt_s16, gen_helper_neon_cgt_u16 },
9080                     { gen_helper_neon_cgt_s32, gen_helper_neon_cgt_u32 },
9081                 };
9082                 genfn = fns[size][u];
9083                 break;
9084             }
9085             case 0x7: /* CMGE, CMHS */
9086             {
9087                 static NeonGenTwoOpFn * const fns[3][2] = {
9088                     { gen_helper_neon_cge_s8, gen_helper_neon_cge_u8 },
9089                     { gen_helper_neon_cge_s16, gen_helper_neon_cge_u16 },
9090                     { gen_helper_neon_cge_s32, gen_helper_neon_cge_u32 },
9091                 };
9092                 genfn = fns[size][u];
9093                 break;
9094             }
9095             case 0x8: /* SSHL, USHL */
9096             {
9097                 static NeonGenTwoOpFn * const fns[3][2] = {
9098                     { gen_helper_neon_shl_s8, gen_helper_neon_shl_u8 },
9099                     { gen_helper_neon_shl_s16, gen_helper_neon_shl_u16 },
9100                     { gen_helper_neon_shl_s32, gen_helper_neon_shl_u32 },
9101                 };
9102                 genfn = fns[size][u];
9103                 break;
9104             }
9105             case 0x9: /* SQSHL, UQSHL */
9106             {
9107                 static NeonGenTwoOpEnvFn * const fns[3][2] = {
9108                     { gen_helper_neon_qshl_s8, gen_helper_neon_qshl_u8 },
9109                     { gen_helper_neon_qshl_s16, gen_helper_neon_qshl_u16 },
9110                     { gen_helper_neon_qshl_s32, gen_helper_neon_qshl_u32 },
9111                 };
9112                 genenvfn = fns[size][u];
9113                 break;
9114             }
9115             case 0xa: /* SRSHL, URSHL */
9116             {
9117                 static NeonGenTwoOpFn * const fns[3][2] = {
9118                     { gen_helper_neon_rshl_s8, gen_helper_neon_rshl_u8 },
9119                     { gen_helper_neon_rshl_s16, gen_helper_neon_rshl_u16 },
9120                     { gen_helper_neon_rshl_s32, gen_helper_neon_rshl_u32 },
9121                 };
9122                 genfn = fns[size][u];
9123                 break;
9124             }
9125             case 0xb: /* SQRSHL, UQRSHL */
9126             {
9127                 static NeonGenTwoOpEnvFn * const fns[3][2] = {
9128                     { gen_helper_neon_qrshl_s8, gen_helper_neon_qrshl_u8 },
9129                     { gen_helper_neon_qrshl_s16, gen_helper_neon_qrshl_u16 },
9130                     { gen_helper_neon_qrshl_s32, gen_helper_neon_qrshl_u32 },
9131                 };
9132                 genenvfn = fns[size][u];
9133                 break;
9134             }
9135             case 0xc: /* SMAX, UMAX */
9136             {
9137                 static NeonGenTwoOpFn * const fns[3][2] = {
9138                     { gen_helper_neon_max_s8, gen_helper_neon_max_u8 },
9139                     { gen_helper_neon_max_s16, gen_helper_neon_max_u16 },
9140                     { gen_max_s32, gen_max_u32 },
9141                 };
9142                 genfn = fns[size][u];
9143                 break;
9144             }
9145
9146             case 0xd: /* SMIN, UMIN */
9147             {
9148                 static NeonGenTwoOpFn * const fns[3][2] = {
9149                     { gen_helper_neon_min_s8, gen_helper_neon_min_u8 },
9150                     { gen_helper_neon_min_s16, gen_helper_neon_min_u16 },
9151                     { gen_min_s32, gen_min_u32 },
9152                 };
9153                 genfn = fns[size][u];
9154                 break;
9155             }
9156             case 0xe: /* SABD, UABD */
9157             case 0xf: /* SABA, UABA */
9158             {
9159                 static NeonGenTwoOpFn * const fns[3][2] = {
9160                     { gen_helper_neon_abd_s8, gen_helper_neon_abd_u8 },
9161                     { gen_helper_neon_abd_s16, gen_helper_neon_abd_u16 },
9162                     { gen_helper_neon_abd_s32, gen_helper_neon_abd_u32 },
9163                 };
9164                 genfn = fns[size][u];
9165                 break;
9166             }
9167             case 0x10: /* ADD, SUB */
9168             {
9169                 static NeonGenTwoOpFn * const fns[3][2] = {
9170                     { gen_helper_neon_add_u8, gen_helper_neon_sub_u8 },
9171                     { gen_helper_neon_add_u16, gen_helper_neon_sub_u16 },
9172                     { tcg_gen_add_i32, tcg_gen_sub_i32 },
9173                 };
9174                 genfn = fns[size][u];
9175                 break;
9176             }
9177             case 0x11: /* CMTST, CMEQ */
9178             {
9179                 static NeonGenTwoOpFn * const fns[3][2] = {
9180                     { gen_helper_neon_tst_u8, gen_helper_neon_ceq_u8 },
9181                     { gen_helper_neon_tst_u16, gen_helper_neon_ceq_u16 },
9182                     { gen_helper_neon_tst_u32, gen_helper_neon_ceq_u32 },
9183                 };
9184                 genfn = fns[size][u];
9185                 break;
9186             }
9187             case 0x13: /* MUL, PMUL */
9188                 if (u) {
9189                     /* PMUL */
9190                     assert(size == 0);
9191                     genfn = gen_helper_neon_mul_p8;
9192                     break;
9193                 }
9194                 /* fall through : MUL */
9195             case 0x12: /* MLA, MLS */
9196             {
9197                 static NeonGenTwoOpFn * const fns[3] = {
9198                     gen_helper_neon_mul_u8,
9199                     gen_helper_neon_mul_u16,
9200                     tcg_gen_mul_i32,
9201                 };
9202                 genfn = fns[size];
9203                 break;
9204             }
9205             case 0x16: /* SQDMULH, SQRDMULH */
9206             {
9207                 static NeonGenTwoOpEnvFn * const fns[2][2] = {
9208                     { gen_helper_neon_qdmulh_s16, gen_helper_neon_qrdmulh_s16 },
9209                     { gen_helper_neon_qdmulh_s32, gen_helper_neon_qrdmulh_s32 },
9210                 };
9211                 assert(size == 1 || size == 2);
9212                 genenvfn = fns[size - 1][u];
9213                 break;
9214             }
9215             default:
9216                 g_assert_not_reached();
9217             }
9218
9219             if (genenvfn) {
9220                 genenvfn(tcg_res, cpu_env, tcg_op1, tcg_op2);
9221             } else {
9222                 genfn(tcg_res, tcg_op1, tcg_op2);
9223             }
9224
9225             if (opcode == 0xf || opcode == 0x12) {
9226                 /* SABA, UABA, MLA, MLS: accumulating ops */
9227                 static NeonGenTwoOpFn * const fns[3][2] = {
9228                     { gen_helper_neon_add_u8, gen_helper_neon_sub_u8 },
9229                     { gen_helper_neon_add_u16, gen_helper_neon_sub_u16 },
9230                     { tcg_gen_add_i32, tcg_gen_sub_i32 },
9231                 };
9232                 bool is_sub = (opcode == 0x12 && u); /* MLS */
9233
9234                 genfn = fns[size][is_sub];
9235                 read_vec_element_i32(s, tcg_op1, rd, pass, MO_32);
9236                 genfn(tcg_res, tcg_op1, tcg_res);
9237             }
9238
9239             write_vec_element_i32(s, tcg_res, rd, pass, MO_32);
9240
9241             tcg_temp_free_i32(tcg_res);
9242             tcg_temp_free_i32(tcg_op1);
9243             tcg_temp_free_i32(tcg_op2);
9244         }
9245     }
9246
9247     if (!is_q) {
9248         clear_vec_high(s, rd);
9249     }
9250 }
9251
9252 /* C3.6.16 AdvSIMD three same
9253  *  31  30  29  28       24 23  22  21 20  16 15    11  10 9    5 4    0
9254  * +---+---+---+-----------+------+---+------+--------+---+------+------+
9255  * | 0 | Q | U | 0 1 1 1 0 | size | 1 |  Rm  | opcode | 1 |  Rn  |  Rd  |
9256  * +---+---+---+-----------+------+---+------+--------+---+------+------+
9257  */
9258 static void disas_simd_three_reg_same(DisasContext *s, uint32_t insn)
9259 {
9260     int opcode = extract32(insn, 11, 5);
9261
9262     switch (opcode) {
9263     case 0x3: /* logic ops */
9264         disas_simd_3same_logic(s, insn);
9265         break;
9266     case 0x17: /* ADDP */
9267     case 0x14: /* SMAXP, UMAXP */
9268     case 0x15: /* SMINP, UMINP */
9269     {
9270         /* Pairwise operations */
9271         int is_q = extract32(insn, 30, 1);
9272         int u = extract32(insn, 29, 1);
9273         int size = extract32(insn, 22, 2);
9274         int rm = extract32(insn, 16, 5);
9275         int rn = extract32(insn, 5, 5);
9276         int rd = extract32(insn, 0, 5);
9277         if (opcode == 0x17) {
9278             if (u || (size == 3 && !is_q)) {
9279                 unallocated_encoding(s);
9280                 return;
9281             }
9282         } else {
9283             if (size == 3) {
9284                 unallocated_encoding(s);
9285                 return;
9286             }
9287         }
9288         handle_simd_3same_pair(s, is_q, u, opcode, size, rn, rm, rd);
9289         break;
9290     }
9291     case 0x18 ... 0x31:
9292         /* floating point ops, sz[1] and U are part of opcode */
9293         disas_simd_3same_float(s, insn);
9294         break;
9295     default:
9296         disas_simd_3same_int(s, insn);
9297         break;
9298     }
9299 }
9300
9301 static void handle_2misc_widening(DisasContext *s, int opcode, bool is_q,
9302                                   int size, int rn, int rd)
9303 {
9304     /* Handle 2-reg-misc ops which are widening (so each size element
9305      * in the source becomes a 2*size element in the destination.
9306      * The only instruction like this is FCVTL.
9307      */
9308     int pass;
9309
9310     if (size == 3) {
9311         /* 32 -> 64 bit fp conversion */
9312         TCGv_i64 tcg_res[2];
9313         int srcelt = is_q ? 2 : 0;
9314
9315         for (pass = 0; pass < 2; pass++) {
9316             TCGv_i32 tcg_op = tcg_temp_new_i32();
9317             tcg_res[pass] = tcg_temp_new_i64();
9318
9319             read_vec_element_i32(s, tcg_op, rn, srcelt + pass, MO_32);
9320             gen_helper_vfp_fcvtds(tcg_res[pass], tcg_op, cpu_env);
9321             tcg_temp_free_i32(tcg_op);
9322         }
9323         for (pass = 0; pass < 2; pass++) {
9324             write_vec_element(s, tcg_res[pass], rd, pass, MO_64);
9325             tcg_temp_free_i64(tcg_res[pass]);
9326         }
9327     } else {
9328         /* 16 -> 32 bit fp conversion */
9329         int srcelt = is_q ? 4 : 0;
9330         TCGv_i32 tcg_res[4];
9331
9332         for (pass = 0; pass < 4; pass++) {
9333             tcg_res[pass] = tcg_temp_new_i32();
9334
9335             read_vec_element_i32(s, tcg_res[pass], rn, srcelt + pass, MO_16);
9336             gen_helper_vfp_fcvt_f16_to_f32(tcg_res[pass], tcg_res[pass],
9337                                            cpu_env);
9338         }
9339         for (pass = 0; pass < 4; pass++) {
9340             write_vec_element_i32(s, tcg_res[pass], rd, pass, MO_32);
9341             tcg_temp_free_i32(tcg_res[pass]);
9342         }
9343     }
9344 }
9345
9346 static void handle_rev(DisasContext *s, int opcode, bool u,
9347                        bool is_q, int size, int rn, int rd)
9348 {
9349     int op = (opcode << 1) | u;
9350     int opsz = op + size;
9351     int grp_size = 3 - opsz;
9352     int dsize = is_q ? 128 : 64;
9353     int i;
9354
9355     if (opsz >= 3) {
9356         unallocated_encoding(s);
9357         return;
9358     }
9359
9360     if (!fp_access_check(s)) {
9361         return;
9362     }
9363
9364     if (size == 0) {
9365         /* Special case bytes, use bswap op on each group of elements */
9366         int groups = dsize / (8 << grp_size);
9367
9368         for (i = 0; i < groups; i++) {
9369             TCGv_i64 tcg_tmp = tcg_temp_new_i64();
9370
9371             read_vec_element(s, tcg_tmp, rn, i, grp_size);
9372             switch (grp_size) {
9373             case MO_16:
9374                 tcg_gen_bswap16_i64(tcg_tmp, tcg_tmp);
9375                 break;
9376             case MO_32:
9377                 tcg_gen_bswap32_i64(tcg_tmp, tcg_tmp);
9378                 break;
9379             case MO_64:
9380                 tcg_gen_bswap64_i64(tcg_tmp, tcg_tmp);
9381                 break;
9382             default:
9383                 g_assert_not_reached();
9384             }
9385             write_vec_element(s, tcg_tmp, rd, i, grp_size);
9386             tcg_temp_free_i64(tcg_tmp);
9387         }
9388         if (!is_q) {
9389             clear_vec_high(s, rd);
9390         }
9391     } else {
9392         int revmask = (1 << grp_size) - 1;
9393         int esize = 8 << size;
9394         int elements = dsize / esize;
9395         TCGv_i64 tcg_rn = tcg_temp_new_i64();
9396         TCGv_i64 tcg_rd = tcg_const_i64(0);
9397         TCGv_i64 tcg_rd_hi = tcg_const_i64(0);
9398
9399         for (i = 0; i < elements; i++) {
9400             int e_rev = (i & 0xf) ^ revmask;
9401             int off = e_rev * esize;
9402             read_vec_element(s, tcg_rn, rn, i, size);
9403             if (off >= 64) {
9404                 tcg_gen_deposit_i64(tcg_rd_hi, tcg_rd_hi,
9405                                     tcg_rn, off - 64, esize);
9406             } else {
9407                 tcg_gen_deposit_i64(tcg_rd, tcg_rd, tcg_rn, off, esize);
9408             }
9409         }
9410         write_vec_element(s, tcg_rd, rd, 0, MO_64);
9411         write_vec_element(s, tcg_rd_hi, rd, 1, MO_64);
9412
9413         tcg_temp_free_i64(tcg_rd_hi);
9414         tcg_temp_free_i64(tcg_rd);
9415         tcg_temp_free_i64(tcg_rn);
9416     }
9417 }
9418
9419 static void handle_2misc_pairwise(DisasContext *s, int opcode, bool u,
9420                                   bool is_q, int size, int rn, int rd)
9421 {
9422     /* Implement the pairwise operations from 2-misc:
9423      * SADDLP, UADDLP, SADALP, UADALP.
9424      * These all add pairs of elements in the input to produce a
9425      * double-width result element in the output (possibly accumulating).
9426      */
9427     bool accum = (opcode == 0x6);
9428     int maxpass = is_q ? 2 : 1;
9429     int pass;
9430     TCGv_i64 tcg_res[2];
9431
9432     if (size == 2) {
9433         /* 32 + 32 -> 64 op */
9434         TCGMemOp memop = size + (u ? 0 : MO_SIGN);
9435
9436         for (pass = 0; pass < maxpass; pass++) {
9437             TCGv_i64 tcg_op1 = tcg_temp_new_i64();
9438             TCGv_i64 tcg_op2 = tcg_temp_new_i64();
9439
9440             tcg_res[pass] = tcg_temp_new_i64();
9441
9442             read_vec_element(s, tcg_op1, rn, pass * 2, memop);
9443             read_vec_element(s, tcg_op2, rn, pass * 2 + 1, memop);
9444             tcg_gen_add_i64(tcg_res[pass], tcg_op1, tcg_op2);
9445             if (accum) {
9446                 read_vec_element(s, tcg_op1, rd, pass, MO_64);
9447                 tcg_gen_add_i64(tcg_res[pass], tcg_res[pass], tcg_op1);
9448             }
9449
9450             tcg_temp_free_i64(tcg_op1);
9451             tcg_temp_free_i64(tcg_op2);
9452         }
9453     } else {
9454         for (pass = 0; pass < maxpass; pass++) {
9455             TCGv_i64 tcg_op = tcg_temp_new_i64();
9456             NeonGenOneOpFn *genfn;
9457             static NeonGenOneOpFn * const fns[2][2] = {
9458                 { gen_helper_neon_addlp_s8,  gen_helper_neon_addlp_u8 },
9459                 { gen_helper_neon_addlp_s16,  gen_helper_neon_addlp_u16 },
9460             };
9461
9462             genfn = fns[size][u];
9463
9464             tcg_res[pass] = tcg_temp_new_i64();
9465
9466             read_vec_element(s, tcg_op, rn, pass, MO_64);
9467             genfn(tcg_res[pass], tcg_op);
9468
9469             if (accum) {
9470                 read_vec_element(s, tcg_op, rd, pass, MO_64);
9471                 if (size == 0) {
9472                     gen_helper_neon_addl_u16(tcg_res[pass],
9473                                              tcg_res[pass], tcg_op);
9474                 } else {
9475                     gen_helper_neon_addl_u32(tcg_res[pass],
9476                                              tcg_res[pass], tcg_op);
9477                 }
9478             }
9479             tcg_temp_free_i64(tcg_op);
9480         }
9481     }
9482     if (!is_q) {
9483         tcg_res[1] = tcg_const_i64(0);
9484     }
9485     for (pass = 0; pass < 2; pass++) {
9486         write_vec_element(s, tcg_res[pass], rd, pass, MO_64);
9487         tcg_temp_free_i64(tcg_res[pass]);
9488     }
9489 }
9490
9491 static void handle_shll(DisasContext *s, bool is_q, int size, int rn, int rd)
9492 {
9493     /* Implement SHLL and SHLL2 */
9494     int pass;
9495     int part = is_q ? 2 : 0;
9496     TCGv_i64 tcg_res[2];
9497
9498     for (pass = 0; pass < 2; pass++) {
9499         static NeonGenWidenFn * const widenfns[3] = {
9500             gen_helper_neon_widen_u8,
9501             gen_helper_neon_widen_u16,
9502             tcg_gen_extu_i32_i64,
9503         };
9504         NeonGenWidenFn *widenfn = widenfns[size];
9505         TCGv_i32 tcg_op = tcg_temp_new_i32();
9506
9507         read_vec_element_i32(s, tcg_op, rn, part + pass, MO_32);
9508         tcg_res[pass] = tcg_temp_new_i64();
9509         widenfn(tcg_res[pass], tcg_op);
9510         tcg_gen_shli_i64(tcg_res[pass], tcg_res[pass], 8 << size);
9511
9512         tcg_temp_free_i32(tcg_op);
9513     }
9514
9515     for (pass = 0; pass < 2; pass++) {
9516         write_vec_element(s, tcg_res[pass], rd, pass, MO_64);
9517         tcg_temp_free_i64(tcg_res[pass]);
9518     }
9519 }
9520
9521 /* C3.6.17 AdvSIMD two reg misc
9522  *   31  30  29 28       24 23  22 21       17 16    12 11 10 9    5 4    0
9523  * +---+---+---+-----------+------+-----------+--------+-----+------+------+
9524  * | 0 | Q | U | 0 1 1 1 0 | size | 1 0 0 0 0 | opcode | 1 0 |  Rn  |  Rd  |
9525  * +---+---+---+-----------+------+-----------+--------+-----+------+------+
9526  */
9527 static void disas_simd_two_reg_misc(DisasContext *s, uint32_t insn)
9528 {
9529     int size = extract32(insn, 22, 2);
9530     int opcode = extract32(insn, 12, 5);
9531     bool u = extract32(insn, 29, 1);
9532     bool is_q = extract32(insn, 30, 1);
9533     int rn = extract32(insn, 5, 5);
9534     int rd = extract32(insn, 0, 5);
9535     bool need_fpstatus = false;
9536     bool need_rmode = false;
9537     int rmode = -1;
9538     TCGv_i32 tcg_rmode;
9539     TCGv_ptr tcg_fpstatus;
9540
9541     switch (opcode) {
9542     case 0x0: /* REV64, REV32 */
9543     case 0x1: /* REV16 */
9544         handle_rev(s, opcode, u, is_q, size, rn, rd);
9545         return;
9546     case 0x5: /* CNT, NOT, RBIT */
9547         if (u && size == 0) {
9548             /* NOT: adjust size so we can use the 64-bits-at-a-time loop. */
9549             size = 3;
9550             break;
9551         } else if (u && size == 1) {
9552             /* RBIT */
9553             break;
9554         } else if (!u && size == 0) {
9555             /* CNT */
9556             break;
9557         }
9558         unallocated_encoding(s);
9559         return;
9560     case 0x12: /* XTN, XTN2, SQXTUN, SQXTUN2 */
9561     case 0x14: /* SQXTN, SQXTN2, UQXTN, UQXTN2 */
9562         if (size == 3) {
9563             unallocated_encoding(s);
9564             return;
9565         }
9566         if (!fp_access_check(s)) {
9567             return;
9568         }
9569
9570         handle_2misc_narrow(s, false, opcode, u, is_q, size, rn, rd);
9571         return;
9572     case 0x4: /* CLS, CLZ */
9573         if (size == 3) {
9574             unallocated_encoding(s);
9575             return;
9576         }
9577         break;
9578     case 0x2: /* SADDLP, UADDLP */
9579     case 0x6: /* SADALP, UADALP */
9580         if (size == 3) {
9581             unallocated_encoding(s);
9582             return;
9583         }
9584         if (!fp_access_check(s)) {
9585             return;
9586         }
9587         handle_2misc_pairwise(s, opcode, u, is_q, size, rn, rd);
9588         return;
9589     case 0x13: /* SHLL, SHLL2 */
9590         if (u == 0 || size == 3) {
9591             unallocated_encoding(s);
9592             return;
9593         }
9594         if (!fp_access_check(s)) {
9595             return;
9596         }
9597         handle_shll(s, is_q, size, rn, rd);
9598         return;
9599     case 0xa: /* CMLT */
9600         if (u == 1) {
9601             unallocated_encoding(s);
9602             return;
9603         }
9604         /* fall through */
9605     case 0x8: /* CMGT, CMGE */
9606     case 0x9: /* CMEQ, CMLE */
9607     case 0xb: /* ABS, NEG */
9608         if (size == 3 && !is_q) {
9609             unallocated_encoding(s);
9610             return;
9611         }
9612         break;
9613     case 0x3: /* SUQADD, USQADD */
9614         if (size == 3 && !is_q) {
9615             unallocated_encoding(s);
9616             return;
9617         }
9618         if (!fp_access_check(s)) {
9619             return;
9620         }
9621         handle_2misc_satacc(s, false, u, is_q, size, rn, rd);
9622         return;
9623     case 0x7: /* SQABS, SQNEG */
9624         if (size == 3 && !is_q) {
9625             unallocated_encoding(s);
9626             return;
9627         }
9628         break;
9629     case 0xc ... 0xf:
9630     case 0x16 ... 0x1d:
9631     case 0x1f:
9632     {
9633         /* Floating point: U, size[1] and opcode indicate operation;
9634          * size[0] indicates single or double precision.
9635          */
9636         int is_double = extract32(size, 0, 1);
9637         opcode |= (extract32(size, 1, 1) << 5) | (u << 6);
9638         size = is_double ? 3 : 2;
9639         switch (opcode) {
9640         case 0x2f: /* FABS */
9641         case 0x6f: /* FNEG */
9642             if (size == 3 && !is_q) {
9643                 unallocated_encoding(s);
9644                 return;
9645             }
9646             break;
9647         case 0x1d: /* SCVTF */
9648         case 0x5d: /* UCVTF */
9649         {
9650             bool is_signed = (opcode == 0x1d) ? true : false;
9651             int elements = is_double ? 2 : is_q ? 4 : 2;
9652             if (is_double && !is_q) {
9653                 unallocated_encoding(s);
9654                 return;
9655             }
9656             if (!fp_access_check(s)) {
9657                 return;
9658             }
9659             handle_simd_intfp_conv(s, rd, rn, elements, is_signed, 0, size);
9660             return;
9661         }
9662         case 0x2c: /* FCMGT (zero) */
9663         case 0x2d: /* FCMEQ (zero) */
9664         case 0x2e: /* FCMLT (zero) */
9665         case 0x6c: /* FCMGE (zero) */
9666         case 0x6d: /* FCMLE (zero) */
9667             if (size == 3 && !is_q) {
9668                 unallocated_encoding(s);
9669                 return;
9670             }
9671             handle_2misc_fcmp_zero(s, opcode, false, u, is_q, size, rn, rd);
9672             return;
9673         case 0x7f: /* FSQRT */
9674             if (size == 3 && !is_q) {
9675                 unallocated_encoding(s);
9676                 return;
9677             }
9678             break;
9679         case 0x1a: /* FCVTNS */
9680         case 0x1b: /* FCVTMS */
9681         case 0x3a: /* FCVTPS */
9682         case 0x3b: /* FCVTZS */
9683         case 0x5a: /* FCVTNU */
9684         case 0x5b: /* FCVTMU */
9685         case 0x7a: /* FCVTPU */
9686         case 0x7b: /* FCVTZU */
9687             need_fpstatus = true;
9688             need_rmode = true;
9689             rmode = extract32(opcode, 5, 1) | (extract32(opcode, 0, 1) << 1);
9690             if (size == 3 && !is_q) {
9691                 unallocated_encoding(s);
9692                 return;
9693             }
9694             break;
9695         case 0x5c: /* FCVTAU */
9696         case 0x1c: /* FCVTAS */
9697             need_fpstatus = true;
9698             need_rmode = true;
9699             rmode = FPROUNDING_TIEAWAY;
9700             if (size == 3 && !is_q) {
9701                 unallocated_encoding(s);
9702                 return;
9703             }
9704             break;
9705         case 0x3c: /* URECPE */
9706             if (size == 3) {
9707                 unallocated_encoding(s);
9708                 return;
9709             }
9710             /* fall through */
9711         case 0x3d: /* FRECPE */
9712         case 0x7d: /* FRSQRTE */
9713             if (size == 3 && !is_q) {
9714                 unallocated_encoding(s);
9715                 return;
9716             }
9717             if (!fp_access_check(s)) {
9718                 return;
9719             }
9720             handle_2misc_reciprocal(s, opcode, false, u, is_q, size, rn, rd);
9721             return;
9722         case 0x56: /* FCVTXN, FCVTXN2 */
9723             if (size == 2) {
9724                 unallocated_encoding(s);
9725                 return;
9726             }
9727             /* fall through */
9728         case 0x16: /* FCVTN, FCVTN2 */
9729             /* handle_2misc_narrow does a 2*size -> size operation, but these
9730              * instructions encode the source size rather than dest size.
9731              */
9732             if (!fp_access_check(s)) {
9733                 return;
9734             }
9735             handle_2misc_narrow(s, false, opcode, 0, is_q, size - 1, rn, rd);
9736             return;
9737         case 0x17: /* FCVTL, FCVTL2 */
9738             if (!fp_access_check(s)) {
9739                 return;
9740             }
9741             handle_2misc_widening(s, opcode, is_q, size, rn, rd);
9742             return;
9743         case 0x18: /* FRINTN */
9744         case 0x19: /* FRINTM */
9745         case 0x38: /* FRINTP */
9746         case 0x39: /* FRINTZ */
9747             need_rmode = true;
9748             rmode = extract32(opcode, 5, 1) | (extract32(opcode, 0, 1) << 1);
9749             /* fall through */
9750         case 0x59: /* FRINTX */
9751         case 0x79: /* FRINTI */
9752             need_fpstatus = true;
9753             if (size == 3 && !is_q) {
9754                 unallocated_encoding(s);
9755                 return;
9756             }
9757             break;
9758         case 0x58: /* FRINTA */
9759             need_rmode = true;
9760             rmode = FPROUNDING_TIEAWAY;
9761             need_fpstatus = true;
9762             if (size == 3 && !is_q) {
9763                 unallocated_encoding(s);
9764                 return;
9765             }
9766             break;
9767         case 0x7c: /* URSQRTE */
9768             if (size == 3) {
9769                 unallocated_encoding(s);
9770                 return;
9771             }
9772             need_fpstatus = true;
9773             break;
9774         default:
9775             unallocated_encoding(s);
9776             return;
9777         }
9778         break;
9779     }
9780     default:
9781         unallocated_encoding(s);
9782         return;
9783     }
9784
9785     if (!fp_access_check(s)) {
9786         return;
9787     }
9788
9789     if (need_fpstatus) {
9790         tcg_fpstatus = get_fpstatus_ptr();
9791     } else {
9792         TCGV_UNUSED_PTR(tcg_fpstatus);
9793     }
9794     if (need_rmode) {
9795         tcg_rmode = tcg_const_i32(arm_rmode_to_sf(rmode));
9796         gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
9797     } else {
9798         TCGV_UNUSED_I32(tcg_rmode);
9799     }
9800
9801     if (size == 3) {
9802         /* All 64-bit element operations can be shared with scalar 2misc */
9803         int pass;
9804
9805         for (pass = 0; pass < (is_q ? 2 : 1); pass++) {
9806             TCGv_i64 tcg_op = tcg_temp_new_i64();
9807             TCGv_i64 tcg_res = tcg_temp_new_i64();
9808
9809             read_vec_element(s, tcg_op, rn, pass, MO_64);
9810
9811             handle_2misc_64(s, opcode, u, tcg_res, tcg_op,
9812                             tcg_rmode, tcg_fpstatus);
9813
9814             write_vec_element(s, tcg_res, rd, pass, MO_64);
9815
9816             tcg_temp_free_i64(tcg_res);
9817             tcg_temp_free_i64(tcg_op);
9818         }
9819     } else {
9820         int pass;
9821
9822         for (pass = 0; pass < (is_q ? 4 : 2); pass++) {
9823             TCGv_i32 tcg_op = tcg_temp_new_i32();
9824             TCGv_i32 tcg_res = tcg_temp_new_i32();
9825             TCGCond cond;
9826
9827             read_vec_element_i32(s, tcg_op, rn, pass, MO_32);
9828
9829             if (size == 2) {
9830                 /* Special cases for 32 bit elements */
9831                 switch (opcode) {
9832                 case 0xa: /* CMLT */
9833                     /* 32 bit integer comparison against zero, result is
9834                      * test ? (2^32 - 1) : 0. We implement via setcond(test)
9835                      * and inverting.
9836                      */
9837                     cond = TCG_COND_LT;
9838                 do_cmop:
9839                     tcg_gen_setcondi_i32(cond, tcg_res, tcg_op, 0);
9840                     tcg_gen_neg_i32(tcg_res, tcg_res);
9841                     break;
9842                 case 0x8: /* CMGT, CMGE */
9843                     cond = u ? TCG_COND_GE : TCG_COND_GT;
9844                     goto do_cmop;
9845                 case 0x9: /* CMEQ, CMLE */
9846                     cond = u ? TCG_COND_LE : TCG_COND_EQ;
9847                     goto do_cmop;
9848                 case 0x4: /* CLS */
9849                     if (u) {
9850                         gen_helper_clz32(tcg_res, tcg_op);
9851                     } else {
9852                         gen_helper_cls32(tcg_res, tcg_op);
9853                     }
9854                     break;
9855                 case 0x7: /* SQABS, SQNEG */
9856                     if (u) {
9857                         gen_helper_neon_qneg_s32(tcg_res, cpu_env, tcg_op);
9858                     } else {
9859                         gen_helper_neon_qabs_s32(tcg_res, cpu_env, tcg_op);
9860                     }
9861                     break;
9862                 case 0xb: /* ABS, NEG */
9863                     if (u) {
9864                         tcg_gen_neg_i32(tcg_res, tcg_op);
9865                     } else {
9866                         TCGv_i32 tcg_zero = tcg_const_i32(0);
9867                         tcg_gen_neg_i32(tcg_res, tcg_op);
9868                         tcg_gen_movcond_i32(TCG_COND_GT, tcg_res, tcg_op,
9869                                             tcg_zero, tcg_op, tcg_res);
9870                         tcg_temp_free_i32(tcg_zero);
9871                     }
9872                     break;
9873                 case 0x2f: /* FABS */
9874                     gen_helper_vfp_abss(tcg_res, tcg_op);
9875                     break;
9876                 case 0x6f: /* FNEG */
9877                     gen_helper_vfp_negs(tcg_res, tcg_op);
9878                     break;
9879                 case 0x7f: /* FSQRT */
9880                     gen_helper_vfp_sqrts(tcg_res, tcg_op, cpu_env);
9881                     break;
9882                 case 0x1a: /* FCVTNS */
9883                 case 0x1b: /* FCVTMS */
9884                 case 0x1c: /* FCVTAS */
9885                 case 0x3a: /* FCVTPS */
9886                 case 0x3b: /* FCVTZS */
9887                 {
9888                     TCGv_i32 tcg_shift = tcg_const_i32(0);
9889                     gen_helper_vfp_tosls(tcg_res, tcg_op,
9890                                          tcg_shift, tcg_fpstatus);
9891                     tcg_temp_free_i32(tcg_shift);
9892                     break;
9893                 }
9894                 case 0x5a: /* FCVTNU */
9895                 case 0x5b: /* FCVTMU */
9896                 case 0x5c: /* FCVTAU */
9897                 case 0x7a: /* FCVTPU */
9898                 case 0x7b: /* FCVTZU */
9899                 {
9900                     TCGv_i32 tcg_shift = tcg_const_i32(0);
9901                     gen_helper_vfp_touls(tcg_res, tcg_op,
9902                                          tcg_shift, tcg_fpstatus);
9903                     tcg_temp_free_i32(tcg_shift);
9904                     break;
9905                 }
9906                 case 0x18: /* FRINTN */
9907                 case 0x19: /* FRINTM */
9908                 case 0x38: /* FRINTP */
9909                 case 0x39: /* FRINTZ */
9910                 case 0x58: /* FRINTA */
9911                 case 0x79: /* FRINTI */
9912                     gen_helper_rints(tcg_res, tcg_op, tcg_fpstatus);
9913                     break;
9914                 case 0x59: /* FRINTX */
9915                     gen_helper_rints_exact(tcg_res, tcg_op, tcg_fpstatus);
9916                     break;
9917                 case 0x7c: /* URSQRTE */
9918                     gen_helper_rsqrte_u32(tcg_res, tcg_op, tcg_fpstatus);
9919                     break;
9920                 default:
9921                     g_assert_not_reached();
9922                 }
9923             } else {
9924                 /* Use helpers for 8 and 16 bit elements */
9925                 switch (opcode) {
9926                 case 0x5: /* CNT, RBIT */
9927                     /* For these two insns size is part of the opcode specifier
9928                      * (handled earlier); they always operate on byte elements.
9929                      */
9930                     if (u) {
9931                         gen_helper_neon_rbit_u8(tcg_res, tcg_op);
9932                     } else {
9933                         gen_helper_neon_cnt_u8(tcg_res, tcg_op);
9934                     }
9935                     break;
9936                 case 0x7: /* SQABS, SQNEG */
9937                 {
9938                     NeonGenOneOpEnvFn *genfn;
9939                     static NeonGenOneOpEnvFn * const fns[2][2] = {
9940                         { gen_helper_neon_qabs_s8, gen_helper_neon_qneg_s8 },
9941                         { gen_helper_neon_qabs_s16, gen_helper_neon_qneg_s16 },
9942                     };
9943                     genfn = fns[size][u];
9944                     genfn(tcg_res, cpu_env, tcg_op);
9945                     break;
9946                 }
9947                 case 0x8: /* CMGT, CMGE */
9948                 case 0x9: /* CMEQ, CMLE */
9949                 case 0xa: /* CMLT */
9950                 {
9951                     static NeonGenTwoOpFn * const fns[3][2] = {
9952                         { gen_helper_neon_cgt_s8, gen_helper_neon_cgt_s16 },
9953                         { gen_helper_neon_cge_s8, gen_helper_neon_cge_s16 },
9954                         { gen_helper_neon_ceq_u8, gen_helper_neon_ceq_u16 },
9955                     };
9956                     NeonGenTwoOpFn *genfn;
9957                     int comp;
9958                     bool reverse;
9959                     TCGv_i32 tcg_zero = tcg_const_i32(0);
9960
9961                     /* comp = index into [CMGT, CMGE, CMEQ, CMLE, CMLT] */
9962                     comp = (opcode - 0x8) * 2 + u;
9963                     /* ...but LE, LT are implemented as reverse GE, GT */
9964                     reverse = (comp > 2);
9965                     if (reverse) {
9966                         comp = 4 - comp;
9967                     }
9968                     genfn = fns[comp][size];
9969                     if (reverse) {
9970                         genfn(tcg_res, tcg_zero, tcg_op);
9971                     } else {
9972                         genfn(tcg_res, tcg_op, tcg_zero);
9973                     }
9974                     tcg_temp_free_i32(tcg_zero);
9975                     break;
9976                 }
9977                 case 0xb: /* ABS, NEG */
9978                     if (u) {
9979                         TCGv_i32 tcg_zero = tcg_const_i32(0);
9980                         if (size) {
9981                             gen_helper_neon_sub_u16(tcg_res, tcg_zero, tcg_op);
9982                         } else {
9983                             gen_helper_neon_sub_u8(tcg_res, tcg_zero, tcg_op);
9984                         }
9985                         tcg_temp_free_i32(tcg_zero);
9986                     } else {
9987                         if (size) {
9988                             gen_helper_neon_abs_s16(tcg_res, tcg_op);
9989                         } else {
9990                             gen_helper_neon_abs_s8(tcg_res, tcg_op);
9991                         }
9992                     }
9993                     break;
9994                 case 0x4: /* CLS, CLZ */
9995                     if (u) {
9996                         if (size == 0) {
9997                             gen_helper_neon_clz_u8(tcg_res, tcg_op);
9998                         } else {
9999                             gen_helper_neon_clz_u16(tcg_res, tcg_op);
10000                         }
10001                     } else {
10002                         if (size == 0) {
10003                             gen_helper_neon_cls_s8(tcg_res, tcg_op);
10004                         } else {
10005                             gen_helper_neon_cls_s16(tcg_res, tcg_op);
10006                         }
10007                     }
10008                     break;
10009                 default:
10010                     g_assert_not_reached();
10011                 }
10012             }
10013
10014             write_vec_element_i32(s, tcg_res, rd, pass, MO_32);
10015
10016             tcg_temp_free_i32(tcg_res);
10017             tcg_temp_free_i32(tcg_op);
10018         }
10019     }
10020     if (!is_q) {
10021         clear_vec_high(s, rd);
10022     }
10023
10024     if (need_rmode) {
10025         gen_helper_set_rmode(tcg_rmode, tcg_rmode, cpu_env);
10026         tcg_temp_free_i32(tcg_rmode);
10027     }
10028     if (need_fpstatus) {
10029         tcg_temp_free_ptr(tcg_fpstatus);
10030     }
10031 }
10032
10033 /* C3.6.13 AdvSIMD scalar x indexed element
10034  *  31 30  29 28       24 23  22 21  20  19  16 15 12  11  10 9    5 4    0
10035  * +-----+---+-----------+------+---+---+------+-----+---+---+------+------+
10036  * | 0 1 | U | 1 1 1 1 1 | size | L | M |  Rm  | opc | H | 0 |  Rn  |  Rd  |
10037  * +-----+---+-----------+------+---+---+------+-----+---+---+------+------+
10038  * C3.6.18 AdvSIMD vector x indexed element
10039  *   31  30  29 28       24 23  22 21  20  19  16 15 12  11  10 9    5 4    0
10040  * +---+---+---+-----------+------+---+---+------+-----+---+---+------+------+
10041  * | 0 | Q | U | 0 1 1 1 1 | size | L | M |  Rm  | opc | H | 0 |  Rn  |  Rd  |
10042  * +---+---+---+-----------+------+---+---+------+-----+---+---+------+------+
10043  */
10044 static void disas_simd_indexed(DisasContext *s, uint32_t insn)
10045 {
10046     /* This encoding has two kinds of instruction:
10047      *  normal, where we perform elt x idxelt => elt for each
10048      *     element in the vector
10049      *  long, where we perform elt x idxelt and generate a result of
10050      *     double the width of the input element
10051      * The long ops have a 'part' specifier (ie come in INSN, INSN2 pairs).
10052      */
10053     bool is_scalar = extract32(insn, 28, 1);
10054     bool is_q = extract32(insn, 30, 1);
10055     bool u = extract32(insn, 29, 1);
10056     int size = extract32(insn, 22, 2);
10057     int l = extract32(insn, 21, 1);
10058     int m = extract32(insn, 20, 1);
10059     /* Note that the Rm field here is only 4 bits, not 5 as it usually is */
10060     int rm = extract32(insn, 16, 4);
10061     int opcode = extract32(insn, 12, 4);
10062     int h = extract32(insn, 11, 1);
10063     int rn = extract32(insn, 5, 5);
10064     int rd = extract32(insn, 0, 5);
10065     bool is_long = false;
10066     bool is_fp = false;
10067     int index;
10068     TCGv_ptr fpst;
10069
10070     switch (opcode) {
10071     case 0x0: /* MLA */
10072     case 0x4: /* MLS */
10073         if (!u || is_scalar) {
10074             unallocated_encoding(s);
10075             return;
10076         }
10077         break;
10078     case 0x2: /* SMLAL, SMLAL2, UMLAL, UMLAL2 */
10079     case 0x6: /* SMLSL, SMLSL2, UMLSL, UMLSL2 */
10080     case 0xa: /* SMULL, SMULL2, UMULL, UMULL2 */
10081         if (is_scalar) {
10082             unallocated_encoding(s);
10083             return;
10084         }
10085         is_long = true;
10086         break;
10087     case 0x3: /* SQDMLAL, SQDMLAL2 */
10088     case 0x7: /* SQDMLSL, SQDMLSL2 */
10089     case 0xb: /* SQDMULL, SQDMULL2 */
10090         is_long = true;
10091         /* fall through */
10092     case 0xc: /* SQDMULH */
10093     case 0xd: /* SQRDMULH */
10094         if (u) {
10095             unallocated_encoding(s);
10096             return;
10097         }
10098         break;
10099     case 0x8: /* MUL */
10100         if (u || is_scalar) {
10101             unallocated_encoding(s);
10102             return;
10103         }
10104         break;
10105     case 0x1: /* FMLA */
10106     case 0x5: /* FMLS */
10107         if (u) {
10108             unallocated_encoding(s);
10109             return;
10110         }
10111         /* fall through */
10112     case 0x9: /* FMUL, FMULX */
10113         if (!extract32(size, 1, 1)) {
10114             unallocated_encoding(s);
10115             return;
10116         }
10117         is_fp = true;
10118         break;
10119     default:
10120         unallocated_encoding(s);
10121         return;
10122     }
10123
10124     if (is_fp) {
10125         /* low bit of size indicates single/double */
10126         size = extract32(size, 0, 1) ? 3 : 2;
10127         if (size == 2) {
10128             index = h << 1 | l;
10129         } else {
10130             if (l || !is_q) {
10131                 unallocated_encoding(s);
10132                 return;
10133             }
10134             index = h;
10135         }
10136         rm |= (m << 4);
10137     } else {
10138         switch (size) {
10139         case 1:
10140             index = h << 2 | l << 1 | m;
10141             break;
10142         case 2:
10143             index = h << 1 | l;
10144             rm |= (m << 4);
10145             break;
10146         default:
10147             unallocated_encoding(s);
10148             return;
10149         }
10150     }
10151
10152     if (!fp_access_check(s)) {
10153         return;
10154     }
10155
10156     if (is_fp) {
10157         fpst = get_fpstatus_ptr();
10158     } else {
10159         TCGV_UNUSED_PTR(fpst);
10160     }
10161
10162     if (size == 3) {
10163         TCGv_i64 tcg_idx = tcg_temp_new_i64();
10164         int pass;
10165
10166         assert(is_fp && is_q && !is_long);
10167
10168         read_vec_element(s, tcg_idx, rm, index, MO_64);
10169
10170         for (pass = 0; pass < (is_scalar ? 1 : 2); pass++) {
10171             TCGv_i64 tcg_op = tcg_temp_new_i64();
10172             TCGv_i64 tcg_res = tcg_temp_new_i64();
10173
10174             read_vec_element(s, tcg_op, rn, pass, MO_64);
10175
10176             switch (opcode) {
10177             case 0x5: /* FMLS */
10178                 /* As usual for ARM, separate negation for fused multiply-add */
10179                 gen_helper_vfp_negd(tcg_op, tcg_op);
10180                 /* fall through */
10181             case 0x1: /* FMLA */
10182                 read_vec_element(s, tcg_res, rd, pass, MO_64);
10183                 gen_helper_vfp_muladdd(tcg_res, tcg_op, tcg_idx, tcg_res, fpst);
10184                 break;
10185             case 0x9: /* FMUL, FMULX */
10186                 if (u) {
10187                     gen_helper_vfp_mulxd(tcg_res, tcg_op, tcg_idx, fpst);
10188                 } else {
10189                     gen_helper_vfp_muld(tcg_res, tcg_op, tcg_idx, fpst);
10190                 }
10191                 break;
10192             default:
10193                 g_assert_not_reached();
10194             }
10195
10196             write_vec_element(s, tcg_res, rd, pass, MO_64);
10197             tcg_temp_free_i64(tcg_op);
10198             tcg_temp_free_i64(tcg_res);
10199         }
10200
10201         if (is_scalar) {
10202             clear_vec_high(s, rd);
10203         }
10204
10205         tcg_temp_free_i64(tcg_idx);
10206     } else if (!is_long) {
10207         /* 32 bit floating point, or 16 or 32 bit integer.
10208          * For the 16 bit scalar case we use the usual Neon helpers and
10209          * rely on the fact that 0 op 0 == 0 with no side effects.
10210          */
10211         TCGv_i32 tcg_idx = tcg_temp_new_i32();
10212         int pass, maxpasses;
10213
10214         if (is_scalar) {
10215             maxpasses = 1;
10216         } else {
10217             maxpasses = is_q ? 4 : 2;
10218         }
10219
10220         read_vec_element_i32(s, tcg_idx, rm, index, size);
10221
10222         if (size == 1 && !is_scalar) {
10223             /* The simplest way to handle the 16x16 indexed ops is to duplicate
10224              * the index into both halves of the 32 bit tcg_idx and then use
10225              * the usual Neon helpers.
10226              */
10227             tcg_gen_deposit_i32(tcg_idx, tcg_idx, tcg_idx, 16, 16);
10228         }
10229
10230         for (pass = 0; pass < maxpasses; pass++) {
10231             TCGv_i32 tcg_op = tcg_temp_new_i32();
10232             TCGv_i32 tcg_res = tcg_temp_new_i32();
10233
10234             read_vec_element_i32(s, tcg_op, rn, pass, is_scalar ? size : MO_32);
10235
10236             switch (opcode) {
10237             case 0x0: /* MLA */
10238             case 0x4: /* MLS */
10239             case 0x8: /* MUL */
10240             {
10241                 static NeonGenTwoOpFn * const fns[2][2] = {
10242                     { gen_helper_neon_add_u16, gen_helper_neon_sub_u16 },
10243                     { tcg_gen_add_i32, tcg_gen_sub_i32 },
10244                 };
10245                 NeonGenTwoOpFn *genfn;
10246                 bool is_sub = opcode == 0x4;
10247
10248                 if (size == 1) {
10249                     gen_helper_neon_mul_u16(tcg_res, tcg_op, tcg_idx);
10250                 } else {
10251                     tcg_gen_mul_i32(tcg_res, tcg_op, tcg_idx);
10252                 }
10253                 if (opcode == 0x8) {
10254                     break;
10255                 }
10256                 read_vec_element_i32(s, tcg_op, rd, pass, MO_32);
10257                 genfn = fns[size - 1][is_sub];
10258                 genfn(tcg_res, tcg_op, tcg_res);
10259                 break;
10260             }
10261             case 0x5: /* FMLS */
10262                 /* As usual for ARM, separate negation for fused multiply-add */
10263                 gen_helper_vfp_negs(tcg_op, tcg_op);
10264                 /* fall through */
10265             case 0x1: /* FMLA */
10266                 read_vec_element_i32(s, tcg_res, rd, pass, MO_32);
10267                 gen_helper_vfp_muladds(tcg_res, tcg_op, tcg_idx, tcg_res, fpst);
10268                 break;
10269             case 0x9: /* FMUL, FMULX */
10270                 if (u) {
10271                     gen_helper_vfp_mulxs(tcg_res, tcg_op, tcg_idx, fpst);
10272                 } else {
10273                     gen_helper_vfp_muls(tcg_res, tcg_op, tcg_idx, fpst);
10274                 }
10275                 break;
10276             case 0xc: /* SQDMULH */
10277                 if (size == 1) {
10278                     gen_helper_neon_qdmulh_s16(tcg_res, cpu_env,
10279                                                tcg_op, tcg_idx);
10280                 } else {
10281                     gen_helper_neon_qdmulh_s32(tcg_res, cpu_env,
10282                                                tcg_op, tcg_idx);
10283                 }
10284                 break;
10285             case 0xd: /* SQRDMULH */
10286                 if (size == 1) {
10287                     gen_helper_neon_qrdmulh_s16(tcg_res, cpu_env,
10288                                                 tcg_op, tcg_idx);
10289                 } else {
10290                     gen_helper_neon_qrdmulh_s32(tcg_res, cpu_env,
10291                                                 tcg_op, tcg_idx);
10292                 }
10293                 break;
10294             default:
10295                 g_assert_not_reached();
10296             }
10297
10298             if (is_scalar) {
10299                 write_fp_sreg(s, rd, tcg_res);
10300             } else {
10301                 write_vec_element_i32(s, tcg_res, rd, pass, MO_32);
10302             }
10303
10304             tcg_temp_free_i32(tcg_op);
10305             tcg_temp_free_i32(tcg_res);
10306         }
10307
10308         tcg_temp_free_i32(tcg_idx);
10309
10310         if (!is_q) {
10311             clear_vec_high(s, rd);
10312         }
10313     } else {
10314         /* long ops: 16x16->32 or 32x32->64 */
10315         TCGv_i64 tcg_res[2];
10316         int pass;
10317         bool satop = extract32(opcode, 0, 1);
10318         TCGMemOp memop = MO_32;
10319
10320         if (satop || !u) {
10321             memop |= MO_SIGN;
10322         }
10323
10324         if (size == 2) {
10325             TCGv_i64 tcg_idx = tcg_temp_new_i64();
10326
10327             read_vec_element(s, tcg_idx, rm, index, memop);
10328
10329             for (pass = 0; pass < (is_scalar ? 1 : 2); pass++) {
10330                 TCGv_i64 tcg_op = tcg_temp_new_i64();
10331                 TCGv_i64 tcg_passres;
10332                 int passelt;
10333
10334                 if (is_scalar) {
10335                     passelt = 0;
10336                 } else {
10337                     passelt = pass + (is_q * 2);
10338                 }
10339
10340                 read_vec_element(s, tcg_op, rn, passelt, memop);
10341
10342                 tcg_res[pass] = tcg_temp_new_i64();
10343
10344                 if (opcode == 0xa || opcode == 0xb) {
10345                     /* Non-accumulating ops */
10346                     tcg_passres = tcg_res[pass];
10347                 } else {
10348                     tcg_passres = tcg_temp_new_i64();
10349                 }
10350
10351                 tcg_gen_mul_i64(tcg_passres, tcg_op, tcg_idx);
10352                 tcg_temp_free_i64(tcg_op);
10353
10354                 if (satop) {
10355                     /* saturating, doubling */
10356                     gen_helper_neon_addl_saturate_s64(tcg_passres, cpu_env,
10357                                                       tcg_passres, tcg_passres);
10358                 }
10359
10360                 if (opcode == 0xa || opcode == 0xb) {
10361                     continue;
10362                 }
10363
10364                 /* Accumulating op: handle accumulate step */
10365                 read_vec_element(s, tcg_res[pass], rd, pass, MO_64);
10366
10367                 switch (opcode) {
10368                 case 0x2: /* SMLAL, SMLAL2, UMLAL, UMLAL2 */
10369                     tcg_gen_add_i64(tcg_res[pass], tcg_res[pass], tcg_passres);
10370                     break;
10371                 case 0x6: /* SMLSL, SMLSL2, UMLSL, UMLSL2 */
10372                     tcg_gen_sub_i64(tcg_res[pass], tcg_res[pass], tcg_passres);
10373                     break;
10374                 case 0x7: /* SQDMLSL, SQDMLSL2 */
10375                     tcg_gen_neg_i64(tcg_passres, tcg_passres);
10376                     /* fall through */
10377                 case 0x3: /* SQDMLAL, SQDMLAL2 */
10378                     gen_helper_neon_addl_saturate_s64(tcg_res[pass], cpu_env,
10379                                                       tcg_res[pass],
10380                                                       tcg_passres);
10381                     break;
10382                 default:
10383                     g_assert_not_reached();
10384                 }
10385                 tcg_temp_free_i64(tcg_passres);
10386             }
10387             tcg_temp_free_i64(tcg_idx);
10388
10389             if (is_scalar) {
10390                 clear_vec_high(s, rd);
10391             }
10392         } else {
10393             TCGv_i32 tcg_idx = tcg_temp_new_i32();
10394
10395             assert(size == 1);
10396             read_vec_element_i32(s, tcg_idx, rm, index, size);
10397
10398             if (!is_scalar) {
10399                 /* The simplest way to handle the 16x16 indexed ops is to
10400                  * duplicate the index into both halves of the 32 bit tcg_idx
10401                  * and then use the usual Neon helpers.
10402                  */
10403                 tcg_gen_deposit_i32(tcg_idx, tcg_idx, tcg_idx, 16, 16);
10404             }
10405
10406             for (pass = 0; pass < (is_scalar ? 1 : 2); pass++) {
10407                 TCGv_i32 tcg_op = tcg_temp_new_i32();
10408                 TCGv_i64 tcg_passres;
10409
10410                 if (is_scalar) {
10411                     read_vec_element_i32(s, tcg_op, rn, pass, size);
10412                 } else {
10413                     read_vec_element_i32(s, tcg_op, rn,
10414                                          pass + (is_q * 2), MO_32);
10415                 }
10416
10417                 tcg_res[pass] = tcg_temp_new_i64();
10418
10419                 if (opcode == 0xa || opcode == 0xb) {
10420                     /* Non-accumulating ops */
10421                     tcg_passres = tcg_res[pass];
10422                 } else {
10423                     tcg_passres = tcg_temp_new_i64();
10424                 }
10425
10426                 if (memop & MO_SIGN) {
10427                     gen_helper_neon_mull_s16(tcg_passres, tcg_op, tcg_idx);
10428                 } else {
10429                     gen_helper_neon_mull_u16(tcg_passres, tcg_op, tcg_idx);
10430                 }
10431                 if (satop) {
10432                     gen_helper_neon_addl_saturate_s32(tcg_passres, cpu_env,
10433                                                       tcg_passres, tcg_passres);
10434                 }
10435                 tcg_temp_free_i32(tcg_op);
10436
10437                 if (opcode == 0xa || opcode == 0xb) {
10438                     continue;
10439                 }
10440
10441                 /* Accumulating op: handle accumulate step */
10442                 read_vec_element(s, tcg_res[pass], rd, pass, MO_64);
10443
10444                 switch (opcode) {
10445                 case 0x2: /* SMLAL, SMLAL2, UMLAL, UMLAL2 */
10446                     gen_helper_neon_addl_u32(tcg_res[pass], tcg_res[pass],
10447                                              tcg_passres);
10448                     break;
10449                 case 0x6: /* SMLSL, SMLSL2, UMLSL, UMLSL2 */
10450                     gen_helper_neon_subl_u32(tcg_res[pass], tcg_res[pass],
10451                                              tcg_passres);
10452                     break;
10453                 case 0x7: /* SQDMLSL, SQDMLSL2 */
10454                     gen_helper_neon_negl_u32(tcg_passres, tcg_passres);
10455                     /* fall through */
10456                 case 0x3: /* SQDMLAL, SQDMLAL2 */
10457                     gen_helper_neon_addl_saturate_s32(tcg_res[pass], cpu_env,
10458                                                       tcg_res[pass],
10459                                                       tcg_passres);
10460                     break;
10461                 default:
10462                     g_assert_not_reached();
10463                 }
10464                 tcg_temp_free_i64(tcg_passres);
10465             }
10466             tcg_temp_free_i32(tcg_idx);
10467
10468             if (is_scalar) {
10469                 tcg_gen_ext32u_i64(tcg_res[0], tcg_res[0]);
10470             }
10471         }
10472
10473         if (is_scalar) {
10474             tcg_res[1] = tcg_const_i64(0);
10475         }
10476
10477         for (pass = 0; pass < 2; pass++) {
10478             write_vec_element(s, tcg_res[pass], rd, pass, MO_64);
10479             tcg_temp_free_i64(tcg_res[pass]);
10480         }
10481     }
10482
10483     if (!TCGV_IS_UNUSED_PTR(fpst)) {
10484         tcg_temp_free_ptr(fpst);
10485     }
10486 }
10487
10488 /* C3.6.19 Crypto AES
10489  *  31             24 23  22 21       17 16    12 11 10 9    5 4    0
10490  * +-----------------+------+-----------+--------+-----+------+------+
10491  * | 0 1 0 0 1 1 1 0 | size | 1 0 1 0 0 | opcode | 1 0 |  Rn  |  Rd  |
10492  * +-----------------+------+-----------+--------+-----+------+------+
10493  */
10494 static void disas_crypto_aes(DisasContext *s, uint32_t insn)
10495 {
10496     unsupported_encoding(s, insn);
10497 }
10498
10499 /* C3.6.20 Crypto three-reg SHA
10500  *  31             24 23  22  21 20  16  15 14    12 11 10 9    5 4    0
10501  * +-----------------+------+---+------+---+--------+-----+------+------+
10502  * | 0 1 0 1 1 1 1 0 | size | 0 |  Rm  | 0 | opcode | 0 0 |  Rn  |  Rd  |
10503  * +-----------------+------+---+------+---+--------+-----+------+------+
10504  */
10505 static void disas_crypto_three_reg_sha(DisasContext *s, uint32_t insn)
10506 {
10507     unsupported_encoding(s, insn);
10508 }
10509
10510 /* C3.6.21 Crypto two-reg SHA
10511  *  31             24 23  22 21       17 16    12 11 10 9    5 4    0
10512  * +-----------------+------+-----------+--------+-----+------+------+
10513  * | 0 1 0 1 1 1 1 0 | size | 1 0 1 0 0 | opcode | 1 0 |  Rn  |  Rd  |
10514  * +-----------------+------+-----------+--------+-----+------+------+
10515  */
10516 static void disas_crypto_two_reg_sha(DisasContext *s, uint32_t insn)
10517 {
10518     unsupported_encoding(s, insn);
10519 }
10520
10521 /* C3.6 Data processing - SIMD, inc Crypto
10522  *
10523  * As the decode gets a little complex we are using a table based
10524  * approach for this part of the decode.
10525  */
10526 static const AArch64DecodeTable data_proc_simd[] = {
10527     /* pattern  ,  mask     ,  fn                        */
10528     { 0x0e200400, 0x9f200400, disas_simd_three_reg_same },
10529     { 0x0e200000, 0x9f200c00, disas_simd_three_reg_diff },
10530     { 0x0e200800, 0x9f3e0c00, disas_simd_two_reg_misc },
10531     { 0x0e300800, 0x9f3e0c00, disas_simd_across_lanes },
10532     { 0x0e000400, 0x9fe08400, disas_simd_copy },
10533     { 0x0f000000, 0x9f000400, disas_simd_indexed }, /* vector indexed */
10534     /* simd_mod_imm decode is a subset of simd_shift_imm, so must precede it */
10535     { 0x0f000400, 0x9ff80400, disas_simd_mod_imm },
10536     { 0x0f000400, 0x9f800400, disas_simd_shift_imm },
10537     { 0x0e000000, 0xbf208c00, disas_simd_tb },
10538     { 0x0e000800, 0xbf208c00, disas_simd_zip_trn },
10539     { 0x2e000000, 0xbf208400, disas_simd_ext },
10540     { 0x5e200400, 0xdf200400, disas_simd_scalar_three_reg_same },
10541     { 0x5e200000, 0xdf200c00, disas_simd_scalar_three_reg_diff },
10542     { 0x5e200800, 0xdf3e0c00, disas_simd_scalar_two_reg_misc },
10543     { 0x5e300800, 0xdf3e0c00, disas_simd_scalar_pairwise },
10544     { 0x5e000400, 0xdfe08400, disas_simd_scalar_copy },
10545     { 0x5f000000, 0xdf000400, disas_simd_indexed }, /* scalar indexed */
10546     { 0x5f000400, 0xdf800400, disas_simd_scalar_shift_imm },
10547     { 0x4e280800, 0xff3e0c00, disas_crypto_aes },
10548     { 0x5e000000, 0xff208c00, disas_crypto_three_reg_sha },
10549     { 0x5e280800, 0xff3e0c00, disas_crypto_two_reg_sha },
10550     { 0x00000000, 0x00000000, NULL }
10551 };
10552
10553 static void disas_data_proc_simd(DisasContext *s, uint32_t insn)
10554 {
10555     /* Note that this is called with all non-FP cases from
10556      * table C3-6 so it must UNDEF for entries not specifically
10557      * allocated to instructions in that table.
10558      */
10559     AArch64DecodeFn *fn = lookup_disas_fn(&data_proc_simd[0], insn);
10560     if (fn) {
10561         fn(s, insn);
10562     } else {
10563         unallocated_encoding(s);
10564     }
10565 }
10566
10567 /* C3.6 Data processing - SIMD and floating point */
10568 static void disas_data_proc_simd_fp(DisasContext *s, uint32_t insn)
10569 {
10570     if (extract32(insn, 28, 1) == 1 && extract32(insn, 30, 1) == 0) {
10571         disas_data_proc_fp(s, insn);
10572     } else {
10573         /* SIMD, including crypto */
10574         disas_data_proc_simd(s, insn);
10575     }
10576 }
10577
10578 /* C3.1 A64 instruction index by encoding */
10579 static void disas_a64_insn(CPUARMState *env, DisasContext *s)
10580 {
10581     uint32_t insn;
10582
10583     insn = arm_ldl_code(env, s->pc, s->bswap_code);
10584     s->insn = insn;
10585     s->pc += 4;
10586
10587     s->fp_access_checked = false;
10588
10589     switch (extract32(insn, 25, 4)) {
10590     case 0x0: case 0x1: case 0x2: case 0x3: /* UNALLOCATED */
10591         unallocated_encoding(s);
10592         break;
10593     case 0x8: case 0x9: /* Data processing - immediate */
10594         disas_data_proc_imm(s, insn);
10595         break;
10596     case 0xa: case 0xb: /* Branch, exception generation and system insns */
10597         disas_b_exc_sys(s, insn);
10598         break;
10599     case 0x4:
10600     case 0x6:
10601     case 0xc:
10602     case 0xe:      /* Loads and stores */
10603         disas_ldst(s, insn);
10604         break;
10605     case 0x5:
10606     case 0xd:      /* Data processing - register */
10607         disas_data_proc_reg(s, insn);
10608         break;
10609     case 0x7:
10610     case 0xf:      /* Data processing - SIMD and floating point */
10611         disas_data_proc_simd_fp(s, insn);
10612         break;
10613     default:
10614         assert(FALSE); /* all 15 cases should be handled above */
10615         break;
10616     }
10617
10618     /* if we allocated any temporaries, free them here */
10619     free_tmp_a64(s);
10620 }
10621
10622 void gen_intermediate_code_internal_a64(ARMCPU *cpu,
10623                                         TranslationBlock *tb,
10624                                         bool search_pc)
10625 {
10626     CPUState *cs = CPU(cpu);
10627     CPUARMState *env = &cpu->env;
10628     DisasContext dc1, *dc = &dc1;
10629     CPUBreakpoint *bp;
10630     uint16_t *gen_opc_end;
10631     int j, lj;
10632     target_ulong pc_start;
10633     target_ulong next_page_start;
10634     int num_insns;
10635     int max_insns;
10636
10637     pc_start = tb->pc;
10638
10639     dc->tb = tb;
10640
10641     gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
10642
10643     dc->is_jmp = DISAS_NEXT;
10644     dc->pc = pc_start;
10645     dc->singlestep_enabled = cs->singlestep_enabled;
10646     dc->condjmp = 0;
10647
10648     dc->aarch64 = 1;
10649     dc->thumb = 0;
10650     dc->bswap_code = 0;
10651     dc->condexec_mask = 0;
10652     dc->condexec_cond = 0;
10653 #if !defined(CONFIG_USER_ONLY)
10654     dc->user = (ARM_TBFLAG_AA64_EL(tb->flags) == 0);
10655 #endif
10656     dc->cpacr_fpen = ARM_TBFLAG_AA64_FPEN(tb->flags);
10657     dc->vec_len = 0;
10658     dc->vec_stride = 0;
10659     dc->cp_regs = cpu->cp_regs;
10660     dc->current_pl = arm_current_pl(env);
10661     dc->features = env->features;
10662
10663     init_tmp_a64_array(dc);
10664
10665     next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE;
10666     lj = -1;
10667     num_insns = 0;
10668     max_insns = tb->cflags & CF_COUNT_MASK;
10669     if (max_insns == 0) {
10670         max_insns = CF_COUNT_MASK;
10671     }
10672
10673     gen_tb_start();
10674
10675     tcg_clear_temp_count();
10676
10677     do {
10678         if (unlikely(!QTAILQ_EMPTY(&cs->breakpoints))) {
10679             QTAILQ_FOREACH(bp, &cs->breakpoints, entry) {
10680                 if (bp->pc == dc->pc) {
10681                     gen_exception_internal_insn(dc, 0, EXCP_DEBUG);
10682                     /* Advance PC so that clearing the breakpoint will
10683                        invalidate this TB.  */
10684                     dc->pc += 2;
10685                     goto done_generating;
10686                 }
10687             }
10688         }
10689
10690         if (search_pc) {
10691             j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
10692             if (lj < j) {
10693                 lj++;
10694                 while (lj < j) {
10695                     tcg_ctx.gen_opc_instr_start[lj++] = 0;
10696                 }
10697             }
10698             tcg_ctx.gen_opc_pc[lj] = dc->pc;
10699             tcg_ctx.gen_opc_instr_start[lj] = 1;
10700             tcg_ctx.gen_opc_icount[lj] = num_insns;
10701         }
10702
10703         if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO)) {
10704             gen_io_start();
10705         }
10706
10707         if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {
10708             tcg_gen_debug_insn_start(dc->pc);
10709         }
10710
10711         disas_a64_insn(env, dc);
10712
10713         if (tcg_check_temp_count()) {
10714             fprintf(stderr, "TCG temporary leak before "TARGET_FMT_lx"\n",
10715                     dc->pc);
10716         }
10717
10718         /* Translation stops when a conditional branch is encountered.
10719          * Otherwise the subsequent code could get translated several times.
10720          * Also stop translation when a page boundary is reached.  This
10721          * ensures prefetch aborts occur at the right place.
10722          */
10723         num_insns++;
10724     } while (!dc->is_jmp && tcg_ctx.gen_opc_ptr < gen_opc_end &&
10725              !cs->singlestep_enabled &&
10726              !singlestep &&
10727              dc->pc < next_page_start &&
10728              num_insns < max_insns);
10729
10730     if (tb->cflags & CF_LAST_IO) {
10731         gen_io_end();
10732     }
10733
10734     if (unlikely(cs->singlestep_enabled) && dc->is_jmp != DISAS_EXC) {
10735         /* Note that this means single stepping WFI doesn't halt the CPU.
10736          * For conditional branch insns this is harmless unreachable code as
10737          * gen_goto_tb() has already handled emitting the debug exception
10738          * (and thus a tb-jump is not possible when singlestepping).
10739          */
10740         assert(dc->is_jmp != DISAS_TB_JUMP);
10741         if (dc->is_jmp != DISAS_JUMP) {
10742             gen_a64_set_pc_im(dc->pc);
10743         }
10744         gen_exception_internal(EXCP_DEBUG);
10745     } else {
10746         switch (dc->is_jmp) {
10747         case DISAS_NEXT:
10748             gen_goto_tb(dc, 1, dc->pc);
10749             break;
10750         default:
10751         case DISAS_UPDATE:
10752             gen_a64_set_pc_im(dc->pc);
10753             /* fall through */
10754         case DISAS_JUMP:
10755             /* indicate that the hash table must be used to find the next TB */
10756             tcg_gen_exit_tb(0);
10757             break;
10758         case DISAS_TB_JUMP:
10759         case DISAS_EXC:
10760         case DISAS_SWI:
10761             break;
10762         case DISAS_WFE:
10763             gen_a64_set_pc_im(dc->pc);
10764             gen_helper_wfe(cpu_env);
10765             break;
10766         case DISAS_WFI:
10767             /* This is a special case because we don't want to just halt the CPU
10768              * if trying to debug across a WFI.
10769              */
10770             gen_a64_set_pc_im(dc->pc);
10771             gen_helper_wfi(cpu_env);
10772             break;
10773         }
10774     }
10775
10776 done_generating:
10777     gen_tb_end(tb, num_insns);
10778     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
10779
10780 #ifdef DEBUG_DISAS
10781     if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
10782         qemu_log("----------------\n");
10783         qemu_log("IN: %s\n", lookup_symbol(pc_start));
10784         log_target_disas(env, pc_start, dc->pc - pc_start,
10785                          4 | (dc->bswap_code << 1));
10786         qemu_log("\n");
10787     }
10788 #endif
10789     if (search_pc) {
10790         j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
10791         lj++;
10792         while (lj <= j) {
10793             tcg_ctx.gen_opc_instr_start[lj++] = 0;
10794         }
10795     } else {
10796         tb->size = dc->pc - pc_start;
10797         tb->icount = num_insns;
10798     }
10799 }