target/arm: Macroify uses of do_vfp_2op_sp() and do_vfp_2op_dp()
[qemu.git] / target / arm / translate-vfp.c.inc
1 /*
2  *  ARM translation: AArch32 VFP instructions
3  *
4  *  Copyright (c) 2003 Fabrice Bellard
5  *  Copyright (c) 2005-2007 CodeSourcery
6  *  Copyright (c) 2007 OpenedHand, Ltd.
7  *  Copyright (c) 2019 Linaro, Ltd.
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
21  */
22
23 /*
24  * This file is intended to be included from translate.c; it uses
25  * some macros and definitions provided by that file.
26  * It might be possible to convert it to a standalone .c file eventually.
27  */
28
29 /* Include the generated VFP decoder */
30 #include "decode-vfp.c.inc"
31 #include "decode-vfp-uncond.c.inc"
32
33 /*
34  * The imm8 encodes the sign bit, enough bits to represent an exponent in
35  * the range 01....1xx to 10....0xx, and the most significant 4 bits of
36  * the mantissa; see VFPExpandImm() in the v8 ARM ARM.
37  */
38 uint64_t vfp_expand_imm(int size, uint8_t imm8)
39 {
40     uint64_t imm;
41
42     switch (size) {
43     case MO_64:
44         imm = (extract32(imm8, 7, 1) ? 0x8000 : 0) |
45             (extract32(imm8, 6, 1) ? 0x3fc0 : 0x4000) |
46             extract32(imm8, 0, 6);
47         imm <<= 48;
48         break;
49     case MO_32:
50         imm = (extract32(imm8, 7, 1) ? 0x8000 : 0) |
51             (extract32(imm8, 6, 1) ? 0x3e00 : 0x4000) |
52             (extract32(imm8, 0, 6) << 3);
53         imm <<= 16;
54         break;
55     case MO_16:
56         imm = (extract32(imm8, 7, 1) ? 0x8000 : 0) |
57             (extract32(imm8, 6, 1) ? 0x3000 : 0x4000) |
58             (extract32(imm8, 0, 6) << 6);
59         break;
60     default:
61         g_assert_not_reached();
62     }
63     return imm;
64 }
65
66 /*
67  * Return the offset of a 16-bit half of the specified VFP single-precision
68  * register. If top is true, returns the top 16 bits; otherwise the bottom
69  * 16 bits.
70  */
71 static inline long vfp_f16_offset(unsigned reg, bool top)
72 {
73     long offs = vfp_reg_offset(false, reg);
74 #ifdef HOST_WORDS_BIGENDIAN
75     if (!top) {
76         offs += 2;
77     }
78 #else
79     if (top) {
80         offs += 2;
81     }
82 #endif
83     return offs;
84 }
85
86 /*
87  * Check that VFP access is enabled. If it is, do the necessary
88  * M-profile lazy-FP handling and then return true.
89  * If not, emit code to generate an appropriate exception and
90  * return false.
91  * The ignore_vfp_enabled argument specifies that we should ignore
92  * whether VFP is enabled via FPEXC[EN]: this should be true for FMXR/FMRX
93  * accesses to FPSID, FPEXC, MVFR0, MVFR1, MVFR2, and false for all other insns.
94  */
95 static bool full_vfp_access_check(DisasContext *s, bool ignore_vfp_enabled)
96 {
97     if (s->fp_excp_el) {
98         /* M-profile handled this earlier, in disas_m_nocp() */
99         assert (!arm_dc_feature(s, ARM_FEATURE_M));
100         gen_exception_insn(s, s->pc_curr, EXCP_UDEF,
101                            syn_fp_access_trap(1, 0xe, false),
102                            s->fp_excp_el);
103         return false;
104     }
105
106     if (!s->vfp_enabled && !ignore_vfp_enabled) {
107         assert(!arm_dc_feature(s, ARM_FEATURE_M));
108         unallocated_encoding(s);
109         return false;
110     }
111
112     if (arm_dc_feature(s, ARM_FEATURE_M)) {
113         /* Handle M-profile lazy FP state mechanics */
114
115         /* Trigger lazy-state preservation if necessary */
116         if (s->v7m_lspact) {
117             /*
118              * Lazy state saving affects external memory and also the NVIC,
119              * so we must mark it as an IO operation for icount (and cause
120              * this to be the last insn in the TB).
121              */
122             if (tb_cflags(s->base.tb) & CF_USE_ICOUNT) {
123                 s->base.is_jmp = DISAS_UPDATE_EXIT;
124                 gen_io_start();
125             }
126             gen_helper_v7m_preserve_fp_state(cpu_env);
127             /*
128              * If the preserve_fp_state helper doesn't throw an exception
129              * then it will clear LSPACT; we don't need to repeat this for
130              * any further FP insns in this TB.
131              */
132             s->v7m_lspact = false;
133         }
134
135         /* Update ownership of FP context: set FPCCR.S to match current state */
136         if (s->v8m_fpccr_s_wrong) {
137             TCGv_i32 tmp;
138
139             tmp = load_cpu_field(v7m.fpccr[M_REG_S]);
140             if (s->v8m_secure) {
141                 tcg_gen_ori_i32(tmp, tmp, R_V7M_FPCCR_S_MASK);
142             } else {
143                 tcg_gen_andi_i32(tmp, tmp, ~R_V7M_FPCCR_S_MASK);
144             }
145             store_cpu_field(tmp, v7m.fpccr[M_REG_S]);
146             /* Don't need to do this for any further FP insns in this TB */
147             s->v8m_fpccr_s_wrong = false;
148         }
149
150         if (s->v7m_new_fp_ctxt_needed) {
151             /*
152              * Create new FP context by updating CONTROL.FPCA, CONTROL.SFPA
153              * and the FPSCR.
154              */
155             TCGv_i32 control, fpscr;
156             uint32_t bits = R_V7M_CONTROL_FPCA_MASK;
157
158             fpscr = load_cpu_field(v7m.fpdscr[s->v8m_secure]);
159             gen_helper_vfp_set_fpscr(cpu_env, fpscr);
160             tcg_temp_free_i32(fpscr);
161             /*
162              * We don't need to arrange to end the TB, because the only
163              * parts of FPSCR which we cache in the TB flags are the VECLEN
164              * and VECSTRIDE, and those don't exist for M-profile.
165              */
166
167             if (s->v8m_secure) {
168                 bits |= R_V7M_CONTROL_SFPA_MASK;
169             }
170             control = load_cpu_field(v7m.control[M_REG_S]);
171             tcg_gen_ori_i32(control, control, bits);
172             store_cpu_field(control, v7m.control[M_REG_S]);
173             /* Don't need to do this for any further FP insns in this TB */
174             s->v7m_new_fp_ctxt_needed = false;
175         }
176     }
177
178     return true;
179 }
180
181 /*
182  * The most usual kind of VFP access check, for everything except
183  * FMXR/FMRX to the always-available special registers.
184  */
185 static bool vfp_access_check(DisasContext *s)
186 {
187     return full_vfp_access_check(s, false);
188 }
189
190 static bool trans_VSEL(DisasContext *s, arg_VSEL *a)
191 {
192     uint32_t rd, rn, rm;
193     bool dp = a->dp;
194
195     if (!dc_isar_feature(aa32_vsel, s)) {
196         return false;
197     }
198
199     if (dp && !dc_isar_feature(aa32_fpdp_v2, s)) {
200         return false;
201     }
202
203     /* UNDEF accesses to D16-D31 if they don't exist */
204     if (dp && !dc_isar_feature(aa32_simd_r32, s) &&
205         ((a->vm | a->vn | a->vd) & 0x10)) {
206         return false;
207     }
208
209     rd = a->vd;
210     rn = a->vn;
211     rm = a->vm;
212
213     if (!vfp_access_check(s)) {
214         return true;
215     }
216
217     if (dp) {
218         TCGv_i64 frn, frm, dest;
219         TCGv_i64 tmp, zero, zf, nf, vf;
220
221         zero = tcg_const_i64(0);
222
223         frn = tcg_temp_new_i64();
224         frm = tcg_temp_new_i64();
225         dest = tcg_temp_new_i64();
226
227         zf = tcg_temp_new_i64();
228         nf = tcg_temp_new_i64();
229         vf = tcg_temp_new_i64();
230
231         tcg_gen_extu_i32_i64(zf, cpu_ZF);
232         tcg_gen_ext_i32_i64(nf, cpu_NF);
233         tcg_gen_ext_i32_i64(vf, cpu_VF);
234
235         neon_load_reg64(frn, rn);
236         neon_load_reg64(frm, rm);
237         switch (a->cc) {
238         case 0: /* eq: Z */
239             tcg_gen_movcond_i64(TCG_COND_EQ, dest, zf, zero,
240                                 frn, frm);
241             break;
242         case 1: /* vs: V */
243             tcg_gen_movcond_i64(TCG_COND_LT, dest, vf, zero,
244                                 frn, frm);
245             break;
246         case 2: /* ge: N == V -> N ^ V == 0 */
247             tmp = tcg_temp_new_i64();
248             tcg_gen_xor_i64(tmp, vf, nf);
249             tcg_gen_movcond_i64(TCG_COND_GE, dest, tmp, zero,
250                                 frn, frm);
251             tcg_temp_free_i64(tmp);
252             break;
253         case 3: /* gt: !Z && N == V */
254             tcg_gen_movcond_i64(TCG_COND_NE, dest, zf, zero,
255                                 frn, frm);
256             tmp = tcg_temp_new_i64();
257             tcg_gen_xor_i64(tmp, vf, nf);
258             tcg_gen_movcond_i64(TCG_COND_GE, dest, tmp, zero,
259                                 dest, frm);
260             tcg_temp_free_i64(tmp);
261             break;
262         }
263         neon_store_reg64(dest, rd);
264         tcg_temp_free_i64(frn);
265         tcg_temp_free_i64(frm);
266         tcg_temp_free_i64(dest);
267
268         tcg_temp_free_i64(zf);
269         tcg_temp_free_i64(nf);
270         tcg_temp_free_i64(vf);
271
272         tcg_temp_free_i64(zero);
273     } else {
274         TCGv_i32 frn, frm, dest;
275         TCGv_i32 tmp, zero;
276
277         zero = tcg_const_i32(0);
278
279         frn = tcg_temp_new_i32();
280         frm = tcg_temp_new_i32();
281         dest = tcg_temp_new_i32();
282         neon_load_reg32(frn, rn);
283         neon_load_reg32(frm, rm);
284         switch (a->cc) {
285         case 0: /* eq: Z */
286             tcg_gen_movcond_i32(TCG_COND_EQ, dest, cpu_ZF, zero,
287                                 frn, frm);
288             break;
289         case 1: /* vs: V */
290             tcg_gen_movcond_i32(TCG_COND_LT, dest, cpu_VF, zero,
291                                 frn, frm);
292             break;
293         case 2: /* ge: N == V -> N ^ V == 0 */
294             tmp = tcg_temp_new_i32();
295             tcg_gen_xor_i32(tmp, cpu_VF, cpu_NF);
296             tcg_gen_movcond_i32(TCG_COND_GE, dest, tmp, zero,
297                                 frn, frm);
298             tcg_temp_free_i32(tmp);
299             break;
300         case 3: /* gt: !Z && N == V */
301             tcg_gen_movcond_i32(TCG_COND_NE, dest, cpu_ZF, zero,
302                                 frn, frm);
303             tmp = tcg_temp_new_i32();
304             tcg_gen_xor_i32(tmp, cpu_VF, cpu_NF);
305             tcg_gen_movcond_i32(TCG_COND_GE, dest, tmp, zero,
306                                 dest, frm);
307             tcg_temp_free_i32(tmp);
308             break;
309         }
310         neon_store_reg32(dest, rd);
311         tcg_temp_free_i32(frn);
312         tcg_temp_free_i32(frm);
313         tcg_temp_free_i32(dest);
314
315         tcg_temp_free_i32(zero);
316     }
317
318     return true;
319 }
320
321 /*
322  * Table for converting the most common AArch32 encoding of
323  * rounding mode to arm_fprounding order (which matches the
324  * common AArch64 order); see ARM ARM pseudocode FPDecodeRM().
325  */
326 static const uint8_t fp_decode_rm[] = {
327     FPROUNDING_TIEAWAY,
328     FPROUNDING_TIEEVEN,
329     FPROUNDING_POSINF,
330     FPROUNDING_NEGINF,
331 };
332
333 static bool trans_VRINT(DisasContext *s, arg_VRINT *a)
334 {
335     uint32_t rd, rm;
336     bool dp = a->dp;
337     TCGv_ptr fpst;
338     TCGv_i32 tcg_rmode;
339     int rounding = fp_decode_rm[a->rm];
340
341     if (!dc_isar_feature(aa32_vrint, s)) {
342         return false;
343     }
344
345     if (dp && !dc_isar_feature(aa32_fpdp_v2, s)) {
346         return false;
347     }
348
349     /* UNDEF accesses to D16-D31 if they don't exist */
350     if (dp && !dc_isar_feature(aa32_simd_r32, s) &&
351         ((a->vm | a->vd) & 0x10)) {
352         return false;
353     }
354
355     rd = a->vd;
356     rm = a->vm;
357
358     if (!vfp_access_check(s)) {
359         return true;
360     }
361
362     fpst = fpstatus_ptr(FPST_FPCR);
363
364     tcg_rmode = tcg_const_i32(arm_rmode_to_sf(rounding));
365     gen_helper_set_rmode(tcg_rmode, tcg_rmode, fpst);
366
367     if (dp) {
368         TCGv_i64 tcg_op;
369         TCGv_i64 tcg_res;
370         tcg_op = tcg_temp_new_i64();
371         tcg_res = tcg_temp_new_i64();
372         neon_load_reg64(tcg_op, rm);
373         gen_helper_rintd(tcg_res, tcg_op, fpst);
374         neon_store_reg64(tcg_res, rd);
375         tcg_temp_free_i64(tcg_op);
376         tcg_temp_free_i64(tcg_res);
377     } else {
378         TCGv_i32 tcg_op;
379         TCGv_i32 tcg_res;
380         tcg_op = tcg_temp_new_i32();
381         tcg_res = tcg_temp_new_i32();
382         neon_load_reg32(tcg_op, rm);
383         gen_helper_rints(tcg_res, tcg_op, fpst);
384         neon_store_reg32(tcg_res, rd);
385         tcg_temp_free_i32(tcg_op);
386         tcg_temp_free_i32(tcg_res);
387     }
388
389     gen_helper_set_rmode(tcg_rmode, tcg_rmode, fpst);
390     tcg_temp_free_i32(tcg_rmode);
391
392     tcg_temp_free_ptr(fpst);
393     return true;
394 }
395
396 static bool trans_VCVT(DisasContext *s, arg_VCVT *a)
397 {
398     uint32_t rd, rm;
399     bool dp = a->dp;
400     TCGv_ptr fpst;
401     TCGv_i32 tcg_rmode, tcg_shift;
402     int rounding = fp_decode_rm[a->rm];
403     bool is_signed = a->op;
404
405     if (!dc_isar_feature(aa32_vcvt_dr, s)) {
406         return false;
407     }
408
409     if (dp && !dc_isar_feature(aa32_fpdp_v2, s)) {
410         return false;
411     }
412
413     /* UNDEF accesses to D16-D31 if they don't exist */
414     if (dp && !dc_isar_feature(aa32_simd_r32, s) && (a->vm & 0x10)) {
415         return false;
416     }
417
418     rd = a->vd;
419     rm = a->vm;
420
421     if (!vfp_access_check(s)) {
422         return true;
423     }
424
425     fpst = fpstatus_ptr(FPST_FPCR);
426
427     tcg_shift = tcg_const_i32(0);
428
429     tcg_rmode = tcg_const_i32(arm_rmode_to_sf(rounding));
430     gen_helper_set_rmode(tcg_rmode, tcg_rmode, fpst);
431
432     if (dp) {
433         TCGv_i64 tcg_double, tcg_res;
434         TCGv_i32 tcg_tmp;
435         tcg_double = tcg_temp_new_i64();
436         tcg_res = tcg_temp_new_i64();
437         tcg_tmp = tcg_temp_new_i32();
438         neon_load_reg64(tcg_double, rm);
439         if (is_signed) {
440             gen_helper_vfp_tosld(tcg_res, tcg_double, tcg_shift, fpst);
441         } else {
442             gen_helper_vfp_tould(tcg_res, tcg_double, tcg_shift, fpst);
443         }
444         tcg_gen_extrl_i64_i32(tcg_tmp, tcg_res);
445         neon_store_reg32(tcg_tmp, rd);
446         tcg_temp_free_i32(tcg_tmp);
447         tcg_temp_free_i64(tcg_res);
448         tcg_temp_free_i64(tcg_double);
449     } else {
450         TCGv_i32 tcg_single, tcg_res;
451         tcg_single = tcg_temp_new_i32();
452         tcg_res = tcg_temp_new_i32();
453         neon_load_reg32(tcg_single, rm);
454         if (is_signed) {
455             gen_helper_vfp_tosls(tcg_res, tcg_single, tcg_shift, fpst);
456         } else {
457             gen_helper_vfp_touls(tcg_res, tcg_single, tcg_shift, fpst);
458         }
459         neon_store_reg32(tcg_res, rd);
460         tcg_temp_free_i32(tcg_res);
461         tcg_temp_free_i32(tcg_single);
462     }
463
464     gen_helper_set_rmode(tcg_rmode, tcg_rmode, fpst);
465     tcg_temp_free_i32(tcg_rmode);
466
467     tcg_temp_free_i32(tcg_shift);
468
469     tcg_temp_free_ptr(fpst);
470
471     return true;
472 }
473
474 static bool trans_VMOV_to_gp(DisasContext *s, arg_VMOV_to_gp *a)
475 {
476     /* VMOV scalar to general purpose register */
477     TCGv_i32 tmp;
478     int pass;
479     uint32_t offset;
480
481     /* SIZE == 2 is a VFP instruction; otherwise NEON.  */
482     if (a->size == 2
483         ? !dc_isar_feature(aa32_fpsp_v2, s)
484         : !arm_dc_feature(s, ARM_FEATURE_NEON)) {
485         return false;
486     }
487
488     /* UNDEF accesses to D16-D31 if they don't exist */
489     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vn & 0x10)) {
490         return false;
491     }
492
493     offset = a->index << a->size;
494     pass = extract32(offset, 2, 1);
495     offset = extract32(offset, 0, 2) * 8;
496
497     if (!vfp_access_check(s)) {
498         return true;
499     }
500
501     tmp = neon_load_reg(a->vn, pass);
502     switch (a->size) {
503     case 0:
504         if (offset) {
505             tcg_gen_shri_i32(tmp, tmp, offset);
506         }
507         if (a->u) {
508             gen_uxtb(tmp);
509         } else {
510             gen_sxtb(tmp);
511         }
512         break;
513     case 1:
514         if (a->u) {
515             if (offset) {
516                 tcg_gen_shri_i32(tmp, tmp, 16);
517             } else {
518                 gen_uxth(tmp);
519             }
520         } else {
521             if (offset) {
522                 tcg_gen_sari_i32(tmp, tmp, 16);
523             } else {
524                 gen_sxth(tmp);
525             }
526         }
527         break;
528     case 2:
529         break;
530     }
531     store_reg(s, a->rt, tmp);
532
533     return true;
534 }
535
536 static bool trans_VMOV_from_gp(DisasContext *s, arg_VMOV_from_gp *a)
537 {
538     /* VMOV general purpose register to scalar */
539     TCGv_i32 tmp, tmp2;
540     int pass;
541     uint32_t offset;
542
543     /* SIZE == 2 is a VFP instruction; otherwise NEON.  */
544     if (a->size == 2
545         ? !dc_isar_feature(aa32_fpsp_v2, s)
546         : !arm_dc_feature(s, ARM_FEATURE_NEON)) {
547         return false;
548     }
549
550     /* UNDEF accesses to D16-D31 if they don't exist */
551     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vn & 0x10)) {
552         return false;
553     }
554
555     offset = a->index << a->size;
556     pass = extract32(offset, 2, 1);
557     offset = extract32(offset, 0, 2) * 8;
558
559     if (!vfp_access_check(s)) {
560         return true;
561     }
562
563     tmp = load_reg(s, a->rt);
564     switch (a->size) {
565     case 0:
566         tmp2 = neon_load_reg(a->vn, pass);
567         tcg_gen_deposit_i32(tmp, tmp2, tmp, offset, 8);
568         tcg_temp_free_i32(tmp2);
569         break;
570     case 1:
571         tmp2 = neon_load_reg(a->vn, pass);
572         tcg_gen_deposit_i32(tmp, tmp2, tmp, offset, 16);
573         tcg_temp_free_i32(tmp2);
574         break;
575     case 2:
576         break;
577     }
578     neon_store_reg(a->vn, pass, tmp);
579
580     return true;
581 }
582
583 static bool trans_VDUP(DisasContext *s, arg_VDUP *a)
584 {
585     /* VDUP (general purpose register) */
586     TCGv_i32 tmp;
587     int size, vec_size;
588
589     if (!arm_dc_feature(s, ARM_FEATURE_NEON)) {
590         return false;
591     }
592
593     /* UNDEF accesses to D16-D31 if they don't exist */
594     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vn & 0x10)) {
595         return false;
596     }
597
598     if (a->b && a->e) {
599         return false;
600     }
601
602     if (a->q && (a->vn & 1)) {
603         return false;
604     }
605
606     vec_size = a->q ? 16 : 8;
607     if (a->b) {
608         size = 0;
609     } else if (a->e) {
610         size = 1;
611     } else {
612         size = 2;
613     }
614
615     if (!vfp_access_check(s)) {
616         return true;
617     }
618
619     tmp = load_reg(s, a->rt);
620     tcg_gen_gvec_dup_i32(size, neon_reg_offset(a->vn, 0),
621                          vec_size, vec_size, tmp);
622     tcg_temp_free_i32(tmp);
623
624     return true;
625 }
626
627 static bool trans_VMSR_VMRS(DisasContext *s, arg_VMSR_VMRS *a)
628 {
629     TCGv_i32 tmp;
630     bool ignore_vfp_enabled = false;
631
632     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
633         return false;
634     }
635
636     if (arm_dc_feature(s, ARM_FEATURE_M)) {
637         /*
638          * The only M-profile VFP vmrs/vmsr sysreg is FPSCR.
639          * Accesses to R15 are UNPREDICTABLE; we choose to undef.
640          * (FPSCR -> r15 is a special case which writes to the PSR flags.)
641          */
642         if (a->rt == 15 && (!a->l || a->reg != ARM_VFP_FPSCR)) {
643             return false;
644         }
645     }
646
647     switch (a->reg) {
648     case ARM_VFP_FPSID:
649         /*
650          * VFPv2 allows access to FPSID from userspace; VFPv3 restricts
651          * all ID registers to privileged access only.
652          */
653         if (IS_USER(s) && dc_isar_feature(aa32_fpsp_v3, s)) {
654             return false;
655         }
656         ignore_vfp_enabled = true;
657         break;
658     case ARM_VFP_MVFR0:
659     case ARM_VFP_MVFR1:
660         if (IS_USER(s) || !arm_dc_feature(s, ARM_FEATURE_MVFR)) {
661             return false;
662         }
663         ignore_vfp_enabled = true;
664         break;
665     case ARM_VFP_MVFR2:
666         if (IS_USER(s) || !arm_dc_feature(s, ARM_FEATURE_V8)) {
667             return false;
668         }
669         ignore_vfp_enabled = true;
670         break;
671     case ARM_VFP_FPSCR:
672         break;
673     case ARM_VFP_FPEXC:
674         if (IS_USER(s)) {
675             return false;
676         }
677         ignore_vfp_enabled = true;
678         break;
679     case ARM_VFP_FPINST:
680     case ARM_VFP_FPINST2:
681         /* Not present in VFPv3 */
682         if (IS_USER(s) || dc_isar_feature(aa32_fpsp_v3, s)) {
683             return false;
684         }
685         break;
686     default:
687         return false;
688     }
689
690     if (!full_vfp_access_check(s, ignore_vfp_enabled)) {
691         return true;
692     }
693
694     if (a->l) {
695         /* VMRS, move VFP special register to gp register */
696         switch (a->reg) {
697         case ARM_VFP_MVFR0:
698         case ARM_VFP_MVFR1:
699         case ARM_VFP_MVFR2:
700         case ARM_VFP_FPSID:
701             if (s->current_el == 1) {
702                 TCGv_i32 tcg_reg, tcg_rt;
703
704                 gen_set_condexec(s);
705                 gen_set_pc_im(s, s->pc_curr);
706                 tcg_reg = tcg_const_i32(a->reg);
707                 tcg_rt = tcg_const_i32(a->rt);
708                 gen_helper_check_hcr_el2_trap(cpu_env, tcg_rt, tcg_reg);
709                 tcg_temp_free_i32(tcg_reg);
710                 tcg_temp_free_i32(tcg_rt);
711             }
712             /* fall through */
713         case ARM_VFP_FPEXC:
714         case ARM_VFP_FPINST:
715         case ARM_VFP_FPINST2:
716             tmp = load_cpu_field(vfp.xregs[a->reg]);
717             break;
718         case ARM_VFP_FPSCR:
719             if (a->rt == 15) {
720                 tmp = load_cpu_field(vfp.xregs[ARM_VFP_FPSCR]);
721                 tcg_gen_andi_i32(tmp, tmp, 0xf0000000);
722             } else {
723                 tmp = tcg_temp_new_i32();
724                 gen_helper_vfp_get_fpscr(tmp, cpu_env);
725             }
726             break;
727         default:
728             g_assert_not_reached();
729         }
730
731         if (a->rt == 15) {
732             /* Set the 4 flag bits in the CPSR.  */
733             gen_set_nzcv(tmp);
734             tcg_temp_free_i32(tmp);
735         } else {
736             store_reg(s, a->rt, tmp);
737         }
738     } else {
739         /* VMSR, move gp register to VFP special register */
740         switch (a->reg) {
741         case ARM_VFP_FPSID:
742         case ARM_VFP_MVFR0:
743         case ARM_VFP_MVFR1:
744         case ARM_VFP_MVFR2:
745             /* Writes are ignored.  */
746             break;
747         case ARM_VFP_FPSCR:
748             tmp = load_reg(s, a->rt);
749             gen_helper_vfp_set_fpscr(cpu_env, tmp);
750             tcg_temp_free_i32(tmp);
751             gen_lookup_tb(s);
752             break;
753         case ARM_VFP_FPEXC:
754             /*
755              * TODO: VFP subarchitecture support.
756              * For now, keep the EN bit only
757              */
758             tmp = load_reg(s, a->rt);
759             tcg_gen_andi_i32(tmp, tmp, 1 << 30);
760             store_cpu_field(tmp, vfp.xregs[a->reg]);
761             gen_lookup_tb(s);
762             break;
763         case ARM_VFP_FPINST:
764         case ARM_VFP_FPINST2:
765             tmp = load_reg(s, a->rt);
766             store_cpu_field(tmp, vfp.xregs[a->reg]);
767             break;
768         default:
769             g_assert_not_reached();
770         }
771     }
772
773     return true;
774 }
775
776 static bool trans_VMOV_single(DisasContext *s, arg_VMOV_single *a)
777 {
778     TCGv_i32 tmp;
779
780     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
781         return false;
782     }
783
784     if (!vfp_access_check(s)) {
785         return true;
786     }
787
788     if (a->l) {
789         /* VFP to general purpose register */
790         tmp = tcg_temp_new_i32();
791         neon_load_reg32(tmp, a->vn);
792         if (a->rt == 15) {
793             /* Set the 4 flag bits in the CPSR.  */
794             gen_set_nzcv(tmp);
795             tcg_temp_free_i32(tmp);
796         } else {
797             store_reg(s, a->rt, tmp);
798         }
799     } else {
800         /* general purpose register to VFP */
801         tmp = load_reg(s, a->rt);
802         neon_store_reg32(tmp, a->vn);
803         tcg_temp_free_i32(tmp);
804     }
805
806     return true;
807 }
808
809 static bool trans_VMOV_64_sp(DisasContext *s, arg_VMOV_64_sp *a)
810 {
811     TCGv_i32 tmp;
812
813     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
814         return false;
815     }
816
817     /*
818      * VMOV between two general-purpose registers and two single precision
819      * floating point registers
820      */
821     if (!vfp_access_check(s)) {
822         return true;
823     }
824
825     if (a->op) {
826         /* fpreg to gpreg */
827         tmp = tcg_temp_new_i32();
828         neon_load_reg32(tmp, a->vm);
829         store_reg(s, a->rt, tmp);
830         tmp = tcg_temp_new_i32();
831         neon_load_reg32(tmp, a->vm + 1);
832         store_reg(s, a->rt2, tmp);
833     } else {
834         /* gpreg to fpreg */
835         tmp = load_reg(s, a->rt);
836         neon_store_reg32(tmp, a->vm);
837         tcg_temp_free_i32(tmp);
838         tmp = load_reg(s, a->rt2);
839         neon_store_reg32(tmp, a->vm + 1);
840         tcg_temp_free_i32(tmp);
841     }
842
843     return true;
844 }
845
846 static bool trans_VMOV_64_dp(DisasContext *s, arg_VMOV_64_dp *a)
847 {
848     TCGv_i32 tmp;
849
850     /*
851      * VMOV between two general-purpose registers and one double precision
852      * floating point register.  Note that this does not require support
853      * for double precision arithmetic.
854      */
855     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
856         return false;
857     }
858
859     /* UNDEF accesses to D16-D31 if they don't exist */
860     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vm & 0x10)) {
861         return false;
862     }
863
864     if (!vfp_access_check(s)) {
865         return true;
866     }
867
868     if (a->op) {
869         /* fpreg to gpreg */
870         tmp = tcg_temp_new_i32();
871         neon_load_reg32(tmp, a->vm * 2);
872         store_reg(s, a->rt, tmp);
873         tmp = tcg_temp_new_i32();
874         neon_load_reg32(tmp, a->vm * 2 + 1);
875         store_reg(s, a->rt2, tmp);
876     } else {
877         /* gpreg to fpreg */
878         tmp = load_reg(s, a->rt);
879         neon_store_reg32(tmp, a->vm * 2);
880         tcg_temp_free_i32(tmp);
881         tmp = load_reg(s, a->rt2);
882         neon_store_reg32(tmp, a->vm * 2 + 1);
883         tcg_temp_free_i32(tmp);
884     }
885
886     return true;
887 }
888
889 static bool trans_VLDR_VSTR_sp(DisasContext *s, arg_VLDR_VSTR_sp *a)
890 {
891     uint32_t offset;
892     TCGv_i32 addr, tmp;
893
894     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
895         return false;
896     }
897
898     if (!vfp_access_check(s)) {
899         return true;
900     }
901
902     offset = a->imm << 2;
903     if (!a->u) {
904         offset = -offset;
905     }
906
907     /* For thumb, use of PC is UNPREDICTABLE.  */
908     addr = add_reg_for_lit(s, a->rn, offset);
909     tmp = tcg_temp_new_i32();
910     if (a->l) {
911         gen_aa32_ld32u(s, tmp, addr, get_mem_index(s));
912         neon_store_reg32(tmp, a->vd);
913     } else {
914         neon_load_reg32(tmp, a->vd);
915         gen_aa32_st32(s, tmp, addr, get_mem_index(s));
916     }
917     tcg_temp_free_i32(tmp);
918     tcg_temp_free_i32(addr);
919
920     return true;
921 }
922
923 static bool trans_VLDR_VSTR_dp(DisasContext *s, arg_VLDR_VSTR_dp *a)
924 {
925     uint32_t offset;
926     TCGv_i32 addr;
927     TCGv_i64 tmp;
928
929     /* Note that this does not require support for double arithmetic.  */
930     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
931         return false;
932     }
933
934     /* UNDEF accesses to D16-D31 if they don't exist */
935     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vd & 0x10)) {
936         return false;
937     }
938
939     if (!vfp_access_check(s)) {
940         return true;
941     }
942
943     offset = a->imm << 2;
944     if (!a->u) {
945         offset = -offset;
946     }
947
948     /* For thumb, use of PC is UNPREDICTABLE.  */
949     addr = add_reg_for_lit(s, a->rn, offset);
950     tmp = tcg_temp_new_i64();
951     if (a->l) {
952         gen_aa32_ld64(s, tmp, addr, get_mem_index(s));
953         neon_store_reg64(tmp, a->vd);
954     } else {
955         neon_load_reg64(tmp, a->vd);
956         gen_aa32_st64(s, tmp, addr, get_mem_index(s));
957     }
958     tcg_temp_free_i64(tmp);
959     tcg_temp_free_i32(addr);
960
961     return true;
962 }
963
964 static bool trans_VLDM_VSTM_sp(DisasContext *s, arg_VLDM_VSTM_sp *a)
965 {
966     uint32_t offset;
967     TCGv_i32 addr, tmp;
968     int i, n;
969
970     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
971         return false;
972     }
973
974     n = a->imm;
975
976     if (n == 0 || (a->vd + n) > 32) {
977         /*
978          * UNPREDICTABLE cases for bad immediates: we choose to
979          * UNDEF to avoid generating huge numbers of TCG ops
980          */
981         return false;
982     }
983     if (a->rn == 15 && a->w) {
984         /* writeback to PC is UNPREDICTABLE, we choose to UNDEF */
985         return false;
986     }
987
988     if (!vfp_access_check(s)) {
989         return true;
990     }
991
992     /* For thumb, use of PC is UNPREDICTABLE.  */
993     addr = add_reg_for_lit(s, a->rn, 0);
994     if (a->p) {
995         /* pre-decrement */
996         tcg_gen_addi_i32(addr, addr, -(a->imm << 2));
997     }
998
999     if (s->v8m_stackcheck && a->rn == 13 && a->w) {
1000         /*
1001          * Here 'addr' is the lowest address we will store to,
1002          * and is either the old SP (if post-increment) or
1003          * the new SP (if pre-decrement). For post-increment
1004          * where the old value is below the limit and the new
1005          * value is above, it is UNKNOWN whether the limit check
1006          * triggers; we choose to trigger.
1007          */
1008         gen_helper_v8m_stackcheck(cpu_env, addr);
1009     }
1010
1011     offset = 4;
1012     tmp = tcg_temp_new_i32();
1013     for (i = 0; i < n; i++) {
1014         if (a->l) {
1015             /* load */
1016             gen_aa32_ld32u(s, tmp, addr, get_mem_index(s));
1017             neon_store_reg32(tmp, a->vd + i);
1018         } else {
1019             /* store */
1020             neon_load_reg32(tmp, a->vd + i);
1021             gen_aa32_st32(s, tmp, addr, get_mem_index(s));
1022         }
1023         tcg_gen_addi_i32(addr, addr, offset);
1024     }
1025     tcg_temp_free_i32(tmp);
1026     if (a->w) {
1027         /* writeback */
1028         if (a->p) {
1029             offset = -offset * n;
1030             tcg_gen_addi_i32(addr, addr, offset);
1031         }
1032         store_reg(s, a->rn, addr);
1033     } else {
1034         tcg_temp_free_i32(addr);
1035     }
1036
1037     return true;
1038 }
1039
1040 static bool trans_VLDM_VSTM_dp(DisasContext *s, arg_VLDM_VSTM_dp *a)
1041 {
1042     uint32_t offset;
1043     TCGv_i32 addr;
1044     TCGv_i64 tmp;
1045     int i, n;
1046
1047     /* Note that this does not require support for double arithmetic.  */
1048     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
1049         return false;
1050     }
1051
1052     n = a->imm >> 1;
1053
1054     if (n == 0 || (a->vd + n) > 32 || n > 16) {
1055         /*
1056          * UNPREDICTABLE cases for bad immediates: we choose to
1057          * UNDEF to avoid generating huge numbers of TCG ops
1058          */
1059         return false;
1060     }
1061     if (a->rn == 15 && a->w) {
1062         /* writeback to PC is UNPREDICTABLE, we choose to UNDEF */
1063         return false;
1064     }
1065
1066     /* UNDEF accesses to D16-D31 if they don't exist */
1067     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vd + n) > 16) {
1068         return false;
1069     }
1070
1071     if (!vfp_access_check(s)) {
1072         return true;
1073     }
1074
1075     /* For thumb, use of PC is UNPREDICTABLE.  */
1076     addr = add_reg_for_lit(s, a->rn, 0);
1077     if (a->p) {
1078         /* pre-decrement */
1079         tcg_gen_addi_i32(addr, addr, -(a->imm << 2));
1080     }
1081
1082     if (s->v8m_stackcheck && a->rn == 13 && a->w) {
1083         /*
1084          * Here 'addr' is the lowest address we will store to,
1085          * and is either the old SP (if post-increment) or
1086          * the new SP (if pre-decrement). For post-increment
1087          * where the old value is below the limit and the new
1088          * value is above, it is UNKNOWN whether the limit check
1089          * triggers; we choose to trigger.
1090          */
1091         gen_helper_v8m_stackcheck(cpu_env, addr);
1092     }
1093
1094     offset = 8;
1095     tmp = tcg_temp_new_i64();
1096     for (i = 0; i < n; i++) {
1097         if (a->l) {
1098             /* load */
1099             gen_aa32_ld64(s, tmp, addr, get_mem_index(s));
1100             neon_store_reg64(tmp, a->vd + i);
1101         } else {
1102             /* store */
1103             neon_load_reg64(tmp, a->vd + i);
1104             gen_aa32_st64(s, tmp, addr, get_mem_index(s));
1105         }
1106         tcg_gen_addi_i32(addr, addr, offset);
1107     }
1108     tcg_temp_free_i64(tmp);
1109     if (a->w) {
1110         /* writeback */
1111         if (a->p) {
1112             offset = -offset * n;
1113         } else if (a->imm & 1) {
1114             offset = 4;
1115         } else {
1116             offset = 0;
1117         }
1118
1119         if (offset != 0) {
1120             tcg_gen_addi_i32(addr, addr, offset);
1121         }
1122         store_reg(s, a->rn, addr);
1123     } else {
1124         tcg_temp_free_i32(addr);
1125     }
1126
1127     return true;
1128 }
1129
1130 /*
1131  * Types for callbacks for do_vfp_3op_sp() and do_vfp_3op_dp().
1132  * The callback should emit code to write a value to vd. If
1133  * do_vfp_3op_{sp,dp}() was passed reads_vd then the TCGv vd
1134  * will contain the old value of the relevant VFP register;
1135  * otherwise it must be written to only.
1136  */
1137 typedef void VFPGen3OpSPFn(TCGv_i32 vd,
1138                            TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst);
1139 typedef void VFPGen3OpDPFn(TCGv_i64 vd,
1140                            TCGv_i64 vn, TCGv_i64 vm, TCGv_ptr fpst);
1141
1142 /*
1143  * Types for callbacks for do_vfp_2op_sp() and do_vfp_2op_dp().
1144  * The callback should emit code to write a value to vd (which
1145  * should be written to only).
1146  */
1147 typedef void VFPGen2OpSPFn(TCGv_i32 vd, TCGv_i32 vm);
1148 typedef void VFPGen2OpDPFn(TCGv_i64 vd, TCGv_i64 vm);
1149
1150 /*
1151  * Return true if the specified S reg is in a scalar bank
1152  * (ie if it is s0..s7)
1153  */
1154 static inline bool vfp_sreg_is_scalar(int reg)
1155 {
1156     return (reg & 0x18) == 0;
1157 }
1158
1159 /*
1160  * Return true if the specified D reg is in a scalar bank
1161  * (ie if it is d0..d3 or d16..d19)
1162  */
1163 static inline bool vfp_dreg_is_scalar(int reg)
1164 {
1165     return (reg & 0xc) == 0;
1166 }
1167
1168 /*
1169  * Advance the S reg number forwards by delta within its bank
1170  * (ie increment the low 3 bits but leave the rest the same)
1171  */
1172 static inline int vfp_advance_sreg(int reg, int delta)
1173 {
1174     return ((reg + delta) & 0x7) | (reg & ~0x7);
1175 }
1176
1177 /*
1178  * Advance the D reg number forwards by delta within its bank
1179  * (ie increment the low 2 bits but leave the rest the same)
1180  */
1181 static inline int vfp_advance_dreg(int reg, int delta)
1182 {
1183     return ((reg + delta) & 0x3) | (reg & ~0x3);
1184 }
1185
1186 /*
1187  * Perform a 3-operand VFP data processing instruction. fn is the
1188  * callback to do the actual operation; this function deals with the
1189  * code to handle looping around for VFP vector processing.
1190  */
1191 static bool do_vfp_3op_sp(DisasContext *s, VFPGen3OpSPFn *fn,
1192                           int vd, int vn, int vm, bool reads_vd)
1193 {
1194     uint32_t delta_m = 0;
1195     uint32_t delta_d = 0;
1196     int veclen = s->vec_len;
1197     TCGv_i32 f0, f1, fd;
1198     TCGv_ptr fpst;
1199
1200     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
1201         return false;
1202     }
1203
1204     if (!dc_isar_feature(aa32_fpshvec, s) &&
1205         (veclen != 0 || s->vec_stride != 0)) {
1206         return false;
1207     }
1208
1209     if (!vfp_access_check(s)) {
1210         return true;
1211     }
1212
1213     if (veclen > 0) {
1214         /* Figure out what type of vector operation this is.  */
1215         if (vfp_sreg_is_scalar(vd)) {
1216             /* scalar */
1217             veclen = 0;
1218         } else {
1219             delta_d = s->vec_stride + 1;
1220
1221             if (vfp_sreg_is_scalar(vm)) {
1222                 /* mixed scalar/vector */
1223                 delta_m = 0;
1224             } else {
1225                 /* vector */
1226                 delta_m = delta_d;
1227             }
1228         }
1229     }
1230
1231     f0 = tcg_temp_new_i32();
1232     f1 = tcg_temp_new_i32();
1233     fd = tcg_temp_new_i32();
1234     fpst = fpstatus_ptr(FPST_FPCR);
1235
1236     neon_load_reg32(f0, vn);
1237     neon_load_reg32(f1, vm);
1238
1239     for (;;) {
1240         if (reads_vd) {
1241             neon_load_reg32(fd, vd);
1242         }
1243         fn(fd, f0, f1, fpst);
1244         neon_store_reg32(fd, vd);
1245
1246         if (veclen == 0) {
1247             break;
1248         }
1249
1250         /* Set up the operands for the next iteration */
1251         veclen--;
1252         vd = vfp_advance_sreg(vd, delta_d);
1253         vn = vfp_advance_sreg(vn, delta_d);
1254         neon_load_reg32(f0, vn);
1255         if (delta_m) {
1256             vm = vfp_advance_sreg(vm, delta_m);
1257             neon_load_reg32(f1, vm);
1258         }
1259     }
1260
1261     tcg_temp_free_i32(f0);
1262     tcg_temp_free_i32(f1);
1263     tcg_temp_free_i32(fd);
1264     tcg_temp_free_ptr(fpst);
1265
1266     return true;
1267 }
1268
1269 static bool do_vfp_3op_hp(DisasContext *s, VFPGen3OpSPFn *fn,
1270                           int vd, int vn, int vm, bool reads_vd)
1271 {
1272     /*
1273      * Do a half-precision operation. Functionally this is
1274      * the same as do_vfp_3op_sp(), except:
1275      *  - it uses the FPST_FPCR_F16
1276      *  - it doesn't need the VFP vector handling (fp16 is a
1277      *    v8 feature, and in v8 VFP vectors don't exist)
1278      *  - it does the aa32_fp16_arith feature test
1279      */
1280     TCGv_i32 f0, f1, fd;
1281     TCGv_ptr fpst;
1282
1283     if (!dc_isar_feature(aa32_fp16_arith, s)) {
1284         return false;
1285     }
1286
1287     if (s->vec_len != 0 || s->vec_stride != 0) {
1288         return false;
1289     }
1290
1291     if (!vfp_access_check(s)) {
1292         return true;
1293     }
1294
1295     f0 = tcg_temp_new_i32();
1296     f1 = tcg_temp_new_i32();
1297     fd = tcg_temp_new_i32();
1298     fpst = fpstatus_ptr(FPST_FPCR_F16);
1299
1300     neon_load_reg32(f0, vn);
1301     neon_load_reg32(f1, vm);
1302
1303     if (reads_vd) {
1304         neon_load_reg32(fd, vd);
1305     }
1306     fn(fd, f0, f1, fpst);
1307     neon_store_reg32(fd, vd);
1308
1309     tcg_temp_free_i32(f0);
1310     tcg_temp_free_i32(f1);
1311     tcg_temp_free_i32(fd);
1312     tcg_temp_free_ptr(fpst);
1313
1314     return true;
1315 }
1316
1317 static bool do_vfp_3op_dp(DisasContext *s, VFPGen3OpDPFn *fn,
1318                           int vd, int vn, int vm, bool reads_vd)
1319 {
1320     uint32_t delta_m = 0;
1321     uint32_t delta_d = 0;
1322     int veclen = s->vec_len;
1323     TCGv_i64 f0, f1, fd;
1324     TCGv_ptr fpst;
1325
1326     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
1327         return false;
1328     }
1329
1330     /* UNDEF accesses to D16-D31 if they don't exist */
1331     if (!dc_isar_feature(aa32_simd_r32, s) && ((vd | vn | vm) & 0x10)) {
1332         return false;
1333     }
1334
1335     if (!dc_isar_feature(aa32_fpshvec, s) &&
1336         (veclen != 0 || s->vec_stride != 0)) {
1337         return false;
1338     }
1339
1340     if (!vfp_access_check(s)) {
1341         return true;
1342     }
1343
1344     if (veclen > 0) {
1345         /* Figure out what type of vector operation this is.  */
1346         if (vfp_dreg_is_scalar(vd)) {
1347             /* scalar */
1348             veclen = 0;
1349         } else {
1350             delta_d = (s->vec_stride >> 1) + 1;
1351
1352             if (vfp_dreg_is_scalar(vm)) {
1353                 /* mixed scalar/vector */
1354                 delta_m = 0;
1355             } else {
1356                 /* vector */
1357                 delta_m = delta_d;
1358             }
1359         }
1360     }
1361
1362     f0 = tcg_temp_new_i64();
1363     f1 = tcg_temp_new_i64();
1364     fd = tcg_temp_new_i64();
1365     fpst = fpstatus_ptr(FPST_FPCR);
1366
1367     neon_load_reg64(f0, vn);
1368     neon_load_reg64(f1, vm);
1369
1370     for (;;) {
1371         if (reads_vd) {
1372             neon_load_reg64(fd, vd);
1373         }
1374         fn(fd, f0, f1, fpst);
1375         neon_store_reg64(fd, vd);
1376
1377         if (veclen == 0) {
1378             break;
1379         }
1380         /* Set up the operands for the next iteration */
1381         veclen--;
1382         vd = vfp_advance_dreg(vd, delta_d);
1383         vn = vfp_advance_dreg(vn, delta_d);
1384         neon_load_reg64(f0, vn);
1385         if (delta_m) {
1386             vm = vfp_advance_dreg(vm, delta_m);
1387             neon_load_reg64(f1, vm);
1388         }
1389     }
1390
1391     tcg_temp_free_i64(f0);
1392     tcg_temp_free_i64(f1);
1393     tcg_temp_free_i64(fd);
1394     tcg_temp_free_ptr(fpst);
1395
1396     return true;
1397 }
1398
1399 static bool do_vfp_2op_sp(DisasContext *s, VFPGen2OpSPFn *fn, int vd, int vm)
1400 {
1401     uint32_t delta_m = 0;
1402     uint32_t delta_d = 0;
1403     int veclen = s->vec_len;
1404     TCGv_i32 f0, fd;
1405
1406     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
1407         return false;
1408     }
1409
1410     if (!dc_isar_feature(aa32_fpshvec, s) &&
1411         (veclen != 0 || s->vec_stride != 0)) {
1412         return false;
1413     }
1414
1415     if (!vfp_access_check(s)) {
1416         return true;
1417     }
1418
1419     if (veclen > 0) {
1420         /* Figure out what type of vector operation this is.  */
1421         if (vfp_sreg_is_scalar(vd)) {
1422             /* scalar */
1423             veclen = 0;
1424         } else {
1425             delta_d = s->vec_stride + 1;
1426
1427             if (vfp_sreg_is_scalar(vm)) {
1428                 /* mixed scalar/vector */
1429                 delta_m = 0;
1430             } else {
1431                 /* vector */
1432                 delta_m = delta_d;
1433             }
1434         }
1435     }
1436
1437     f0 = tcg_temp_new_i32();
1438     fd = tcg_temp_new_i32();
1439
1440     neon_load_reg32(f0, vm);
1441
1442     for (;;) {
1443         fn(fd, f0);
1444         neon_store_reg32(fd, vd);
1445
1446         if (veclen == 0) {
1447             break;
1448         }
1449
1450         if (delta_m == 0) {
1451             /* single source one-many */
1452             while (veclen--) {
1453                 vd = vfp_advance_sreg(vd, delta_d);
1454                 neon_store_reg32(fd, vd);
1455             }
1456             break;
1457         }
1458
1459         /* Set up the operands for the next iteration */
1460         veclen--;
1461         vd = vfp_advance_sreg(vd, delta_d);
1462         vm = vfp_advance_sreg(vm, delta_m);
1463         neon_load_reg32(f0, vm);
1464     }
1465
1466     tcg_temp_free_i32(f0);
1467     tcg_temp_free_i32(fd);
1468
1469     return true;
1470 }
1471
1472 static bool do_vfp_2op_dp(DisasContext *s, VFPGen2OpDPFn *fn, int vd, int vm)
1473 {
1474     uint32_t delta_m = 0;
1475     uint32_t delta_d = 0;
1476     int veclen = s->vec_len;
1477     TCGv_i64 f0, fd;
1478
1479     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
1480         return false;
1481     }
1482
1483     /* UNDEF accesses to D16-D31 if they don't exist */
1484     if (!dc_isar_feature(aa32_simd_r32, s) && ((vd | vm) & 0x10)) {
1485         return false;
1486     }
1487
1488     if (!dc_isar_feature(aa32_fpshvec, s) &&
1489         (veclen != 0 || s->vec_stride != 0)) {
1490         return false;
1491     }
1492
1493     if (!vfp_access_check(s)) {
1494         return true;
1495     }
1496
1497     if (veclen > 0) {
1498         /* Figure out what type of vector operation this is.  */
1499         if (vfp_dreg_is_scalar(vd)) {
1500             /* scalar */
1501             veclen = 0;
1502         } else {
1503             delta_d = (s->vec_stride >> 1) + 1;
1504
1505             if (vfp_dreg_is_scalar(vm)) {
1506                 /* mixed scalar/vector */
1507                 delta_m = 0;
1508             } else {
1509                 /* vector */
1510                 delta_m = delta_d;
1511             }
1512         }
1513     }
1514
1515     f0 = tcg_temp_new_i64();
1516     fd = tcg_temp_new_i64();
1517
1518     neon_load_reg64(f0, vm);
1519
1520     for (;;) {
1521         fn(fd, f0);
1522         neon_store_reg64(fd, vd);
1523
1524         if (veclen == 0) {
1525             break;
1526         }
1527
1528         if (delta_m == 0) {
1529             /* single source one-many */
1530             while (veclen--) {
1531                 vd = vfp_advance_dreg(vd, delta_d);
1532                 neon_store_reg64(fd, vd);
1533             }
1534             break;
1535         }
1536
1537         /* Set up the operands for the next iteration */
1538         veclen--;
1539         vd = vfp_advance_dreg(vd, delta_d);
1540         vd = vfp_advance_dreg(vm, delta_m);
1541         neon_load_reg64(f0, vm);
1542     }
1543
1544     tcg_temp_free_i64(f0);
1545     tcg_temp_free_i64(fd);
1546
1547     return true;
1548 }
1549
1550 static void gen_VMLA_hp(TCGv_i32 vd, TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst)
1551 {
1552     /* Note that order of inputs to the add matters for NaNs */
1553     TCGv_i32 tmp = tcg_temp_new_i32();
1554
1555     gen_helper_vfp_mulh(tmp, vn, vm, fpst);
1556     gen_helper_vfp_addh(vd, vd, tmp, fpst);
1557     tcg_temp_free_i32(tmp);
1558 }
1559
1560 static bool trans_VMLA_hp(DisasContext *s, arg_VMLA_sp *a)
1561 {
1562     return do_vfp_3op_hp(s, gen_VMLA_hp, a->vd, a->vn, a->vm, true);
1563 }
1564
1565 static void gen_VMLA_sp(TCGv_i32 vd, TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst)
1566 {
1567     /* Note that order of inputs to the add matters for NaNs */
1568     TCGv_i32 tmp = tcg_temp_new_i32();
1569
1570     gen_helper_vfp_muls(tmp, vn, vm, fpst);
1571     gen_helper_vfp_adds(vd, vd, tmp, fpst);
1572     tcg_temp_free_i32(tmp);
1573 }
1574
1575 static bool trans_VMLA_sp(DisasContext *s, arg_VMLA_sp *a)
1576 {
1577     return do_vfp_3op_sp(s, gen_VMLA_sp, a->vd, a->vn, a->vm, true);
1578 }
1579
1580 static void gen_VMLA_dp(TCGv_i64 vd, TCGv_i64 vn, TCGv_i64 vm, TCGv_ptr fpst)
1581 {
1582     /* Note that order of inputs to the add matters for NaNs */
1583     TCGv_i64 tmp = tcg_temp_new_i64();
1584
1585     gen_helper_vfp_muld(tmp, vn, vm, fpst);
1586     gen_helper_vfp_addd(vd, vd, tmp, fpst);
1587     tcg_temp_free_i64(tmp);
1588 }
1589
1590 static bool trans_VMLA_dp(DisasContext *s, arg_VMLA_dp *a)
1591 {
1592     return do_vfp_3op_dp(s, gen_VMLA_dp, a->vd, a->vn, a->vm, true);
1593 }
1594
1595 static void gen_VMLS_hp(TCGv_i32 vd, TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst)
1596 {
1597     /*
1598      * VMLS: vd = vd + -(vn * vm)
1599      * Note that order of inputs to the add matters for NaNs.
1600      */
1601     TCGv_i32 tmp = tcg_temp_new_i32();
1602
1603     gen_helper_vfp_mulh(tmp, vn, vm, fpst);
1604     gen_helper_vfp_negh(tmp, tmp);
1605     gen_helper_vfp_addh(vd, vd, tmp, fpst);
1606     tcg_temp_free_i32(tmp);
1607 }
1608
1609 static bool trans_VMLS_hp(DisasContext *s, arg_VMLS_sp *a)
1610 {
1611     return do_vfp_3op_hp(s, gen_VMLS_hp, a->vd, a->vn, a->vm, true);
1612 }
1613
1614 static void gen_VMLS_sp(TCGv_i32 vd, TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst)
1615 {
1616     /*
1617      * VMLS: vd = vd + -(vn * vm)
1618      * Note that order of inputs to the add matters for NaNs.
1619      */
1620     TCGv_i32 tmp = tcg_temp_new_i32();
1621
1622     gen_helper_vfp_muls(tmp, vn, vm, fpst);
1623     gen_helper_vfp_negs(tmp, tmp);
1624     gen_helper_vfp_adds(vd, vd, tmp, fpst);
1625     tcg_temp_free_i32(tmp);
1626 }
1627
1628 static bool trans_VMLS_sp(DisasContext *s, arg_VMLS_sp *a)
1629 {
1630     return do_vfp_3op_sp(s, gen_VMLS_sp, a->vd, a->vn, a->vm, true);
1631 }
1632
1633 static void gen_VMLS_dp(TCGv_i64 vd, TCGv_i64 vn, TCGv_i64 vm, TCGv_ptr fpst)
1634 {
1635     /*
1636      * VMLS: vd = vd + -(vn * vm)
1637      * Note that order of inputs to the add matters for NaNs.
1638      */
1639     TCGv_i64 tmp = tcg_temp_new_i64();
1640
1641     gen_helper_vfp_muld(tmp, vn, vm, fpst);
1642     gen_helper_vfp_negd(tmp, tmp);
1643     gen_helper_vfp_addd(vd, vd, tmp, fpst);
1644     tcg_temp_free_i64(tmp);
1645 }
1646
1647 static bool trans_VMLS_dp(DisasContext *s, arg_VMLS_dp *a)
1648 {
1649     return do_vfp_3op_dp(s, gen_VMLS_dp, a->vd, a->vn, a->vm, true);
1650 }
1651
1652 static void gen_VNMLS_hp(TCGv_i32 vd, TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst)
1653 {
1654     /*
1655      * VNMLS: -fd + (fn * fm)
1656      * Note that it isn't valid to replace (-A + B) with (B - A) or similar
1657      * plausible looking simplifications because this will give wrong results
1658      * for NaNs.
1659      */
1660     TCGv_i32 tmp = tcg_temp_new_i32();
1661
1662     gen_helper_vfp_mulh(tmp, vn, vm, fpst);
1663     gen_helper_vfp_negh(vd, vd);
1664     gen_helper_vfp_addh(vd, vd, tmp, fpst);
1665     tcg_temp_free_i32(tmp);
1666 }
1667
1668 static bool trans_VNMLS_hp(DisasContext *s, arg_VNMLS_sp *a)
1669 {
1670     return do_vfp_3op_hp(s, gen_VNMLS_hp, a->vd, a->vn, a->vm, true);
1671 }
1672
1673 static void gen_VNMLS_sp(TCGv_i32 vd, TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst)
1674 {
1675     /*
1676      * VNMLS: -fd + (fn * fm)
1677      * Note that it isn't valid to replace (-A + B) with (B - A) or similar
1678      * plausible looking simplifications because this will give wrong results
1679      * for NaNs.
1680      */
1681     TCGv_i32 tmp = tcg_temp_new_i32();
1682
1683     gen_helper_vfp_muls(tmp, vn, vm, fpst);
1684     gen_helper_vfp_negs(vd, vd);
1685     gen_helper_vfp_adds(vd, vd, tmp, fpst);
1686     tcg_temp_free_i32(tmp);
1687 }
1688
1689 static bool trans_VNMLS_sp(DisasContext *s, arg_VNMLS_sp *a)
1690 {
1691     return do_vfp_3op_sp(s, gen_VNMLS_sp, a->vd, a->vn, a->vm, true);
1692 }
1693
1694 static void gen_VNMLS_dp(TCGv_i64 vd, TCGv_i64 vn, TCGv_i64 vm, TCGv_ptr fpst)
1695 {
1696     /*
1697      * VNMLS: -fd + (fn * fm)
1698      * Note that it isn't valid to replace (-A + B) with (B - A) or similar
1699      * plausible looking simplifications because this will give wrong results
1700      * for NaNs.
1701      */
1702     TCGv_i64 tmp = tcg_temp_new_i64();
1703
1704     gen_helper_vfp_muld(tmp, vn, vm, fpst);
1705     gen_helper_vfp_negd(vd, vd);
1706     gen_helper_vfp_addd(vd, vd, tmp, fpst);
1707     tcg_temp_free_i64(tmp);
1708 }
1709
1710 static bool trans_VNMLS_dp(DisasContext *s, arg_VNMLS_dp *a)
1711 {
1712     return do_vfp_3op_dp(s, gen_VNMLS_dp, a->vd, a->vn, a->vm, true);
1713 }
1714
1715 static void gen_VNMLA_hp(TCGv_i32 vd, TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst)
1716 {
1717     /* VNMLA: -fd + -(fn * fm) */
1718     TCGv_i32 tmp = tcg_temp_new_i32();
1719
1720     gen_helper_vfp_mulh(tmp, vn, vm, fpst);
1721     gen_helper_vfp_negh(tmp, tmp);
1722     gen_helper_vfp_negh(vd, vd);
1723     gen_helper_vfp_addh(vd, vd, tmp, fpst);
1724     tcg_temp_free_i32(tmp);
1725 }
1726
1727 static bool trans_VNMLA_hp(DisasContext *s, arg_VNMLA_sp *a)
1728 {
1729     return do_vfp_3op_hp(s, gen_VNMLA_hp, a->vd, a->vn, a->vm, true);
1730 }
1731
1732 static void gen_VNMLA_sp(TCGv_i32 vd, TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst)
1733 {
1734     /* VNMLA: -fd + -(fn * fm) */
1735     TCGv_i32 tmp = tcg_temp_new_i32();
1736
1737     gen_helper_vfp_muls(tmp, vn, vm, fpst);
1738     gen_helper_vfp_negs(tmp, tmp);
1739     gen_helper_vfp_negs(vd, vd);
1740     gen_helper_vfp_adds(vd, vd, tmp, fpst);
1741     tcg_temp_free_i32(tmp);
1742 }
1743
1744 static bool trans_VNMLA_sp(DisasContext *s, arg_VNMLA_sp *a)
1745 {
1746     return do_vfp_3op_sp(s, gen_VNMLA_sp, a->vd, a->vn, a->vm, true);
1747 }
1748
1749 static void gen_VNMLA_dp(TCGv_i64 vd, TCGv_i64 vn, TCGv_i64 vm, TCGv_ptr fpst)
1750 {
1751     /* VNMLA: -fd + (fn * fm) */
1752     TCGv_i64 tmp = tcg_temp_new_i64();
1753
1754     gen_helper_vfp_muld(tmp, vn, vm, fpst);
1755     gen_helper_vfp_negd(tmp, tmp);
1756     gen_helper_vfp_negd(vd, vd);
1757     gen_helper_vfp_addd(vd, vd, tmp, fpst);
1758     tcg_temp_free_i64(tmp);
1759 }
1760
1761 static bool trans_VNMLA_dp(DisasContext *s, arg_VNMLA_dp *a)
1762 {
1763     return do_vfp_3op_dp(s, gen_VNMLA_dp, a->vd, a->vn, a->vm, true);
1764 }
1765
1766 static bool trans_VMUL_hp(DisasContext *s, arg_VMUL_sp *a)
1767 {
1768     return do_vfp_3op_hp(s, gen_helper_vfp_mulh, a->vd, a->vn, a->vm, false);
1769 }
1770
1771 static bool trans_VMUL_sp(DisasContext *s, arg_VMUL_sp *a)
1772 {
1773     return do_vfp_3op_sp(s, gen_helper_vfp_muls, a->vd, a->vn, a->vm, false);
1774 }
1775
1776 static bool trans_VMUL_dp(DisasContext *s, arg_VMUL_dp *a)
1777 {
1778     return do_vfp_3op_dp(s, gen_helper_vfp_muld, a->vd, a->vn, a->vm, false);
1779 }
1780
1781 static void gen_VNMUL_hp(TCGv_i32 vd, TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst)
1782 {
1783     /* VNMUL: -(fn * fm) */
1784     gen_helper_vfp_mulh(vd, vn, vm, fpst);
1785     gen_helper_vfp_negh(vd, vd);
1786 }
1787
1788 static bool trans_VNMUL_hp(DisasContext *s, arg_VNMUL_sp *a)
1789 {
1790     return do_vfp_3op_hp(s, gen_VNMUL_hp, a->vd, a->vn, a->vm, false);
1791 }
1792
1793 static void gen_VNMUL_sp(TCGv_i32 vd, TCGv_i32 vn, TCGv_i32 vm, TCGv_ptr fpst)
1794 {
1795     /* VNMUL: -(fn * fm) */
1796     gen_helper_vfp_muls(vd, vn, vm, fpst);
1797     gen_helper_vfp_negs(vd, vd);
1798 }
1799
1800 static bool trans_VNMUL_sp(DisasContext *s, arg_VNMUL_sp *a)
1801 {
1802     return do_vfp_3op_sp(s, gen_VNMUL_sp, a->vd, a->vn, a->vm, false);
1803 }
1804
1805 static void gen_VNMUL_dp(TCGv_i64 vd, TCGv_i64 vn, TCGv_i64 vm, TCGv_ptr fpst)
1806 {
1807     /* VNMUL: -(fn * fm) */
1808     gen_helper_vfp_muld(vd, vn, vm, fpst);
1809     gen_helper_vfp_negd(vd, vd);
1810 }
1811
1812 static bool trans_VNMUL_dp(DisasContext *s, arg_VNMUL_dp *a)
1813 {
1814     return do_vfp_3op_dp(s, gen_VNMUL_dp, a->vd, a->vn, a->vm, false);
1815 }
1816
1817 static bool trans_VADD_hp(DisasContext *s, arg_VADD_sp *a)
1818 {
1819     return do_vfp_3op_hp(s, gen_helper_vfp_addh, a->vd, a->vn, a->vm, false);
1820 }
1821
1822 static bool trans_VADD_sp(DisasContext *s, arg_VADD_sp *a)
1823 {
1824     return do_vfp_3op_sp(s, gen_helper_vfp_adds, a->vd, a->vn, a->vm, false);
1825 }
1826
1827 static bool trans_VADD_dp(DisasContext *s, arg_VADD_dp *a)
1828 {
1829     return do_vfp_3op_dp(s, gen_helper_vfp_addd, a->vd, a->vn, a->vm, false);
1830 }
1831
1832 static bool trans_VSUB_hp(DisasContext *s, arg_VSUB_sp *a)
1833 {
1834     return do_vfp_3op_hp(s, gen_helper_vfp_subh, a->vd, a->vn, a->vm, false);
1835 }
1836
1837 static bool trans_VSUB_sp(DisasContext *s, arg_VSUB_sp *a)
1838 {
1839     return do_vfp_3op_sp(s, gen_helper_vfp_subs, a->vd, a->vn, a->vm, false);
1840 }
1841
1842 static bool trans_VSUB_dp(DisasContext *s, arg_VSUB_dp *a)
1843 {
1844     return do_vfp_3op_dp(s, gen_helper_vfp_subd, a->vd, a->vn, a->vm, false);
1845 }
1846
1847 static bool trans_VDIV_hp(DisasContext *s, arg_VDIV_sp *a)
1848 {
1849     return do_vfp_3op_hp(s, gen_helper_vfp_divh, a->vd, a->vn, a->vm, false);
1850 }
1851
1852 static bool trans_VDIV_sp(DisasContext *s, arg_VDIV_sp *a)
1853 {
1854     return do_vfp_3op_sp(s, gen_helper_vfp_divs, a->vd, a->vn, a->vm, false);
1855 }
1856
1857 static bool trans_VDIV_dp(DisasContext *s, arg_VDIV_dp *a)
1858 {
1859     return do_vfp_3op_dp(s, gen_helper_vfp_divd, a->vd, a->vn, a->vm, false);
1860 }
1861
1862 static bool trans_VMINNM_hp(DisasContext *s, arg_VMINNM_sp *a)
1863 {
1864     if (!dc_isar_feature(aa32_vminmaxnm, s)) {
1865         return false;
1866     }
1867     return do_vfp_3op_hp(s, gen_helper_vfp_minnumh,
1868                          a->vd, a->vn, a->vm, false);
1869 }
1870
1871 static bool trans_VMAXNM_hp(DisasContext *s, arg_VMAXNM_sp *a)
1872 {
1873     if (!dc_isar_feature(aa32_vminmaxnm, s)) {
1874         return false;
1875     }
1876     return do_vfp_3op_hp(s, gen_helper_vfp_maxnumh,
1877                          a->vd, a->vn, a->vm, false);
1878 }
1879
1880 static bool trans_VMINNM_sp(DisasContext *s, arg_VMINNM_sp *a)
1881 {
1882     if (!dc_isar_feature(aa32_vminmaxnm, s)) {
1883         return false;
1884     }
1885     return do_vfp_3op_sp(s, gen_helper_vfp_minnums,
1886                          a->vd, a->vn, a->vm, false);
1887 }
1888
1889 static bool trans_VMAXNM_sp(DisasContext *s, arg_VMAXNM_sp *a)
1890 {
1891     if (!dc_isar_feature(aa32_vminmaxnm, s)) {
1892         return false;
1893     }
1894     return do_vfp_3op_sp(s, gen_helper_vfp_maxnums,
1895                          a->vd, a->vn, a->vm, false);
1896 }
1897
1898 static bool trans_VMINNM_dp(DisasContext *s, arg_VMINNM_dp *a)
1899 {
1900     if (!dc_isar_feature(aa32_vminmaxnm, s)) {
1901         return false;
1902     }
1903     return do_vfp_3op_dp(s, gen_helper_vfp_minnumd,
1904                          a->vd, a->vn, a->vm, false);
1905 }
1906
1907 static bool trans_VMAXNM_dp(DisasContext *s, arg_VMAXNM_dp *a)
1908 {
1909     if (!dc_isar_feature(aa32_vminmaxnm, s)) {
1910         return false;
1911     }
1912     return do_vfp_3op_dp(s, gen_helper_vfp_maxnumd,
1913                          a->vd, a->vn, a->vm, false);
1914 }
1915
1916 static bool do_vfm_hp(DisasContext *s, arg_VFMA_sp *a, bool neg_n, bool neg_d)
1917 {
1918     /*
1919      * VFNMA : fd = muladd(-fd,  fn, fm)
1920      * VFNMS : fd = muladd(-fd, -fn, fm)
1921      * VFMA  : fd = muladd( fd,  fn, fm)
1922      * VFMS  : fd = muladd( fd, -fn, fm)
1923      *
1924      * These are fused multiply-add, and must be done as one floating
1925      * point operation with no rounding between the multiplication and
1926      * addition steps.  NB that doing the negations here as separate
1927      * steps is correct : an input NaN should come out with its sign
1928      * bit flipped if it is a negated-input.
1929      */
1930     TCGv_ptr fpst;
1931     TCGv_i32 vn, vm, vd;
1932
1933     /*
1934      * Present in VFPv4 only, and only with the FP16 extension.
1935      * Note that we can't rely on the SIMDFMAC check alone, because
1936      * in a Neon-no-VFP core that ID register field will be non-zero.
1937      */
1938     if (!dc_isar_feature(aa32_fp16_arith, s) ||
1939         !dc_isar_feature(aa32_simdfmac, s) ||
1940         !dc_isar_feature(aa32_fpsp_v2, s)) {
1941         return false;
1942     }
1943
1944     if (s->vec_len != 0 || s->vec_stride != 0) {
1945         return false;
1946     }
1947
1948     if (!vfp_access_check(s)) {
1949         return true;
1950     }
1951
1952     vn = tcg_temp_new_i32();
1953     vm = tcg_temp_new_i32();
1954     vd = tcg_temp_new_i32();
1955
1956     neon_load_reg32(vn, a->vn);
1957     neon_load_reg32(vm, a->vm);
1958     if (neg_n) {
1959         /* VFNMS, VFMS */
1960         gen_helper_vfp_negh(vn, vn);
1961     }
1962     neon_load_reg32(vd, a->vd);
1963     if (neg_d) {
1964         /* VFNMA, VFNMS */
1965         gen_helper_vfp_negh(vd, vd);
1966     }
1967     fpst = fpstatus_ptr(FPST_FPCR_F16);
1968     gen_helper_vfp_muladdh(vd, vn, vm, vd, fpst);
1969     neon_store_reg32(vd, a->vd);
1970
1971     tcg_temp_free_ptr(fpst);
1972     tcg_temp_free_i32(vn);
1973     tcg_temp_free_i32(vm);
1974     tcg_temp_free_i32(vd);
1975
1976     return true;
1977 }
1978
1979 static bool do_vfm_sp(DisasContext *s, arg_VFMA_sp *a, bool neg_n, bool neg_d)
1980 {
1981     /*
1982      * VFNMA : fd = muladd(-fd,  fn, fm)
1983      * VFNMS : fd = muladd(-fd, -fn, fm)
1984      * VFMA  : fd = muladd( fd,  fn, fm)
1985      * VFMS  : fd = muladd( fd, -fn, fm)
1986      *
1987      * These are fused multiply-add, and must be done as one floating
1988      * point operation with no rounding between the multiplication and
1989      * addition steps.  NB that doing the negations here as separate
1990      * steps is correct : an input NaN should come out with its sign
1991      * bit flipped if it is a negated-input.
1992      */
1993     TCGv_ptr fpst;
1994     TCGv_i32 vn, vm, vd;
1995
1996     /*
1997      * Present in VFPv4 only.
1998      * Note that we can't rely on the SIMDFMAC check alone, because
1999      * in a Neon-no-VFP core that ID register field will be non-zero.
2000      */
2001     if (!dc_isar_feature(aa32_simdfmac, s) ||
2002         !dc_isar_feature(aa32_fpsp_v2, s)) {
2003         return false;
2004     }
2005     /*
2006      * In v7A, UNPREDICTABLE with non-zero vector length/stride; from
2007      * v8A, must UNDEF. We choose to UNDEF for both v7A and v8A.
2008      */
2009     if (s->vec_len != 0 || s->vec_stride != 0) {
2010         return false;
2011     }
2012
2013     if (!vfp_access_check(s)) {
2014         return true;
2015     }
2016
2017     vn = tcg_temp_new_i32();
2018     vm = tcg_temp_new_i32();
2019     vd = tcg_temp_new_i32();
2020
2021     neon_load_reg32(vn, a->vn);
2022     neon_load_reg32(vm, a->vm);
2023     if (neg_n) {
2024         /* VFNMS, VFMS */
2025         gen_helper_vfp_negs(vn, vn);
2026     }
2027     neon_load_reg32(vd, a->vd);
2028     if (neg_d) {
2029         /* VFNMA, VFNMS */
2030         gen_helper_vfp_negs(vd, vd);
2031     }
2032     fpst = fpstatus_ptr(FPST_FPCR);
2033     gen_helper_vfp_muladds(vd, vn, vm, vd, fpst);
2034     neon_store_reg32(vd, a->vd);
2035
2036     tcg_temp_free_ptr(fpst);
2037     tcg_temp_free_i32(vn);
2038     tcg_temp_free_i32(vm);
2039     tcg_temp_free_i32(vd);
2040
2041     return true;
2042 }
2043
2044 static bool do_vfm_dp(DisasContext *s, arg_VFMA_dp *a, bool neg_n, bool neg_d)
2045 {
2046     /*
2047      * VFNMA : fd = muladd(-fd,  fn, fm)
2048      * VFNMS : fd = muladd(-fd, -fn, fm)
2049      * VFMA  : fd = muladd( fd,  fn, fm)
2050      * VFMS  : fd = muladd( fd, -fn, fm)
2051      *
2052      * These are fused multiply-add, and must be done as one floating
2053      * point operation with no rounding between the multiplication and
2054      * addition steps.  NB that doing the negations here as separate
2055      * steps is correct : an input NaN should come out with its sign
2056      * bit flipped if it is a negated-input.
2057      */
2058     TCGv_ptr fpst;
2059     TCGv_i64 vn, vm, vd;
2060
2061     /*
2062      * Present in VFPv4 only.
2063      * Note that we can't rely on the SIMDFMAC check alone, because
2064      * in a Neon-no-VFP core that ID register field will be non-zero.
2065      */
2066     if (!dc_isar_feature(aa32_simdfmac, s) ||
2067         !dc_isar_feature(aa32_fpdp_v2, s)) {
2068         return false;
2069     }
2070     /*
2071      * In v7A, UNPREDICTABLE with non-zero vector length/stride; from
2072      * v8A, must UNDEF. We choose to UNDEF for both v7A and v8A.
2073      */
2074     if (s->vec_len != 0 || s->vec_stride != 0) {
2075         return false;
2076     }
2077
2078     /* UNDEF accesses to D16-D31 if they don't exist. */
2079     if (!dc_isar_feature(aa32_simd_r32, s) &&
2080         ((a->vd | a->vn | a->vm) & 0x10)) {
2081         return false;
2082     }
2083
2084     if (!vfp_access_check(s)) {
2085         return true;
2086     }
2087
2088     vn = tcg_temp_new_i64();
2089     vm = tcg_temp_new_i64();
2090     vd = tcg_temp_new_i64();
2091
2092     neon_load_reg64(vn, a->vn);
2093     neon_load_reg64(vm, a->vm);
2094     if (neg_n) {
2095         /* VFNMS, VFMS */
2096         gen_helper_vfp_negd(vn, vn);
2097     }
2098     neon_load_reg64(vd, a->vd);
2099     if (neg_d) {
2100         /* VFNMA, VFNMS */
2101         gen_helper_vfp_negd(vd, vd);
2102     }
2103     fpst = fpstatus_ptr(FPST_FPCR);
2104     gen_helper_vfp_muladdd(vd, vn, vm, vd, fpst);
2105     neon_store_reg64(vd, a->vd);
2106
2107     tcg_temp_free_ptr(fpst);
2108     tcg_temp_free_i64(vn);
2109     tcg_temp_free_i64(vm);
2110     tcg_temp_free_i64(vd);
2111
2112     return true;
2113 }
2114
2115 #define MAKE_ONE_VFM_TRANS_FN(INSN, PREC, NEGN, NEGD)                   \
2116     static bool trans_##INSN##_##PREC(DisasContext *s,                  \
2117                                       arg_##INSN##_##PREC *a)           \
2118     {                                                                   \
2119         return do_vfm_##PREC(s, a, NEGN, NEGD);                         \
2120     }
2121
2122 #define MAKE_VFM_TRANS_FNS(PREC) \
2123     MAKE_ONE_VFM_TRANS_FN(VFMA, PREC, false, false) \
2124     MAKE_ONE_VFM_TRANS_FN(VFMS, PREC, true, false) \
2125     MAKE_ONE_VFM_TRANS_FN(VFNMA, PREC, false, true) \
2126     MAKE_ONE_VFM_TRANS_FN(VFNMS, PREC, true, true)
2127
2128 MAKE_VFM_TRANS_FNS(hp)
2129 MAKE_VFM_TRANS_FNS(sp)
2130 MAKE_VFM_TRANS_FNS(dp)
2131
2132 static bool trans_VMOV_imm_sp(DisasContext *s, arg_VMOV_imm_sp *a)
2133 {
2134     uint32_t delta_d = 0;
2135     int veclen = s->vec_len;
2136     TCGv_i32 fd;
2137     uint32_t vd;
2138
2139     vd = a->vd;
2140
2141     if (!dc_isar_feature(aa32_fpsp_v3, s)) {
2142         return false;
2143     }
2144
2145     if (!dc_isar_feature(aa32_fpshvec, s) &&
2146         (veclen != 0 || s->vec_stride != 0)) {
2147         return false;
2148     }
2149
2150     if (!vfp_access_check(s)) {
2151         return true;
2152     }
2153
2154     if (veclen > 0) {
2155         /* Figure out what type of vector operation this is.  */
2156         if (vfp_sreg_is_scalar(vd)) {
2157             /* scalar */
2158             veclen = 0;
2159         } else {
2160             delta_d = s->vec_stride + 1;
2161         }
2162     }
2163
2164     fd = tcg_const_i32(vfp_expand_imm(MO_32, a->imm));
2165
2166     for (;;) {
2167         neon_store_reg32(fd, vd);
2168
2169         if (veclen == 0) {
2170             break;
2171         }
2172
2173         /* Set up the operands for the next iteration */
2174         veclen--;
2175         vd = vfp_advance_sreg(vd, delta_d);
2176     }
2177
2178     tcg_temp_free_i32(fd);
2179     return true;
2180 }
2181
2182 static bool trans_VMOV_imm_dp(DisasContext *s, arg_VMOV_imm_dp *a)
2183 {
2184     uint32_t delta_d = 0;
2185     int veclen = s->vec_len;
2186     TCGv_i64 fd;
2187     uint32_t vd;
2188
2189     vd = a->vd;
2190
2191     if (!dc_isar_feature(aa32_fpdp_v3, s)) {
2192         return false;
2193     }
2194
2195     /* UNDEF accesses to D16-D31 if they don't exist. */
2196     if (!dc_isar_feature(aa32_simd_r32, s) && (vd & 0x10)) {
2197         return false;
2198     }
2199
2200     if (!dc_isar_feature(aa32_fpshvec, s) &&
2201         (veclen != 0 || s->vec_stride != 0)) {
2202         return false;
2203     }
2204
2205     if (!vfp_access_check(s)) {
2206         return true;
2207     }
2208
2209     if (veclen > 0) {
2210         /* Figure out what type of vector operation this is.  */
2211         if (vfp_dreg_is_scalar(vd)) {
2212             /* scalar */
2213             veclen = 0;
2214         } else {
2215             delta_d = (s->vec_stride >> 1) + 1;
2216         }
2217     }
2218
2219     fd = tcg_const_i64(vfp_expand_imm(MO_64, a->imm));
2220
2221     for (;;) {
2222         neon_store_reg64(fd, vd);
2223
2224         if (veclen == 0) {
2225             break;
2226         }
2227
2228         /* Set up the operands for the next iteration */
2229         veclen--;
2230         vd = vfp_advance_dreg(vd, delta_d);
2231     }
2232
2233     tcg_temp_free_i64(fd);
2234     return true;
2235 }
2236
2237 #define DO_VFP_2OP(INSN, PREC, FN)                              \
2238     static bool trans_##INSN##_##PREC(DisasContext *s,          \
2239                                       arg_##INSN##_##PREC *a)   \
2240     {                                                           \
2241         return do_vfp_2op_##PREC(s, FN, a->vd, a->vm);          \
2242     }
2243
2244 DO_VFP_2OP(VMOV_reg, sp, tcg_gen_mov_i32)
2245 DO_VFP_2OP(VMOV_reg, dp, tcg_gen_mov_i64)
2246
2247 DO_VFP_2OP(VABS, sp, gen_helper_vfp_abss)
2248 DO_VFP_2OP(VABS, dp, gen_helper_vfp_absd)
2249
2250 DO_VFP_2OP(VNEG, sp, gen_helper_vfp_negs)
2251 DO_VFP_2OP(VNEG, dp, gen_helper_vfp_negd)
2252
2253 static void gen_VSQRT_sp(TCGv_i32 vd, TCGv_i32 vm)
2254 {
2255     gen_helper_vfp_sqrts(vd, vm, cpu_env);
2256 }
2257
2258 static void gen_VSQRT_dp(TCGv_i64 vd, TCGv_i64 vm)
2259 {
2260     gen_helper_vfp_sqrtd(vd, vm, cpu_env);
2261 }
2262
2263 DO_VFP_2OP(VSQRT, sp, gen_VSQRT_sp)
2264 DO_VFP_2OP(VSQRT, dp, gen_VSQRT_dp)
2265
2266 static bool trans_VCMP_sp(DisasContext *s, arg_VCMP_sp *a)
2267 {
2268     TCGv_i32 vd, vm;
2269
2270     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
2271         return false;
2272     }
2273
2274     /* Vm/M bits must be zero for the Z variant */
2275     if (a->z && a->vm != 0) {
2276         return false;
2277     }
2278
2279     if (!vfp_access_check(s)) {
2280         return true;
2281     }
2282
2283     vd = tcg_temp_new_i32();
2284     vm = tcg_temp_new_i32();
2285
2286     neon_load_reg32(vd, a->vd);
2287     if (a->z) {
2288         tcg_gen_movi_i32(vm, 0);
2289     } else {
2290         neon_load_reg32(vm, a->vm);
2291     }
2292
2293     if (a->e) {
2294         gen_helper_vfp_cmpes(vd, vm, cpu_env);
2295     } else {
2296         gen_helper_vfp_cmps(vd, vm, cpu_env);
2297     }
2298
2299     tcg_temp_free_i32(vd);
2300     tcg_temp_free_i32(vm);
2301
2302     return true;
2303 }
2304
2305 static bool trans_VCMP_dp(DisasContext *s, arg_VCMP_dp *a)
2306 {
2307     TCGv_i64 vd, vm;
2308
2309     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2310         return false;
2311     }
2312
2313     /* Vm/M bits must be zero for the Z variant */
2314     if (a->z && a->vm != 0) {
2315         return false;
2316     }
2317
2318     /* UNDEF accesses to D16-D31 if they don't exist. */
2319     if (!dc_isar_feature(aa32_simd_r32, s) && ((a->vd | a->vm) & 0x10)) {
2320         return false;
2321     }
2322
2323     if (!vfp_access_check(s)) {
2324         return true;
2325     }
2326
2327     vd = tcg_temp_new_i64();
2328     vm = tcg_temp_new_i64();
2329
2330     neon_load_reg64(vd, a->vd);
2331     if (a->z) {
2332         tcg_gen_movi_i64(vm, 0);
2333     } else {
2334         neon_load_reg64(vm, a->vm);
2335     }
2336
2337     if (a->e) {
2338         gen_helper_vfp_cmped(vd, vm, cpu_env);
2339     } else {
2340         gen_helper_vfp_cmpd(vd, vm, cpu_env);
2341     }
2342
2343     tcg_temp_free_i64(vd);
2344     tcg_temp_free_i64(vm);
2345
2346     return true;
2347 }
2348
2349 static bool trans_VCVT_f32_f16(DisasContext *s, arg_VCVT_f32_f16 *a)
2350 {
2351     TCGv_ptr fpst;
2352     TCGv_i32 ahp_mode;
2353     TCGv_i32 tmp;
2354
2355     if (!dc_isar_feature(aa32_fp16_spconv, s)) {
2356         return false;
2357     }
2358
2359     if (!vfp_access_check(s)) {
2360         return true;
2361     }
2362
2363     fpst = fpstatus_ptr(FPST_FPCR);
2364     ahp_mode = get_ahp_flag();
2365     tmp = tcg_temp_new_i32();
2366     /* The T bit tells us if we want the low or high 16 bits of Vm */
2367     tcg_gen_ld16u_i32(tmp, cpu_env, vfp_f16_offset(a->vm, a->t));
2368     gen_helper_vfp_fcvt_f16_to_f32(tmp, tmp, fpst, ahp_mode);
2369     neon_store_reg32(tmp, a->vd);
2370     tcg_temp_free_i32(ahp_mode);
2371     tcg_temp_free_ptr(fpst);
2372     tcg_temp_free_i32(tmp);
2373     return true;
2374 }
2375
2376 static bool trans_VCVT_f64_f16(DisasContext *s, arg_VCVT_f64_f16 *a)
2377 {
2378     TCGv_ptr fpst;
2379     TCGv_i32 ahp_mode;
2380     TCGv_i32 tmp;
2381     TCGv_i64 vd;
2382
2383     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2384         return false;
2385     }
2386
2387     if (!dc_isar_feature(aa32_fp16_dpconv, s)) {
2388         return false;
2389     }
2390
2391     /* UNDEF accesses to D16-D31 if they don't exist. */
2392     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vd  & 0x10)) {
2393         return false;
2394     }
2395
2396     if (!vfp_access_check(s)) {
2397         return true;
2398     }
2399
2400     fpst = fpstatus_ptr(FPST_FPCR);
2401     ahp_mode = get_ahp_flag();
2402     tmp = tcg_temp_new_i32();
2403     /* The T bit tells us if we want the low or high 16 bits of Vm */
2404     tcg_gen_ld16u_i32(tmp, cpu_env, vfp_f16_offset(a->vm, a->t));
2405     vd = tcg_temp_new_i64();
2406     gen_helper_vfp_fcvt_f16_to_f64(vd, tmp, fpst, ahp_mode);
2407     neon_store_reg64(vd, a->vd);
2408     tcg_temp_free_i32(ahp_mode);
2409     tcg_temp_free_ptr(fpst);
2410     tcg_temp_free_i32(tmp);
2411     tcg_temp_free_i64(vd);
2412     return true;
2413 }
2414
2415 static bool trans_VCVT_f16_f32(DisasContext *s, arg_VCVT_f16_f32 *a)
2416 {
2417     TCGv_ptr fpst;
2418     TCGv_i32 ahp_mode;
2419     TCGv_i32 tmp;
2420
2421     if (!dc_isar_feature(aa32_fp16_spconv, s)) {
2422         return false;
2423     }
2424
2425     if (!vfp_access_check(s)) {
2426         return true;
2427     }
2428
2429     fpst = fpstatus_ptr(FPST_FPCR);
2430     ahp_mode = get_ahp_flag();
2431     tmp = tcg_temp_new_i32();
2432
2433     neon_load_reg32(tmp, a->vm);
2434     gen_helper_vfp_fcvt_f32_to_f16(tmp, tmp, fpst, ahp_mode);
2435     tcg_gen_st16_i32(tmp, cpu_env, vfp_f16_offset(a->vd, a->t));
2436     tcg_temp_free_i32(ahp_mode);
2437     tcg_temp_free_ptr(fpst);
2438     tcg_temp_free_i32(tmp);
2439     return true;
2440 }
2441
2442 static bool trans_VCVT_f16_f64(DisasContext *s, arg_VCVT_f16_f64 *a)
2443 {
2444     TCGv_ptr fpst;
2445     TCGv_i32 ahp_mode;
2446     TCGv_i32 tmp;
2447     TCGv_i64 vm;
2448
2449     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2450         return false;
2451     }
2452
2453     if (!dc_isar_feature(aa32_fp16_dpconv, s)) {
2454         return false;
2455     }
2456
2457     /* UNDEF accesses to D16-D31 if they don't exist. */
2458     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vm  & 0x10)) {
2459         return false;
2460     }
2461
2462     if (!vfp_access_check(s)) {
2463         return true;
2464     }
2465
2466     fpst = fpstatus_ptr(FPST_FPCR);
2467     ahp_mode = get_ahp_flag();
2468     tmp = tcg_temp_new_i32();
2469     vm = tcg_temp_new_i64();
2470
2471     neon_load_reg64(vm, a->vm);
2472     gen_helper_vfp_fcvt_f64_to_f16(tmp, vm, fpst, ahp_mode);
2473     tcg_temp_free_i64(vm);
2474     tcg_gen_st16_i32(tmp, cpu_env, vfp_f16_offset(a->vd, a->t));
2475     tcg_temp_free_i32(ahp_mode);
2476     tcg_temp_free_ptr(fpst);
2477     tcg_temp_free_i32(tmp);
2478     return true;
2479 }
2480
2481 static bool trans_VRINTR_sp(DisasContext *s, arg_VRINTR_sp *a)
2482 {
2483     TCGv_ptr fpst;
2484     TCGv_i32 tmp;
2485
2486     if (!dc_isar_feature(aa32_vrint, s)) {
2487         return false;
2488     }
2489
2490     if (!vfp_access_check(s)) {
2491         return true;
2492     }
2493
2494     tmp = tcg_temp_new_i32();
2495     neon_load_reg32(tmp, a->vm);
2496     fpst = fpstatus_ptr(FPST_FPCR);
2497     gen_helper_rints(tmp, tmp, fpst);
2498     neon_store_reg32(tmp, a->vd);
2499     tcg_temp_free_ptr(fpst);
2500     tcg_temp_free_i32(tmp);
2501     return true;
2502 }
2503
2504 static bool trans_VRINTR_dp(DisasContext *s, arg_VRINTR_dp *a)
2505 {
2506     TCGv_ptr fpst;
2507     TCGv_i64 tmp;
2508
2509     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2510         return false;
2511     }
2512
2513     if (!dc_isar_feature(aa32_vrint, s)) {
2514         return false;
2515     }
2516
2517     /* UNDEF accesses to D16-D31 if they don't exist. */
2518     if (!dc_isar_feature(aa32_simd_r32, s) && ((a->vd | a->vm) & 0x10)) {
2519         return false;
2520     }
2521
2522     if (!vfp_access_check(s)) {
2523         return true;
2524     }
2525
2526     tmp = tcg_temp_new_i64();
2527     neon_load_reg64(tmp, a->vm);
2528     fpst = fpstatus_ptr(FPST_FPCR);
2529     gen_helper_rintd(tmp, tmp, fpst);
2530     neon_store_reg64(tmp, a->vd);
2531     tcg_temp_free_ptr(fpst);
2532     tcg_temp_free_i64(tmp);
2533     return true;
2534 }
2535
2536 static bool trans_VRINTZ_sp(DisasContext *s, arg_VRINTZ_sp *a)
2537 {
2538     TCGv_ptr fpst;
2539     TCGv_i32 tmp;
2540     TCGv_i32 tcg_rmode;
2541
2542     if (!dc_isar_feature(aa32_vrint, s)) {
2543         return false;
2544     }
2545
2546     if (!vfp_access_check(s)) {
2547         return true;
2548     }
2549
2550     tmp = tcg_temp_new_i32();
2551     neon_load_reg32(tmp, a->vm);
2552     fpst = fpstatus_ptr(FPST_FPCR);
2553     tcg_rmode = tcg_const_i32(float_round_to_zero);
2554     gen_helper_set_rmode(tcg_rmode, tcg_rmode, fpst);
2555     gen_helper_rints(tmp, tmp, fpst);
2556     gen_helper_set_rmode(tcg_rmode, tcg_rmode, fpst);
2557     neon_store_reg32(tmp, a->vd);
2558     tcg_temp_free_ptr(fpst);
2559     tcg_temp_free_i32(tcg_rmode);
2560     tcg_temp_free_i32(tmp);
2561     return true;
2562 }
2563
2564 static bool trans_VRINTZ_dp(DisasContext *s, arg_VRINTZ_dp *a)
2565 {
2566     TCGv_ptr fpst;
2567     TCGv_i64 tmp;
2568     TCGv_i32 tcg_rmode;
2569
2570     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2571         return false;
2572     }
2573
2574     if (!dc_isar_feature(aa32_vrint, s)) {
2575         return false;
2576     }
2577
2578     /* UNDEF accesses to D16-D31 if they don't exist. */
2579     if (!dc_isar_feature(aa32_simd_r32, s) && ((a->vd | a->vm) & 0x10)) {
2580         return false;
2581     }
2582
2583     if (!vfp_access_check(s)) {
2584         return true;
2585     }
2586
2587     tmp = tcg_temp_new_i64();
2588     neon_load_reg64(tmp, a->vm);
2589     fpst = fpstatus_ptr(FPST_FPCR);
2590     tcg_rmode = tcg_const_i32(float_round_to_zero);
2591     gen_helper_set_rmode(tcg_rmode, tcg_rmode, fpst);
2592     gen_helper_rintd(tmp, tmp, fpst);
2593     gen_helper_set_rmode(tcg_rmode, tcg_rmode, fpst);
2594     neon_store_reg64(tmp, a->vd);
2595     tcg_temp_free_ptr(fpst);
2596     tcg_temp_free_i64(tmp);
2597     tcg_temp_free_i32(tcg_rmode);
2598     return true;
2599 }
2600
2601 static bool trans_VRINTX_sp(DisasContext *s, arg_VRINTX_sp *a)
2602 {
2603     TCGv_ptr fpst;
2604     TCGv_i32 tmp;
2605
2606     if (!dc_isar_feature(aa32_vrint, s)) {
2607         return false;
2608     }
2609
2610     if (!vfp_access_check(s)) {
2611         return true;
2612     }
2613
2614     tmp = tcg_temp_new_i32();
2615     neon_load_reg32(tmp, a->vm);
2616     fpst = fpstatus_ptr(FPST_FPCR);
2617     gen_helper_rints_exact(tmp, tmp, fpst);
2618     neon_store_reg32(tmp, a->vd);
2619     tcg_temp_free_ptr(fpst);
2620     tcg_temp_free_i32(tmp);
2621     return true;
2622 }
2623
2624 static bool trans_VRINTX_dp(DisasContext *s, arg_VRINTX_dp *a)
2625 {
2626     TCGv_ptr fpst;
2627     TCGv_i64 tmp;
2628
2629     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2630         return false;
2631     }
2632
2633     if (!dc_isar_feature(aa32_vrint, s)) {
2634         return false;
2635     }
2636
2637     /* UNDEF accesses to D16-D31 if they don't exist. */
2638     if (!dc_isar_feature(aa32_simd_r32, s) && ((a->vd | a->vm) & 0x10)) {
2639         return false;
2640     }
2641
2642     if (!vfp_access_check(s)) {
2643         return true;
2644     }
2645
2646     tmp = tcg_temp_new_i64();
2647     neon_load_reg64(tmp, a->vm);
2648     fpst = fpstatus_ptr(FPST_FPCR);
2649     gen_helper_rintd_exact(tmp, tmp, fpst);
2650     neon_store_reg64(tmp, a->vd);
2651     tcg_temp_free_ptr(fpst);
2652     tcg_temp_free_i64(tmp);
2653     return true;
2654 }
2655
2656 static bool trans_VCVT_sp(DisasContext *s, arg_VCVT_sp *a)
2657 {
2658     TCGv_i64 vd;
2659     TCGv_i32 vm;
2660
2661     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2662         return false;
2663     }
2664
2665     /* UNDEF accesses to D16-D31 if they don't exist. */
2666     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vd & 0x10)) {
2667         return false;
2668     }
2669
2670     if (!vfp_access_check(s)) {
2671         return true;
2672     }
2673
2674     vm = tcg_temp_new_i32();
2675     vd = tcg_temp_new_i64();
2676     neon_load_reg32(vm, a->vm);
2677     gen_helper_vfp_fcvtds(vd, vm, cpu_env);
2678     neon_store_reg64(vd, a->vd);
2679     tcg_temp_free_i32(vm);
2680     tcg_temp_free_i64(vd);
2681     return true;
2682 }
2683
2684 static bool trans_VCVT_dp(DisasContext *s, arg_VCVT_dp *a)
2685 {
2686     TCGv_i64 vm;
2687     TCGv_i32 vd;
2688
2689     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2690         return false;
2691     }
2692
2693     /* UNDEF accesses to D16-D31 if they don't exist. */
2694     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vm & 0x10)) {
2695         return false;
2696     }
2697
2698     if (!vfp_access_check(s)) {
2699         return true;
2700     }
2701
2702     vd = tcg_temp_new_i32();
2703     vm = tcg_temp_new_i64();
2704     neon_load_reg64(vm, a->vm);
2705     gen_helper_vfp_fcvtsd(vd, vm, cpu_env);
2706     neon_store_reg32(vd, a->vd);
2707     tcg_temp_free_i32(vd);
2708     tcg_temp_free_i64(vm);
2709     return true;
2710 }
2711
2712 static bool trans_VCVT_int_sp(DisasContext *s, arg_VCVT_int_sp *a)
2713 {
2714     TCGv_i32 vm;
2715     TCGv_ptr fpst;
2716
2717     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
2718         return false;
2719     }
2720
2721     if (!vfp_access_check(s)) {
2722         return true;
2723     }
2724
2725     vm = tcg_temp_new_i32();
2726     neon_load_reg32(vm, a->vm);
2727     fpst = fpstatus_ptr(FPST_FPCR);
2728     if (a->s) {
2729         /* i32 -> f32 */
2730         gen_helper_vfp_sitos(vm, vm, fpst);
2731     } else {
2732         /* u32 -> f32 */
2733         gen_helper_vfp_uitos(vm, vm, fpst);
2734     }
2735     neon_store_reg32(vm, a->vd);
2736     tcg_temp_free_i32(vm);
2737     tcg_temp_free_ptr(fpst);
2738     return true;
2739 }
2740
2741 static bool trans_VCVT_int_dp(DisasContext *s, arg_VCVT_int_dp *a)
2742 {
2743     TCGv_i32 vm;
2744     TCGv_i64 vd;
2745     TCGv_ptr fpst;
2746
2747     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2748         return false;
2749     }
2750
2751     /* UNDEF accesses to D16-D31 if they don't exist. */
2752     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vd & 0x10)) {
2753         return false;
2754     }
2755
2756     if (!vfp_access_check(s)) {
2757         return true;
2758     }
2759
2760     vm = tcg_temp_new_i32();
2761     vd = tcg_temp_new_i64();
2762     neon_load_reg32(vm, a->vm);
2763     fpst = fpstatus_ptr(FPST_FPCR);
2764     if (a->s) {
2765         /* i32 -> f64 */
2766         gen_helper_vfp_sitod(vd, vm, fpst);
2767     } else {
2768         /* u32 -> f64 */
2769         gen_helper_vfp_uitod(vd, vm, fpst);
2770     }
2771     neon_store_reg64(vd, a->vd);
2772     tcg_temp_free_i32(vm);
2773     tcg_temp_free_i64(vd);
2774     tcg_temp_free_ptr(fpst);
2775     return true;
2776 }
2777
2778 static bool trans_VJCVT(DisasContext *s, arg_VJCVT *a)
2779 {
2780     TCGv_i32 vd;
2781     TCGv_i64 vm;
2782
2783     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2784         return false;
2785     }
2786
2787     if (!dc_isar_feature(aa32_jscvt, s)) {
2788         return false;
2789     }
2790
2791     /* UNDEF accesses to D16-D31 if they don't exist. */
2792     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vm & 0x10)) {
2793         return false;
2794     }
2795
2796     if (!vfp_access_check(s)) {
2797         return true;
2798     }
2799
2800     vm = tcg_temp_new_i64();
2801     vd = tcg_temp_new_i32();
2802     neon_load_reg64(vm, a->vm);
2803     gen_helper_vjcvt(vd, vm, cpu_env);
2804     neon_store_reg32(vd, a->vd);
2805     tcg_temp_free_i64(vm);
2806     tcg_temp_free_i32(vd);
2807     return true;
2808 }
2809
2810 static bool trans_VCVT_fix_sp(DisasContext *s, arg_VCVT_fix_sp *a)
2811 {
2812     TCGv_i32 vd, shift;
2813     TCGv_ptr fpst;
2814     int frac_bits;
2815
2816     if (!dc_isar_feature(aa32_fpsp_v3, s)) {
2817         return false;
2818     }
2819
2820     if (!vfp_access_check(s)) {
2821         return true;
2822     }
2823
2824     frac_bits = (a->opc & 1) ? (32 - a->imm) : (16 - a->imm);
2825
2826     vd = tcg_temp_new_i32();
2827     neon_load_reg32(vd, a->vd);
2828
2829     fpst = fpstatus_ptr(FPST_FPCR);
2830     shift = tcg_const_i32(frac_bits);
2831
2832     /* Switch on op:U:sx bits */
2833     switch (a->opc) {
2834     case 0:
2835         gen_helper_vfp_shtos(vd, vd, shift, fpst);
2836         break;
2837     case 1:
2838         gen_helper_vfp_sltos(vd, vd, shift, fpst);
2839         break;
2840     case 2:
2841         gen_helper_vfp_uhtos(vd, vd, shift, fpst);
2842         break;
2843     case 3:
2844         gen_helper_vfp_ultos(vd, vd, shift, fpst);
2845         break;
2846     case 4:
2847         gen_helper_vfp_toshs_round_to_zero(vd, vd, shift, fpst);
2848         break;
2849     case 5:
2850         gen_helper_vfp_tosls_round_to_zero(vd, vd, shift, fpst);
2851         break;
2852     case 6:
2853         gen_helper_vfp_touhs_round_to_zero(vd, vd, shift, fpst);
2854         break;
2855     case 7:
2856         gen_helper_vfp_touls_round_to_zero(vd, vd, shift, fpst);
2857         break;
2858     default:
2859         g_assert_not_reached();
2860     }
2861
2862     neon_store_reg32(vd, a->vd);
2863     tcg_temp_free_i32(vd);
2864     tcg_temp_free_i32(shift);
2865     tcg_temp_free_ptr(fpst);
2866     return true;
2867 }
2868
2869 static bool trans_VCVT_fix_dp(DisasContext *s, arg_VCVT_fix_dp *a)
2870 {
2871     TCGv_i64 vd;
2872     TCGv_i32 shift;
2873     TCGv_ptr fpst;
2874     int frac_bits;
2875
2876     if (!dc_isar_feature(aa32_fpdp_v3, s)) {
2877         return false;
2878     }
2879
2880     /* UNDEF accesses to D16-D31 if they don't exist. */
2881     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vd & 0x10)) {
2882         return false;
2883     }
2884
2885     if (!vfp_access_check(s)) {
2886         return true;
2887     }
2888
2889     frac_bits = (a->opc & 1) ? (32 - a->imm) : (16 - a->imm);
2890
2891     vd = tcg_temp_new_i64();
2892     neon_load_reg64(vd, a->vd);
2893
2894     fpst = fpstatus_ptr(FPST_FPCR);
2895     shift = tcg_const_i32(frac_bits);
2896
2897     /* Switch on op:U:sx bits */
2898     switch (a->opc) {
2899     case 0:
2900         gen_helper_vfp_shtod(vd, vd, shift, fpst);
2901         break;
2902     case 1:
2903         gen_helper_vfp_sltod(vd, vd, shift, fpst);
2904         break;
2905     case 2:
2906         gen_helper_vfp_uhtod(vd, vd, shift, fpst);
2907         break;
2908     case 3:
2909         gen_helper_vfp_ultod(vd, vd, shift, fpst);
2910         break;
2911     case 4:
2912         gen_helper_vfp_toshd_round_to_zero(vd, vd, shift, fpst);
2913         break;
2914     case 5:
2915         gen_helper_vfp_tosld_round_to_zero(vd, vd, shift, fpst);
2916         break;
2917     case 6:
2918         gen_helper_vfp_touhd_round_to_zero(vd, vd, shift, fpst);
2919         break;
2920     case 7:
2921         gen_helper_vfp_tould_round_to_zero(vd, vd, shift, fpst);
2922         break;
2923     default:
2924         g_assert_not_reached();
2925     }
2926
2927     neon_store_reg64(vd, a->vd);
2928     tcg_temp_free_i64(vd);
2929     tcg_temp_free_i32(shift);
2930     tcg_temp_free_ptr(fpst);
2931     return true;
2932 }
2933
2934 static bool trans_VCVT_sp_int(DisasContext *s, arg_VCVT_sp_int *a)
2935 {
2936     TCGv_i32 vm;
2937     TCGv_ptr fpst;
2938
2939     if (!dc_isar_feature(aa32_fpsp_v2, s)) {
2940         return false;
2941     }
2942
2943     if (!vfp_access_check(s)) {
2944         return true;
2945     }
2946
2947     fpst = fpstatus_ptr(FPST_FPCR);
2948     vm = tcg_temp_new_i32();
2949     neon_load_reg32(vm, a->vm);
2950
2951     if (a->s) {
2952         if (a->rz) {
2953             gen_helper_vfp_tosizs(vm, vm, fpst);
2954         } else {
2955             gen_helper_vfp_tosis(vm, vm, fpst);
2956         }
2957     } else {
2958         if (a->rz) {
2959             gen_helper_vfp_touizs(vm, vm, fpst);
2960         } else {
2961             gen_helper_vfp_touis(vm, vm, fpst);
2962         }
2963     }
2964     neon_store_reg32(vm, a->vd);
2965     tcg_temp_free_i32(vm);
2966     tcg_temp_free_ptr(fpst);
2967     return true;
2968 }
2969
2970 static bool trans_VCVT_dp_int(DisasContext *s, arg_VCVT_dp_int *a)
2971 {
2972     TCGv_i32 vd;
2973     TCGv_i64 vm;
2974     TCGv_ptr fpst;
2975
2976     if (!dc_isar_feature(aa32_fpdp_v2, s)) {
2977         return false;
2978     }
2979
2980     /* UNDEF accesses to D16-D31 if they don't exist. */
2981     if (!dc_isar_feature(aa32_simd_r32, s) && (a->vm & 0x10)) {
2982         return false;
2983     }
2984
2985     if (!vfp_access_check(s)) {
2986         return true;
2987     }
2988
2989     fpst = fpstatus_ptr(FPST_FPCR);
2990     vm = tcg_temp_new_i64();
2991     vd = tcg_temp_new_i32();
2992     neon_load_reg64(vm, a->vm);
2993
2994     if (a->s) {
2995         if (a->rz) {
2996             gen_helper_vfp_tosizd(vd, vm, fpst);
2997         } else {
2998             gen_helper_vfp_tosid(vd, vm, fpst);
2999         }
3000     } else {
3001         if (a->rz) {
3002             gen_helper_vfp_touizd(vd, vm, fpst);
3003         } else {
3004             gen_helper_vfp_touid(vd, vm, fpst);
3005         }
3006     }
3007     neon_store_reg32(vd, a->vd);
3008     tcg_temp_free_i32(vd);
3009     tcg_temp_free_i64(vm);
3010     tcg_temp_free_ptr(fpst);
3011     return true;
3012 }
3013
3014 /*
3015  * Decode VLLDM and VLSTM are nonstandard because:
3016  *  * if there is no FPU then these insns must NOP in
3017  *    Secure state and UNDEF in Nonsecure state
3018  *  * if there is an FPU then these insns do not have
3019  *    the usual behaviour that vfp_access_check() provides of
3020  *    being controlled by CPACR/NSACR enable bits or the
3021  *    lazy-stacking logic.
3022  */
3023 static bool trans_VLLDM_VLSTM(DisasContext *s, arg_VLLDM_VLSTM *a)
3024 {
3025     TCGv_i32 fptr;
3026
3027     if (!arm_dc_feature(s, ARM_FEATURE_M) ||
3028         !arm_dc_feature(s, ARM_FEATURE_V8)) {
3029         return false;
3030     }
3031     /*
3032      * If not secure, UNDEF. We must emit code for this
3033      * rather than returning false so that this takes
3034      * precedence over the m-nocp.decode NOCP fallback.
3035      */
3036     if (!s->v8m_secure) {
3037         unallocated_encoding(s);
3038         return true;
3039     }
3040     /* If no fpu, NOP. */
3041     if (!dc_isar_feature(aa32_vfp, s)) {
3042         return true;
3043     }
3044
3045     fptr = load_reg(s, a->rn);
3046     if (a->l) {
3047         gen_helper_v7m_vlldm(cpu_env, fptr);
3048     } else {
3049         gen_helper_v7m_vlstm(cpu_env, fptr);
3050     }
3051     tcg_temp_free_i32(fptr);
3052
3053     /* End the TB, because we have updated FP control bits */
3054     s->base.is_jmp = DISAS_UPDATE_EXIT;
3055     return true;
3056 }
3057
3058 static bool trans_NOCP(DisasContext *s, arg_NOCP *a)
3059 {
3060     /*
3061      * Handle M-profile early check for disabled coprocessor:
3062      * all we need to do here is emit the NOCP exception if
3063      * the coprocessor is disabled. Otherwise we return false
3064      * and the real VFP/etc decode will handle the insn.
3065      */
3066     assert(arm_dc_feature(s, ARM_FEATURE_M));
3067
3068     if (a->cp == 11) {
3069         a->cp = 10;
3070     }
3071     /* TODO: in v8.1M cp 8, 9, 14, 15 also are governed by the cp10 enable */
3072
3073     if (a->cp != 10) {
3074         gen_exception_insn(s, s->pc_curr, EXCP_NOCP,
3075                            syn_uncategorized(), default_exception_el(s));
3076         return true;
3077     }
3078
3079     if (s->fp_excp_el != 0) {
3080         gen_exception_insn(s, s->pc_curr, EXCP_NOCP,
3081                            syn_uncategorized(), s->fp_excp_el);
3082         return true;
3083     }
3084
3085     return false;
3086 }