Enable tests for more CPU features.

These features are already supported by VIXL, and they should have been enabled in the patch that introduced these tests. The noise in the diff exists because these tests are generated from a script. With this version, the generation should be made stable, so that future updates using the same script do not generate this kind of noise. Change-Id: Idd9c37e642e0c51fdba07f82a41496c9d6927c1d
author: Jacob Bramley <jacob.bramley@arm.com> 2018-08-20 17:38:13 +0100
committer: Jacob Bramley <jacob.bramley@arm.com> 2018-08-28 14:16:48 +0100
commit: f658ca1813c32f483f20f75a4be0947ef66b442f (patch)
tree: 47e32ebccc275d9d027ea841b39100381f918136 /test
parent: 7175d2ed0e4b6473dfc5a73116ee1957d6b99efd (diff)
1 files changed, 842 insertions, 797 deletions
diff --git a/test/aarch64/test-cpu-features-aarch64.cc b/test/aarch64/test-cpu-features-aarch64.cc
index dc9c74b2..bc313162 100644
--- a/test/aarch64/test-cpu-features-aarch64.cc
+++ b/test/aarch64/test-cpu-features-aarch64.cc
@@ -135,109 +135,109 @@ TEST_NONE(adc_0, adc(w0, w1, w2))
 TEST_NONE(adc_1, adc(x0, x1, x2))
 TEST_NONE(adcs_0, adcs(w0, w1, w2))
 TEST_NONE(adcs_1, adcs(x0, x1, x2))
-TEST_NONE(adds_0, adds(w0, w1, Operand(w2, SXTH, 1)))
-TEST_NONE(adds_1, adds(x0, x1, Operand(x2, UXTX, 2)))
-TEST_NONE(adds_2, adds(x0, x1, Operand(w2, UXTB, 4)))
-TEST_NONE(adds_3, adds(w0, w1, 0x7fb))
-TEST_NONE(adds_4, adds(x0, x1, 0xb0d << 12))
-TEST_NONE(adds_5, adds(w0, w1, Operand(w2, LSR, 18)))
-TEST_NONE(adds_6, adds(x0, x1, Operand(x2, LSR, 1)))
-TEST_NONE(add_0, add(w0, w1, Operand(w2, SXTH, 3)))
-TEST_NONE(add_1, add(x0, x1, Operand(x2, SXTX, 2)))
-TEST_NONE(add_2, add(x0, x1, Operand(w2, SXTB, 2)))
-TEST_NONE(add_3, add(w0, w1, 0x700))
-TEST_NONE(add_4, add(x0, x1, 0xec0))
-TEST_NONE(add_5, add(w0, w1, Operand(w2, ASR, 31)))
-TEST_NONE(add_6, add(x0, x1, Operand(x2, ASR, 16)))
+TEST_NONE(adds_0, adds(w0, w1, Operand(w2, UXTH, 0)))
+TEST_NONE(adds_1, adds(x0, x1, Operand(x2, SXTX, 4)))
+TEST_NONE(adds_2, adds(x0, x1, Operand(w2, SXTB, 1)))
+TEST_NONE(adds_3, adds(w0, w1, 0x905 << 12))
+TEST_NONE(adds_4, adds(x0, x1, 0x35a))
+TEST_NONE(adds_5, adds(w0, w1, Operand(w2, LSL, 10)))
+TEST_NONE(adds_6, adds(x0, x1, Operand(x2, LSR, 11)))
+TEST_NONE(add_0, add(w0, w1, Operand(w2, UXTW, 3)))
+TEST_NONE(add_1, add(x0, x1, Operand(x2, UXTX, 4)))
+TEST_NONE(add_2, add(x0, x1, Operand(w2, UXTH, 4)))
+TEST_NONE(add_3, add(w0, w1, 0xb7e << 12))
+TEST_NONE(add_4, add(x0, x1, 0x6d2))
+TEST_NONE(add_5, add(w0, w1, Operand(w2, LSL, 6)))
+TEST_NONE(add_6, add(x0, x1, Operand(x2, LSR, 25)))
 TEST_NONE(adr_0, adr(x0, &label))
 TEST_NONE(adrp_0, adrp(x0, &label))
-TEST_NONE(ands_0, ands(w0, w1, 0xf0))
-TEST_NONE(ands_1, ands(x0, x1, 0x3c))
-TEST_NONE(ands_2, ands(w0, w1, Operand(w2, LSL, 23)))
-TEST_NONE(ands_3, ands(x0, x1, Operand(x2, LSL, 17)))
+TEST_NONE(ands_0, ands(w0, w1, 0x3c0000))
+TEST_NONE(ands_1, ands(x0, x1, 0x3c0000))
+TEST_NONE(ands_2, ands(w0, w1, Operand(w2, ASR, 6)))
+TEST_NONE(ands_3, ands(x0, x1, Operand(x2, ASR, 33)))
 TEST_NONE(and_0, and_(w0, w1, 0x3c0))
-TEST_NONE(and_1, and_(x0, x1, 0x7800))
-TEST_NONE(and_2, and_(w0, w1, Operand(w2, ASR, 6)))
-TEST_NONE(and_3, and_(x0, x1, Operand(x2, ASR, 52)))
+TEST_NONE(and_1, and_(x0, x1, 0xf))
+TEST_NONE(and_2, and_(w0, w1, Operand(w2, LSL, 1)))
+TEST_NONE(and_3, and_(x0, x1, Operand(x2, LSL, 58)))
 TEST_NONE(asrv_0, asrv(w0, w1, w2))
 TEST_NONE(asrv_1, asrv(x0, x1, x2))
-TEST_NONE(bfi_0, bfi(w0, w1, 4, 16))
-TEST_NONE(bfi_1, bfi(x0, x1, 33, 10))
-TEST_NONE(bfm_0, bfm(w0, w1, 9, 14))
-TEST_NONE(bfm_1, bfm(x0, x1, 12, 8))
-TEST_NONE(bfxil_0, bfxil(w0, w1, 8, 13))
-TEST_NONE(bfxil_1, bfxil(x0, x1, 4, 31))
-TEST_NONE(bics_0, bics(w0, w1, Operand(w2, ASR, 30)))
-TEST_NONE(bics_1, bics(x0, x1, Operand(x2, ASR, 18)))
-TEST_NONE(bic_0, bic(w0, w1, Operand(w2, ASR, 24)))
-TEST_NONE(bic_1, bic(x0, x1, Operand(x2, LSR, 52)))
+TEST_NONE(bfi_0, bfi(w0, w1, 5, 11))
+TEST_NONE(bfi_1, bfi(x0, x1, 25, 36))
+TEST_NONE(bfm_0, bfm(w0, w1, 27, 31))
+TEST_NONE(bfm_1, bfm(x0, x1, 54, 57))
+TEST_NONE(bfxil_0, bfxil(w0, w1, 14, 13))
+TEST_NONE(bfxil_1, bfxil(x0, x1, 22, 6))
+TEST_NONE(bics_0, bics(w0, w1, Operand(w2, LSR, 10)))
+TEST_NONE(bics_1, bics(x0, x1, Operand(x2, LSL, 42)))
+TEST_NONE(bic_0, bic(w0, w1, Operand(w2, LSL, 17)))
+TEST_NONE(bic_1, bic(x0, x1, Operand(x2, LSR, 16)))
 TEST_NONE(bl_0, bl(&label))
 TEST_NONE(blr_0, blr(x0))
 TEST_NONE(br_0, br(x0))
-TEST_NONE(brk_0, brk(0x9ede))
-TEST_NONE(b_0, b(&label, cc))
+TEST_NONE(brk_0, brk(0x97b0))
+TEST_NONE(b_0, b(&label, pl))
 TEST_NONE(b_1, b(&label))
 TEST_NONE(cbnz_0, cbnz(w0, &label))
 TEST_NONE(cbnz_1, cbnz(x0, &label))
 TEST_NONE(cbz_0, cbz(w0, &label))
 TEST_NONE(cbz_1, cbz(x0, &label))
-TEST_NONE(ccmn_0, ccmn(w0, 30, ZVFlag, ne))
-TEST_NONE(ccmn_1, ccmn(x0, 19, ZFlag, hi))
-TEST_NONE(ccmn_2, ccmn(w0, w1, NZCVFlag, eq))
-TEST_NONE(ccmn_3, ccmn(x0, x1, NZCFlag, hi))
-TEST_NONE(ccmp_0, ccmp(w0, 19, VFlag, lt))
-TEST_NONE(ccmp_1, ccmp(x0, 18, NFlag, cc))
-TEST_NONE(ccmp_2, ccmp(w0, w1, NCFlag, gt))
-TEST_NONE(ccmp_3, ccmp(x0, x1, ZCVFlag, cc))
-TEST_NONE(cinc_0, cinc(w0, w1, ls))
-TEST_NONE(cinc_1, cinc(x0, x1, cs))
-TEST_NONE(cinv_0, cinv(w0, w1, lt))
-TEST_NONE(cinv_1, cinv(x0, x1, le))
-TEST_NONE(clrex_0, clrex(15))
+TEST_NONE(ccmn_0, ccmn(w0, 28, NZVFlag, lt))
+TEST_NONE(ccmn_1, ccmn(x0, 12, ZFlag, ge))
+TEST_NONE(ccmn_2, ccmn(w0, w1, NZCFlag, gt))
+TEST_NONE(ccmn_3, ccmn(x0, x1, ZCFlag, cs))
+TEST_NONE(ccmp_0, ccmp(w0, 8, NVFlag, mi))
+TEST_NONE(ccmp_1, ccmp(x0, 19, ZVFlag, cc))
+TEST_NONE(ccmp_2, ccmp(w0, w1, NVFlag, ne))
+TEST_NONE(ccmp_3, ccmp(x0, x1, NZVFlag, cs))
+TEST_NONE(cinc_0, cinc(w0, w1, eq))
+TEST_NONE(cinc_1, cinc(x0, x1, le))
+TEST_NONE(cinv_0, cinv(w0, w1, cs))
+TEST_NONE(cinv_1, cinv(x0, x1, cc))
+TEST_NONE(clrex_0, clrex(10))
 TEST_NONE(cls_0, cls(w0, w1))
 TEST_NONE(cls_1, cls(x0, x1))
 TEST_NONE(clz_0, clz(w0, w1))
 TEST_NONE(clz_1, clz(x0, x1))
-TEST_NONE(cmn_0, cmn(w0, Operand(w1, SXTB, 2)))
-TEST_NONE(cmn_1, cmn(x0, Operand(x1, SXTX, 3)))
-TEST_NONE(cmn_2, cmn(x0, Operand(w1, UXTB, 4)))
-TEST_NONE(cmn_3, cmn(w0, 0x357))
-TEST_NONE(cmn_4, cmn(x0, 0x6cd << 12))
-TEST_NONE(cmn_5, cmn(w0, Operand(w1, LSL, 18)))
-TEST_NONE(cmn_6, cmn(x0, Operand(x1, LSR, 28)))
-TEST_NONE(cmp_0, cmp(w0, Operand(w1, UXTH, 2)))
-TEST_NONE(cmp_1, cmp(x0, Operand(x1, UXTX, 0)))
-TEST_NONE(cmp_2, cmp(x0, Operand(w1, UXTW, 0)))
-TEST_NONE(cmp_3, cmp(w0, 0xbc5))
-TEST_NONE(cmp_4, cmp(x0, 0x645))
-TEST_NONE(cmp_5, cmp(w0, Operand(w1, LSL, 30)))
-TEST_NONE(cmp_6, cmp(x0, Operand(x1, LSR, 46)))
-TEST_NONE(cneg_0, cneg(w0, w1, ge))
-TEST_NONE(cneg_1, cneg(x0, x1, gt))
+TEST_NONE(cmn_0, cmn(w0, Operand(w1, UXTH, 2)))
+TEST_NONE(cmn_1, cmn(x0, Operand(x1, SXTX, 1)))
+TEST_NONE(cmn_2, cmn(x0, Operand(w1, SXTW, 3)))
+TEST_NONE(cmn_3, cmn(w0, 0x2e5 << 12))
+TEST_NONE(cmn_4, cmn(x0, 0xb48))
+TEST_NONE(cmn_5, cmn(w0, Operand(w1, LSR, 9)))
+TEST_NONE(cmn_6, cmn(x0, Operand(x1, LSL, 50)))
+TEST_NONE(cmp_0, cmp(w0, Operand(w1, UXTB, 3)))
+TEST_NONE(cmp_1, cmp(x0, Operand(x1, SXTX, 0)))
+TEST_NONE(cmp_2, cmp(x0, Operand(w1, SXTB, 0)))
+TEST_NONE(cmp_3, cmp(w0, 0xb44 << 12))
+TEST_NONE(cmp_4, cmp(x0, 0x48 << 12))
+TEST_NONE(cmp_5, cmp(w0, Operand(w1, LSL, 1)))
+TEST_NONE(cmp_6, cmp(x0, Operand(x1, ASR, 4)))
+TEST_NONE(cneg_0, cneg(w0, w1, mi))
+TEST_NONE(cneg_1, cneg(x0, x1, cs))
 TEST_NONE(csdb_0, csdb())
-TEST_NONE(csel_0, csel(w0, w1, w2, mi))
-TEST_NONE(csel_1, csel(x0, x1, x2, eq))
-TEST_NONE(csetm_0, csetm(w0, hi))
-TEST_NONE(csetm_1, csetm(x0, gt))
-TEST_NONE(cset_0, cset(w0, mi))
+TEST_NONE(csel_0, csel(w0, w1, w2, cs))
+TEST_NONE(csel_1, csel(x0, x1, x2, cc))
+TEST_NONE(csetm_0, csetm(w0, vc))
+TEST_NONE(csetm_1, csetm(x0, pl))
+TEST_NONE(cset_0, cset(w0, vc))
 TEST_NONE(cset_1, cset(x0, lt))
-TEST_NONE(csinc_0, csinc(w0, w1, w2, cs))
-TEST_NONE(csinc_1, csinc(x0, x1, x2, lt))
-TEST_NONE(csinv_0, csinv(w0, w1, w2, le))
-TEST_NONE(csinv_1, csinv(x0, x1, x2, gt))
-TEST_NONE(csneg_0, csneg(w0, w1, w2, eq))
-TEST_NONE(csneg_1, csneg(x0, x1, x2, ge))
-TEST_NONE(dc_0, dc(ZVA, x0))
-TEST_NONE(eon_0, eon(w0, w1, Operand(w2, LSL, 23)))
-TEST_NONE(eon_1, eon(x0, x1, Operand(x2, LSR, 57)))
-TEST_NONE(eor_0, eor(w0, w1, 0xf00000))
-TEST_NONE(eor_1, eor(x0, x1, 0xf00000))
-TEST_NONE(eor_2, eor(w0, w1, Operand(w2, ASR, 19)))
-TEST_NONE(eor_3, eor(x0, x1, Operand(x2, LSL, 51)))
-TEST_NONE(extr_0, extr(w0, w1, w2, 2))
+TEST_NONE(csinc_0, csinc(w0, w1, w2, lt))
+TEST_NONE(csinc_1, csinc(x0, x1, x2, cs))
+TEST_NONE(csinv_0, csinv(w0, w1, w2, cc))
+TEST_NONE(csinv_1, csinv(x0, x1, x2, ne))
+TEST_NONE(csneg_0, csneg(w0, w1, w2, ge))
+TEST_NONE(csneg_1, csneg(x0, x1, x2, cc))
+TEST_NONE(dc_0, dc(CIVAC, x0))
+TEST_NONE(eon_0, eon(w0, w1, Operand(w2, ASR, 3)))
+TEST_NONE(eon_1, eon(x0, x1, Operand(x2, LSL, 28)))
+TEST_NONE(eor_0, eor(w0, w1, 0xf0))
+TEST_NONE(eor_1, eor(x0, x1, 0x1e000))
+TEST_NONE(eor_2, eor(w0, w1, Operand(w2, LSL, 24)))
+TEST_NONE(eor_3, eor(x0, x1, Operand(x2, ASR, 16)))
+TEST_NONE(extr_0, extr(w0, w1, w2, 17))
 TEST_NONE(extr_1, extr(x0, x1, x2, 8))
-TEST_NONE(extr_2, extr(x0, x1, x2, 41))
-TEST_NONE(hlt_0, hlt(0x4255))
+TEST_NONE(extr_2, extr(x0, x1, x2, 50))
+TEST_NONE(hlt_0, hlt(0x7fb7))
 TEST_NONE(ic_0, ic(IVAU, x0))
 TEST_NONE(ldar_0, ldar(w0, MemOperand(x1, 0)))
 TEST_NONE(ldar_1, ldar(x0, MemOperand(x1, 0)))
@@ -249,77 +249,77 @@ TEST_NONE(ldaxr_0, ldaxr(w0, MemOperand(x1, 0)))
 TEST_NONE(ldaxr_1, ldaxr(x0, MemOperand(x1, 0)))
 TEST_NONE(ldaxrb_0, ldaxrb(w0, MemOperand(x1, 0)))
 TEST_NONE(ldaxrh_0, ldaxrh(w0, MemOperand(x1, 0)))
-TEST_NONE(ldnp_0, ldnp(w0, w1, MemOperand(x2, 140)))
-TEST_NONE(ldnp_1, ldnp(x0, x1, MemOperand(x2, -456)))
-TEST_NONE(ldpsw_0, ldpsw(x0, x1, MemOperand(x2, -112)))
-TEST_NONE(ldpsw_1, ldpsw(x0, x1, MemOperand(x2, -28, PostIndex)))
-TEST_NONE(ldpsw_2, ldpsw(x0, x1, MemOperand(x2, 36, PreIndex)))
-TEST_NONE(ldp_0, ldp(w0, w1, MemOperand(x2, -60)))
-TEST_NONE(ldp_1, ldp(w0, w1, MemOperand(x2, -244, PostIndex)))
-TEST_NONE(ldp_2, ldp(w0, w1, MemOperand(x2, -248, PreIndex)))
-TEST_NONE(ldp_3, ldp(x0, x1, MemOperand(x2, -152)))
-TEST_NONE(ldp_4, ldp(x0, x1, MemOperand(x2, -40, PostIndex)))
-TEST_NONE(ldp_5, ldp(x0, x1, MemOperand(x2, 352, PreIndex)))
-TEST_NONE(ldrb_0, ldrb(w0, MemOperand(x1, 236, PostIndex)))
-TEST_NONE(ldrb_1, ldrb(w0, MemOperand(x1, -34, PreIndex)))
-TEST_NONE(ldrb_2, ldrb(w0, MemOperand(x1, 2545)))
+TEST_NONE(ldnp_0, ldnp(w0, w1, MemOperand(x2, 12)))
+TEST_NONE(ldnp_1, ldnp(x0, x1, MemOperand(x2, 304)))
+TEST_NONE(ldpsw_0, ldpsw(x0, x1, MemOperand(x2, -212)))
+TEST_NONE(ldpsw_1, ldpsw(x0, x1, MemOperand(x2, -36, PostIndex)))
+TEST_NONE(ldpsw_2, ldpsw(x0, x1, MemOperand(x2, 104, PreIndex)))
+TEST_NONE(ldp_0, ldp(w0, w1, MemOperand(x2, -212)))
+TEST_NONE(ldp_1, ldp(w0, w1, MemOperand(x2, -212, PostIndex)))
+TEST_NONE(ldp_2, ldp(w0, w1, MemOperand(x2, -252, PreIndex)))
+TEST_NONE(ldp_3, ldp(x0, x1, MemOperand(x2, 336)))
+TEST_NONE(ldp_4, ldp(x0, x1, MemOperand(x2, 8, PostIndex)))
+TEST_NONE(ldp_5, ldp(x0, x1, MemOperand(x2, 360, PreIndex)))
+TEST_NONE(ldrb_0, ldrb(w0, MemOperand(x1, -219, PostIndex)))
+TEST_NONE(ldrb_1, ldrb(w0, MemOperand(x1, -137, PreIndex)))
+TEST_NONE(ldrb_2, ldrb(w0, MemOperand(x1, 4022)))
 TEST_NONE(ldrb_3, ldrb(w0, MemOperand(x1, x2, LSL, 0)))
-TEST_NONE(ldrb_4, ldrb(w0, MemOperand(x1, w2, UXTW, 0)))
+TEST_NONE(ldrb_4, ldrb(w0, MemOperand(x1, w2, SXTW, 0)))
 TEST_NONE(ldrb_5, ldrb(w0, MemOperand(x1, x2, SXTX, 0)))
-TEST_NONE(ldrh_0, ldrh(w0, MemOperand(x1, -197, PostIndex)))
-TEST_NONE(ldrh_1, ldrh(w0, MemOperand(x1, 106, PreIndex)))
-TEST_NONE(ldrh_2, ldrh(w0, MemOperand(x1, 1294)))
-TEST_NONE(ldrh_3, ldrh(w0, MemOperand(x1, w2, SXTW, 1)))
-TEST_NONE(ldrh_4, ldrh(w0, MemOperand(x1, x2, LSL, 1)))
-TEST_NONE(ldrsb_0, ldrsb(w0, MemOperand(x1, -177, PostIndex)))
-TEST_NONE(ldrsb_1, ldrsb(w0, MemOperand(x1, -17, PreIndex)))
-TEST_NONE(ldrsb_2, ldrsb(w0, MemOperand(x1, 3460)))
-TEST_NONE(ldrsb_3, ldrsb(x0, MemOperand(x1, 129, PostIndex)))
-TEST_NONE(ldrsb_4, ldrsb(x0, MemOperand(x1, -74, PreIndex)))
-TEST_NONE(ldrsb_5, ldrsb(x0, MemOperand(x1, 1801)))
+TEST_NONE(ldrh_0, ldrh(w0, MemOperand(x1, -135, PostIndex)))
+TEST_NONE(ldrh_1, ldrh(w0, MemOperand(x1, 52, PreIndex)))
+TEST_NONE(ldrh_2, ldrh(w0, MemOperand(x1, 4410)))
+TEST_NONE(ldrh_3, ldrh(w0, MemOperand(x1, w2, UXTW, 1)))
+TEST_NONE(ldrh_4, ldrh(w0, MemOperand(x1, x2, SXTX, 1)))
+TEST_NONE(ldrsb_0, ldrsb(w0, MemOperand(x1, 160, PostIndex)))
+TEST_NONE(ldrsb_1, ldrsb(w0, MemOperand(x1, -253, PreIndex)))
+TEST_NONE(ldrsb_2, ldrsb(w0, MemOperand(x1, 147)))
+TEST_NONE(ldrsb_3, ldrsb(x0, MemOperand(x1, 33, PostIndex)))
+TEST_NONE(ldrsb_4, ldrsb(x0, MemOperand(x1, 11, PreIndex)))
+TEST_NONE(ldrsb_5, ldrsb(x0, MemOperand(x1, 2742)))
 TEST_NONE(ldrsb_6, ldrsb(w0, MemOperand(x1, x2, LSL, 0)))
 TEST_NONE(ldrsb_7, ldrsb(w0, MemOperand(x1, w2, UXTW, 0)))
 TEST_NONE(ldrsb_8, ldrsb(w0, MemOperand(x1, x2, SXTX, 0)))
 TEST_NONE(ldrsb_9, ldrsb(x0, MemOperand(x1, x2, LSL, 0)))
-TEST_NONE(ldrsb_10, ldrsb(x0, MemOperand(x1, w2, UXTW, 0)))
+TEST_NONE(ldrsb_10, ldrsb(x0, MemOperand(x1, w2, SXTW, 0)))
 TEST_NONE(ldrsb_11, ldrsb(x0, MemOperand(x1, x2, SXTX, 0)))
-TEST_NONE(ldrsh_0, ldrsh(w0, MemOperand(x1, -29, PostIndex)))
-TEST_NONE(ldrsh_1, ldrsh(w0, MemOperand(x1, 20, PreIndex)))
-TEST_NONE(ldrsh_2, ldrsh(w0, MemOperand(x1, 6322)))
-TEST_NONE(ldrsh_3, ldrsh(x0, MemOperand(x1, -249, PostIndex)))
-TEST_NONE(ldrsh_4, ldrsh(x0, MemOperand(x1, -190, PreIndex)))
-TEST_NONE(ldrsh_5, ldrsh(x0, MemOperand(x1, 7928)))
-TEST_NONE(ldrsh_6, ldrsh(w0, MemOperand(x1, w2, UXTW, 1)))
-TEST_NONE(ldrsh_7, ldrsh(w0, MemOperand(x1, x2, LSL, 1)))
-TEST_NONE(ldrsh_8, ldrsh(x0, MemOperand(x1, w2, UXTW, 0)))
+TEST_NONE(ldrsh_0, ldrsh(w0, MemOperand(x1, 11, PostIndex)))
+TEST_NONE(ldrsh_1, ldrsh(w0, MemOperand(x1, -34, PreIndex)))
+TEST_NONE(ldrsh_2, ldrsh(w0, MemOperand(x1, 6212)))
+TEST_NONE(ldrsh_3, ldrsh(x0, MemOperand(x1, -78, PostIndex)))
+TEST_NONE(ldrsh_4, ldrsh(x0, MemOperand(x1, 72, PreIndex)))
+TEST_NONE(ldrsh_5, ldrsh(x0, MemOperand(x1, 6232)))
+TEST_NONE(ldrsh_6, ldrsh(w0, MemOperand(x1, w2, UXTW, 0)))
+TEST_NONE(ldrsh_7, ldrsh(w0, MemOperand(x1, x2, LSL, 0)))
+TEST_NONE(ldrsh_8, ldrsh(x0, MemOperand(x1, w2, SXTW, 0)))
 TEST_NONE(ldrsh_9, ldrsh(x0, MemOperand(x1, x2, SXTX, 1)))
-TEST_NONE(ldrsw_0, ldrsw(x0, MemOperand(x1, -185, PostIndex)))
-TEST_NONE(ldrsw_1, ldrsw(x0, MemOperand(x1, 0, PreIndex)))
-TEST_NONE(ldrsw_2, ldrsw(x0, MemOperand(x1, 1204)))
-TEST_NONE(ldrsw_3, ldrsw(x0, 0x38723))
-TEST_NONE(ldrsw_4, ldrsw(x0, MemOperand(x1, w2, SXTW, 2)))
+TEST_NONE(ldrsw_0, ldrsw(x0, MemOperand(x1, 73, PostIndex)))
+TEST_NONE(ldrsw_1, ldrsw(x0, MemOperand(x1, 13, PreIndex)))
+TEST_NONE(ldrsw_2, ldrsw(x0, MemOperand(x1, 2192)))
+TEST_NONE(ldrsw_3, ldrsw(x0, 0x16279))
+TEST_NONE(ldrsw_4, ldrsw(x0, MemOperand(x1, w2, SXTW, 0)))
 TEST_NONE(ldrsw_5, ldrsw(x0, MemOperand(x1, x2, LSL, 2)))
-TEST_NONE(ldr_0, ldr(w0, MemOperand(x1, 153, PostIndex)))
-TEST_NONE(ldr_1, ldr(w0, MemOperand(x1, 203, PreIndex)))
-TEST_NONE(ldr_2, ldr(w0, MemOperand(x1, 10604)))
-TEST_NONE(ldr_3, ldr(x0, MemOperand(x1, -243, PostIndex)))
-TEST_NONE(ldr_4, ldr(x0, MemOperand(x1, 23, PreIndex)))
-TEST_NONE(ldr_5, ldr(x0, MemOperand(x1, 23432)))
-TEST_NONE(ldr_6, ldr(w0, 0x1a315))
-TEST_NONE(ldr_7, ldr(x0, 0x4f28))
-TEST_NONE(ldr_8, ldr(w0, MemOperand(x1, w2, UXTW, 0)))
+TEST_NONE(ldr_0, ldr(w0, MemOperand(x1, -169, PostIndex)))
+TEST_NONE(ldr_1, ldr(w0, MemOperand(x1, 16, PreIndex)))
+TEST_NONE(ldr_2, ldr(w0, MemOperand(x1, 13080)))
+TEST_NONE(ldr_3, ldr(x0, MemOperand(x1, 3, PostIndex)))
+TEST_NONE(ldr_4, ldr(x0, MemOperand(x1, -27, PreIndex)))
+TEST_NONE(ldr_5, ldr(x0, MemOperand(x1, 14016)))
+TEST_NONE(ldr_6, ldr(w0, 0x21ada))
+TEST_NONE(ldr_7, ldr(x0, 0x2a87d))
+TEST_NONE(ldr_8, ldr(w0, MemOperand(x1, w2, SXTW, 0)))
 TEST_NONE(ldr_9, ldr(w0, MemOperand(x1, x2, LSL, 0)))
-TEST_NONE(ldr_10, ldr(x0, MemOperand(x1, w2, SXTW, 3)))
-TEST_NONE(ldr_11, ldr(x0, MemOperand(x1, x2, LSL, 0)))
-TEST_NONE(ldurb_0, ldurb(w0, MemOperand(x1, -215)))
-TEST_NONE(ldurh_0, ldurh(w0, MemOperand(x1, -14)))
-TEST_NONE(ldursb_0, ldursb(w0, MemOperand(x1, 166)))
-TEST_NONE(ldursb_1, ldursb(x0, MemOperand(x1, -141)))
-TEST_NONE(ldursh_0, ldursh(w0, MemOperand(x1, -123)))
-TEST_NONE(ldursh_1, ldursh(x0, MemOperand(x1, 112)))
-TEST_NONE(ldursw_0, ldursw(x0, MemOperand(x1, -173)))
-TEST_NONE(ldur_0, ldur(w0, MemOperand(x1, 251)))
-TEST_NONE(ldur_1, ldur(x0, MemOperand(x1, -140)))
+TEST_NONE(ldr_10, ldr(x0, MemOperand(x1, w2, UXTW, 3)))
+TEST_NONE(ldr_11, ldr(x0, MemOperand(x1, x2, LSL, 3)))
+TEST_NONE(ldurb_0, ldurb(w0, MemOperand(x1, 58)))
+TEST_NONE(ldurh_0, ldurh(w0, MemOperand(x1, -222)))
+TEST_NONE(ldursb_0, ldursb(w0, MemOperand(x1, -216)))
+TEST_NONE(ldursb_1, ldursb(x0, MemOperand(x1, 196)))
+TEST_NONE(ldursh_0, ldursh(w0, MemOperand(x1, -61)))
+TEST_NONE(ldursh_1, ldursh(x0, MemOperand(x1, -255)))
+TEST_NONE(ldursw_0, ldursw(x0, MemOperand(x1, -206)))
+TEST_NONE(ldur_0, ldur(w0, MemOperand(x1, 71)))
+TEST_NONE(ldur_1, ldur(x0, MemOperand(x1, 70)))
 TEST_NONE(ldxp_0, ldxp(w0, w1, MemOperand(x2, 0)))
 TEST_NONE(ldxp_1, ldxp(x0, x1, MemOperand(x2, 0)))
 TEST_NONE(ldxr_0, ldxr(w0, MemOperand(x1, 0)))
@@ -334,44 +334,44 @@ TEST_NONE(madd_0, madd(w0, w1, w2, w3))
 TEST_NONE(madd_1, madd(x0, x1, x2, x3))
 TEST_NONE(mneg_0, mneg(w0, w1, w2))
 TEST_NONE(mneg_1, mneg(x0, x1, x2))
-TEST_NONE(movk_0, movk(w0, UINT32_C(0x73f9) << 16))
-TEST_NONE(movk_1, movk(x0, UINT64_C(0xa4fb) << 16))
-TEST_NONE(movn_0, movn(w0, UINT32_C(0xbb3f)))
-TEST_NONE(movn_1, movn(x0, UINT64_C(0xa113) << 16))
-TEST_NONE(movz_0, movz(w0, UINT32_C(0x13b6) << 16))
-TEST_NONE(movz_1, movz(x0, UINT64_C(0x588e)))
+TEST_NONE(movk_0, movk(w0, UINT32_C(0xee40)))
+TEST_NONE(movk_1, movk(x0, UINT64_C(0xfff2) << 16))
+TEST_NONE(movn_0, movn(w0, UINT32_C(0xbd2f)))
+TEST_NONE(movn_1, movn(x0, UINT64_C(0x560c) << 16))
+TEST_NONE(movz_0, movz(w0, UINT32_C(0x9028) << 16))
+TEST_NONE(movz_1, movz(x0, UINT64_C(0xf525)))
 TEST_NONE(mov_0, mov(w0, w1))
 TEST_NONE(mov_1, mov(x0, x1))
 TEST_NONE(mov_2, mov(w0, w1))
 TEST_NONE(mov_3, mov(x0, x1))
 TEST_NONE(mrs_0, mrs(x0, FPCR))
-TEST_NONE(msr_0, msr(NZCV, x0))
+TEST_NONE(msr_0, msr(FPCR, x0))
 TEST_NONE(msub_0, msub(w0, w1, w2, w3))
 TEST_NONE(msub_1, msub(x0, x1, x2, x3))
 TEST_NONE(mul_0, mul(w0, w1, w2))
 TEST_NONE(mul_1, mul(x0, x1, x2))
-TEST_NONE(mvn_0, mvn(w0, Operand(w1, LSL, 4)))
-TEST_NONE(mvn_1, mvn(x0, Operand(x1, ASR, 6)))
-TEST_NONE(negs_0, negs(w0, Operand(w1, ASR, 20)))
+TEST_NONE(mvn_0, mvn(w0, Operand(w1, LSL, 7)))
+TEST_NONE(mvn_1, mvn(x0, Operand(x1, LSL, 40)))
+TEST_NONE(negs_0, negs(w0, Operand(w1, LSL, 21)))
 TEST_NONE(negs_1, negs(x0, Operand(x1, LSL, 57)))
-TEST_NONE(neg_0, neg(w0, Operand(w1, LSL, 14)))
-TEST_NONE(neg_1, neg(x0, Operand(x1, ASR, 38)))
+TEST_NONE(neg_0, neg(w0, Operand(w1, LSR, 18)))
+TEST_NONE(neg_1, neg(x0, Operand(x1, ASR, 33)))
 TEST_NONE(ngcs_0, ngcs(w0, w1))
 TEST_NONE(ngcs_1, ngcs(x0, x1))
 TEST_NONE(ngc_0, ngc(w0, w1))
 TEST_NONE(ngc_1, ngc(x0, x1))
 TEST_NONE(nop_0, nop())
-TEST_NONE(orn_0, orn(w0, w1, Operand(w2, ASR, 5)))
-TEST_NONE(orn_1, orn(x0, x1, Operand(x2, ASR, 19)))
-TEST_NONE(orr_0, orr(w0, w1, 0x1e))
-TEST_NONE(orr_1, orr(x0, x1, 0xf0))
-TEST_NONE(orr_2, orr(w0, w1, Operand(w2, ASR, 2)))
-TEST_NONE(orr_3, orr(x0, x1, Operand(x2, ASR, 16)))
-TEST_NONE(prfm_0, prfm(PSTL1KEEP, MemOperand(x0, 12096)))
-TEST_NONE(prfm_1, prfm(PLDL2STRM, 0x2d4b3))
-TEST_NONE(prfm_2, prfm(PSTL1KEEP, MemOperand(x0, w1, SXTW, 0)))
-TEST_NONE(prfm_3, prfm(PLDL3KEEP, MemOperand(x0, x1, LSL, 3)))
-TEST_NONE(prfum_0, prfum(PSTL2KEEP, MemOperand(x0, -179)))
+TEST_NONE(orn_0, orn(w0, w1, Operand(w2, LSL, 6)))
+TEST_NONE(orn_1, orn(x0, x1, Operand(x2, LSL, 63)))
+TEST_NONE(orr_0, orr(w0, w1, 0x780000))
+TEST_NONE(orr_1, orr(x0, x1, 0x1e0000))
+TEST_NONE(orr_2, orr(w0, w1, Operand(w2, ASR, 24)))
+TEST_NONE(orr_3, orr(x0, x1, Operand(x2, LSR, 2)))
+TEST_NONE(prfm_0, prfm(PLDL2STRM, MemOperand(x0, 832)))
+TEST_NONE(prfm_1, prfm(PSTL1STRM, 0x2c2fa))
+TEST_NONE(prfm_2, prfm(PLDL1KEEP, MemOperand(x0, w1, SXTW, 0)))
+TEST_NONE(prfm_3, prfm(PSTL3STRM, MemOperand(x0, x1, SXTX, 0)))
+TEST_NONE(prfum_0, prfum(PSTL3KEEP, MemOperand(x0, 47)))
 TEST_NONE(rbit_0, rbit(w0, w1))
 TEST_NONE(rbit_1, rbit(x0, x1))
 TEST_NONE(ret_0, ret(x0))
@@ -386,12 +386,12 @@ TEST_NONE(sbc_0, sbc(w0, w1, w2))
 TEST_NONE(sbc_1, sbc(x0, x1, x2))
 TEST_NONE(sbcs_0, sbcs(w0, w1, w2))
 TEST_NONE(sbcs_1, sbcs(x0, x1, x2))
-TEST_NONE(sbfiz_0, sbfiz(w0, w1, 4, 12))
-TEST_NONE(sbfiz_1, sbfiz(x0, x1, 12, 44))
-TEST_NONE(sbfm_0, sbfm(w0, w1, 12, 14))
-TEST_NONE(sbfm_1, sbfm(x0, x1, 50, 61))
-TEST_NONE(sbfx_0, sbfx(w0, w1, 24, 2))
-TEST_NONE(sbfx_1, sbfx(x0, x1, 39, 21))
+TEST_NONE(sbfiz_0, sbfiz(w0, w1, 28, 2))
+TEST_NONE(sbfiz_1, sbfiz(x0, x1, 46, 5))
+TEST_NONE(sbfm_0, sbfm(w0, w1, 9, 11))
+TEST_NONE(sbfm_1, sbfm(x0, x1, 22, 22))
+TEST_NONE(sbfx_0, sbfx(w0, w1, 15, 9))
+TEST_NONE(sbfx_1, sbfx(x0, x1, 21, 16))
 TEST_NONE(sdiv_0, sdiv(w0, w1, w2))
 TEST_NONE(sdiv_1, sdiv(x0, x1, x2))
 TEST_NONE(smaddl_0, smaddl(x0, w1, w2, x3))
@@ -408,83 +408,83 @@ TEST_NONE(stlxr_0, stlxr(w0, w1, MemOperand(x2, 0)))
 TEST_NONE(stlxr_1, stlxr(w0, x1, MemOperand(x2, 0)))
 TEST_NONE(stlxrb_0, stlxrb(w0, w1, MemOperand(x2, 0)))
 TEST_NONE(stlxrh_0, stlxrh(w0, w1, MemOperand(x2, 0)))
-TEST_NONE(stnp_0, stnp(w0, w1, MemOperand(x2, 216)))
-TEST_NONE(stnp_1, stnp(x0, x1, MemOperand(x2, 336)))
+TEST_NONE(stnp_0, stnp(w0, w1, MemOperand(x2, -136)))
+TEST_NONE(stnp_1, stnp(x0, x1, MemOperand(x2, 480)))
 TEST_NONE(stp_0, stp(w0, w1, MemOperand(x2, 184)))
-TEST_NONE(stp_1, stp(w0, w1, MemOperand(x2, -104, PostIndex)))
-TEST_NONE(stp_2, stp(w0, w1, MemOperand(x2, -156, PreIndex)))
-TEST_NONE(stp_3, stp(x0, x1, MemOperand(x2, 152)))
-TEST_NONE(stp_4, stp(x0, x1, MemOperand(x2, -112, PostIndex)))
-TEST_NONE(stp_5, stp(x0, x1, MemOperand(x2, 416, PreIndex)))
-TEST_NONE(strb_0, strb(w0, MemOperand(x1, -5, PostIndex)))
-TEST_NONE(strb_1, strb(w0, MemOperand(x1, 40, PreIndex)))
-TEST_NONE(strb_2, strb(w0, MemOperand(x1, 3977)))
+TEST_NONE(stp_1, stp(w0, w1, MemOperand(x2, -16, PostIndex)))
+TEST_NONE(stp_2, stp(w0, w1, MemOperand(x2, -44, PreIndex)))
+TEST_NONE(stp_3, stp(x0, x1, MemOperand(x2, 472)))
+TEST_NONE(stp_4, stp(x0, x1, MemOperand(x2, 320, PostIndex)))
+TEST_NONE(stp_5, stp(x0, x1, MemOperand(x2, -392, PreIndex)))
+TEST_NONE(strb_0, strb(w0, MemOperand(x1, 146, PostIndex)))
+TEST_NONE(strb_1, strb(w0, MemOperand(x1, -120, PreIndex)))
+TEST_NONE(strb_2, strb(w0, MemOperand(x1, 1477)))
 TEST_NONE(strb_3, strb(w0, MemOperand(x1, x2, LSL, 0)))
 TEST_NONE(strb_4, strb(w0, MemOperand(x1, w2, SXTW, 0)))
 TEST_NONE(strb_5, strb(w0, MemOperand(x1, x2, SXTX, 0)))
-TEST_NONE(strh_0, strh(w0, MemOperand(x1, -54, PostIndex)))
-TEST_NONE(strh_1, strh(w0, MemOperand(x1, 79, PreIndex)))
-TEST_NONE(strh_2, strh(w0, MemOperand(x1, 5510)))
+TEST_NONE(strh_0, strh(w0, MemOperand(x1, -228, PostIndex)))
+TEST_NONE(strh_1, strh(w0, MemOperand(x1, 240, PreIndex)))
+TEST_NONE(strh_2, strh(w0, MemOperand(x1, 742)))
 TEST_NONE(strh_3, strh(w0, MemOperand(x1, w2, UXTW, 0)))
-TEST_NONE(strh_4, strh(w0, MemOperand(x1, x2, LSL, 0)))
-TEST_NONE(str_0, str(w0, MemOperand(x1, 78, PostIndex)))
-TEST_NONE(str_1, str(w0, MemOperand(x1, -109, PreIndex)))
-TEST_NONE(str_2, str(w0, MemOperand(x1, 14624)))
-TEST_NONE(str_3, str(x0, MemOperand(x1, 87, PostIndex)))
-TEST_NONE(str_4, str(x0, MemOperand(x1, 50, PreIndex)))
-TEST_NONE(str_5, str(x0, MemOperand(x1, 19144)))
-TEST_NONE(str_6, str(w0, MemOperand(x1, w2, SXTW, 0)))
-TEST_NONE(str_7, str(w0, MemOperand(x1, x2, LSL, 0)))
-TEST_NONE(str_8, str(x0, MemOperand(x1, w2, SXTW, 0)))
-TEST_NONE(str_9, str(x0, MemOperand(x1, x2, LSL, 0)))
-TEST_NONE(sturb_0, sturb(w0, MemOperand(x1, 247)))
-TEST_NONE(sturh_0, sturh(w0, MemOperand(x1, 230)))
-TEST_NONE(stur_0, stur(w0, MemOperand(x1, 255)))
-TEST_NONE(stur_1, stur(x0, MemOperand(x1, 34)))
+TEST_NONE(strh_4, strh(w0, MemOperand(x1, x2, LSL, 1)))
+TEST_NONE(str_0, str(w0, MemOperand(x1, 161, PostIndex)))
+TEST_NONE(str_1, str(w0, MemOperand(x1, -86, PreIndex)))
+TEST_NONE(str_2, str(w0, MemOperand(x1, 9200)))
+TEST_NONE(str_3, str(x0, MemOperand(x1, 121, PostIndex)))
+TEST_NONE(str_4, str(x0, MemOperand(x1, -6, PreIndex)))
+TEST_NONE(str_5, str(x0, MemOperand(x1, 28952)))
+TEST_NONE(str_6, str(w0, MemOperand(x1, w2, SXTW, 2)))
+TEST_NONE(str_7, str(w0, MemOperand(x1, x2, LSL, 2)))
+TEST_NONE(str_8, str(x0, MemOperand(x1, w2, UXTW, 0)))
+TEST_NONE(str_9, str(x0, MemOperand(x1, x2, SXTX, 0)))
+TEST_NONE(sturb_0, sturb(w0, MemOperand(x1, 67)))
+TEST_NONE(sturh_0, sturh(w0, MemOperand(x1, 173)))
+TEST_NONE(stur_0, stur(w0, MemOperand(x1, 151)))
+TEST_NONE(stur_1, stur(x0, MemOperand(x1, 134)))
 TEST_NONE(stxp_0, stxp(w0, w1, w2, MemOperand(x3, 0)))
 TEST_NONE(stxp_1, stxp(w0, x1, x2, MemOperand(x3, 0)))
 TEST_NONE(stxr_0, stxr(w0, w1, MemOperand(x2, 0)))
 TEST_NONE(stxr_1, stxr(w0, x1, MemOperand(x2, 0)))
 TEST_NONE(stxrb_0, stxrb(w0, w1, MemOperand(x2, 0)))
 TEST_NONE(stxrh_0, stxrh(w0, w1, MemOperand(x2, 0)))
-TEST_NONE(subs_0, subs(w0, w1, Operand(w2, UXTW, 0)))
-TEST_NONE(subs_1, subs(x0, x1, Operand(x2, UXTX, 1)))
-TEST_NONE(subs_2, subs(x0, x1, Operand(w2, UXTW, 4)))
-TEST_NONE(subs_3, subs(w0, w1, 0x1f))
-TEST_NONE(subs_4, subs(x0, x1, 0x210))
-TEST_NONE(subs_5, subs(w0, w1, Operand(w2, LSL, 10)))
-TEST_NONE(subs_6, subs(x0, x1, Operand(x2, LSL, 40)))
-TEST_NONE(sub_0, sub(w0, w1, Operand(w2, UXTB, 0)))
+TEST_NONE(subs_0, subs(w0, w1, Operand(w2, SXTH, 0)))
+TEST_NONE(subs_1, subs(x0, x1, Operand(x2, UXTX, 3)))
+TEST_NONE(subs_2, subs(x0, x1, Operand(w2, UXTB, 3)))
+TEST_NONE(subs_3, subs(w0, w1, 0x812))
+TEST_NONE(subs_4, subs(x0, x1, 0x915))
+TEST_NONE(subs_5, subs(w0, w1, Operand(w2, ASR, 7)))
+TEST_NONE(subs_6, subs(x0, x1, Operand(x2, LSR, 45)))
+TEST_NONE(sub_0, sub(w0, w1, Operand(w2, SXTW, 0)))
 TEST_NONE(sub_1, sub(x0, x1, Operand(x2, UXTX, 3)))
-TEST_NONE(sub_2, sub(x0, x1, Operand(w2, SXTW, 3)))
-TEST_NONE(sub_3, sub(w0, w1, 0x757))
-TEST_NONE(sub_4, sub(x0, x1, 0xa3c))
-TEST_NONE(sub_5, sub(w0, w1, Operand(w2, ASR, 30)))
-TEST_NONE(sub_6, sub(x0, x1, Operand(x2, LSR, 16)))
-TEST_NONE(svc_0, svc(0xcca4))
+TEST_NONE(sub_2, sub(x0, x1, Operand(w2, UXTB, 2)))
+TEST_NONE(sub_3, sub(w0, w1, 0x492 << 12))
+TEST_NONE(sub_4, sub(x0, x1, 0xa56 << 12))
+TEST_NONE(sub_5, sub(w0, w1, Operand(w2, ASR, 2)))
+TEST_NONE(sub_6, sub(x0, x1, Operand(x2, ASR, 45)))
+TEST_NONE(svc_0, svc(0x1220))
 TEST_NONE(sxtb_0, sxtb(w0, w1))
 TEST_NONE(sxtb_1, sxtb(x0, w1))
 TEST_NONE(sxth_0, sxth(w0, w1))
 TEST_NONE(sxth_1, sxth(x0, w1))
 TEST_NONE(sxtw_0, sxtw(x0, w1))
-TEST_NONE(sys_0, sys(1, 9, 2, 7, x0))
-TEST_NONE(sys_1, sys(0x2719, x0))
-TEST_NONE(tbnz_0, tbnz(x0, 21, &label))
-TEST_NONE(tbnz_1, tbnz(x0, 43, &label))
-TEST_NONE(tbnz_2, tbnz(w0, 17, &label))
-TEST_NONE(tbz_0, tbz(x0, 7, &label))
-TEST_NONE(tbz_1, tbz(x0, 33, &label))
-TEST_NONE(tbz_2, tbz(w0, 29, &label))
-TEST_NONE(tst_0, tst(w0, 0x78000))
-TEST_NONE(tst_1, tst(x0, 0xf00000))
-TEST_NONE(tst_2, tst(w0, Operand(w1, ASR, 4)))
-TEST_NONE(tst_3, tst(x0, Operand(x1, LSL, 46)))
-TEST_NONE(ubfiz_0, ubfiz(w0, w1, 5, 19))
-TEST_NONE(ubfiz_1, ubfiz(x0, x1, 4, 38))
-TEST_NONE(ubfm_0, ubfm(w0, w1, 15, 21))
-TEST_NONE(ubfm_1, ubfm(x0, x1, 50, 31))
-TEST_NONE(ubfx_0, ubfx(w0, w1, 8, 19))
-TEST_NONE(ubfx_1, ubfx(x0, x1, 63, 1))
+TEST_NONE(sys_0, sys(6, 10, 8, 3, x0))
+TEST_NONE(sys_1, sys(0x2ae9, x0))
+TEST_NONE(tbnz_0, tbnz(x0, 0, &label))
+TEST_NONE(tbnz_1, tbnz(x0, 37, &label))
+TEST_NONE(tbnz_2, tbnz(w0, 20, &label))
+TEST_NONE(tbz_0, tbz(x0, 24, &label))
+TEST_NONE(tbz_1, tbz(x0, 60, &label))
+TEST_NONE(tbz_2, tbz(w0, 13, &label))
+TEST_NONE(tst_0, tst(w0, 0x3c0))
+TEST_NONE(tst_1, tst(x0, 0x3c00))
+TEST_NONE(tst_2, tst(w0, Operand(w1, LSL, 12)))
+TEST_NONE(tst_3, tst(x0, Operand(x1, ASR, 16)))
+TEST_NONE(ubfiz_0, ubfiz(w0, w1, 10, 9))
+TEST_NONE(ubfiz_1, ubfiz(x0, x1, 13, 49))
+TEST_NONE(ubfm_0, ubfm(w0, w1, 18, 3))
+TEST_NONE(ubfm_1, ubfm(x0, x1, 54, 30))
+TEST_NONE(ubfx_0, ubfx(w0, w1, 24, 7))
+TEST_NONE(ubfx_1, ubfx(x0, x1, 11, 21))
 TEST_NONE(udiv_0, udiv(w0, w1, w2))
 TEST_NONE(udiv_1, udiv(x0, x1, x2))
 TEST_NONE(umaddl_0, umaddl(x0, w1, w2, x3))
@@ -500,10 +500,10 @@ TEST_FP(fabs_0, fabs(d0, d1))
 TEST_FP(fabs_1, fabs(s0, s1))
 TEST_FP(fadd_0, fadd(d0, d1, d2))
 TEST_FP(fadd_1, fadd(s0, s1, s2))
-TEST_FP(fccmpe_0, fccmpe(d0, d1, NVFlag, cs))
-TEST_FP(fccmpe_1, fccmpe(s0, s1, NFlag, ne))
-TEST_FP(fccmp_0, fccmp(d0, d1, NZCVFlag, lt))
-TEST_FP(fccmp_1, fccmp(s0, s1, NVFlag, le))
+TEST_FP(fccmpe_0, fccmpe(d0, d1, NCFlag, hi))
+TEST_FP(fccmpe_1, fccmpe(s0, s1, NZCFlag, ne))
+TEST_FP(fccmp_0, fccmp(d0, d1, NZCVFlag, pl))
+TEST_FP(fccmp_1, fccmp(s0, s1, ZCVFlag, eq))
 TEST_FP(fcmpe_0, fcmpe(d0, 0.0))
 TEST_FP(fcmpe_1, fcmpe(d0, d1))
 TEST_FP(fcmpe_2, fcmpe(s0, 0.0))
@@ -513,7 +513,7 @@ TEST_FP(fcmp_1, fcmp(d0, d1))
 TEST_FP(fcmp_2, fcmp(s0, 0.0))
 TEST_FP(fcmp_3, fcmp(s0, s1))
 TEST_FP(fcsel_0, fcsel(d0, d1, d2, cs))
-TEST_FP(fcsel_1, fcsel(s0, s1, s2, gt))
+TEST_FP(fcsel_1, fcsel(s0, s1, s2, ne))
 TEST_FP(fcvtas_0, fcvtas(w0, d1))
 TEST_FP(fcvtas_1, fcvtas(w0, s1))
 TEST_FP(fcvtas_2, fcvtas(x0, d1))
@@ -586,8 +586,8 @@ TEST_FP(fmov_2, fmov(w0, s1))
 TEST_FP(fmov_3, fmov(x0, d1))
 TEST_FP(fmov_4, fmov(d0, x1))
 TEST_FP(fmov_5, fmov(s0, w1))
-TEST_FP(fmov_6, fmov(d0, -0.359375))
-TEST_FP(fmov_7, fmov(s0, -0.6875f))
+TEST_FP(fmov_6, fmov(d0, -0.15625))
+TEST_FP(fmov_7, fmov(s0, -2.875f))
 TEST_FP(fmsub_0, fmsub(d0, d1, d2, d3))
 TEST_FP(fmsub_1, fmsub(s0, s1, s2, s3))
 TEST_FP(fmul_0, fmul(d0, d1, d2))
@@ -618,34 +618,34 @@ TEST_FP(fsqrt_0, fsqrt(d0, d1))
 TEST_FP(fsqrt_1, fsqrt(s0, s1))
 TEST_FP(fsub_0, fsub(d0, d1, d2))
 TEST_FP(fsub_1, fsub(s0, s1, s2))
-TEST_FP(ldnp_0, ldnp(d0, d1, MemOperand(x2, 504)))
-TEST_FP(ldnp_1, ldnp(s0, s1, MemOperand(x2, 184)))
-TEST_FP(ldp_0, ldp(d0, d1, MemOperand(x2, -192)))
-TEST_FP(ldp_1, ldp(d0, d1, MemOperand(x2, -104, PostIndex)))
-TEST_FP(ldp_2, ldp(d0, d1, MemOperand(x2, -128, PreIndex)))
-TEST_FP(ldp_3, ldp(s0, s1, MemOperand(x2, 156)))
-TEST_FP(ldp_4, ldp(s0, s1, MemOperand(x2, 224, PostIndex)))
-TEST_FP(ldp_5, ldp(s0, s1, MemOperand(x2, -76, PreIndex)))
-TEST_FP(ldr_0, ldr(d0, MemOperand(x1, 219, PostIndex)))
-TEST_FP(ldr_1, ldr(d0, MemOperand(x1, -45, PreIndex)))
-TEST_FP(ldr_2, ldr(d0, MemOperand(x1, 25840)))
-TEST_FP(ldr_3, ldr(h0, MemOperand(x1, 49, PostIndex)))
-TEST_FP(ldr_4, ldr(h0, MemOperand(x1, -172, PreIndex)))
-TEST_FP(ldr_5, ldr(h0, MemOperand(x1, 386)))
-TEST_FP(ldr_6, ldr(s0, MemOperand(x1, 105, PostIndex)))
-TEST_FP(ldr_7, ldr(s0, MemOperand(x1, -148, PreIndex)))
-TEST_FP(ldr_8, ldr(s0, MemOperand(x1, 944)))
-TEST_FP(ldr_9, ldr(d0, 0x3739f))
-TEST_FP(ldr_10, ldr(s0, 0x17874))
-TEST_FP(ldr_11, ldr(d0, MemOperand(x1, w2, SXTW, 0)))
-TEST_FP(ldr_12, ldr(d0, MemOperand(x1, x2, SXTX, 0)))
-TEST_FP(ldr_13, ldr(h0, MemOperand(x1, w2, SXTW, 1)))
+TEST_FP(ldnp_0, ldnp(d0, d1, MemOperand(x2, -32)))
+TEST_FP(ldnp_1, ldnp(s0, s1, MemOperand(x2, -180)))
+TEST_FP(ldp_0, ldp(d0, d1, MemOperand(x2, 112)))
+TEST_FP(ldp_1, ldp(d0, d1, MemOperand(x2, 24, PostIndex)))
+TEST_FP(ldp_2, ldp(d0, d1, MemOperand(x2, 192, PreIndex)))
+TEST_FP(ldp_3, ldp(s0, s1, MemOperand(x2, -72)))
+TEST_FP(ldp_4, ldp(s0, s1, MemOperand(x2, 0, PostIndex)))
+TEST_FP(ldp_5, ldp(s0, s1, MemOperand(x2, 144, PreIndex)))
+TEST_FP(ldr_0, ldr(d0, MemOperand(x1, -240, PostIndex)))
+TEST_FP(ldr_1, ldr(d0, MemOperand(x1, 110, PreIndex)))
+TEST_FP(ldr_2, ldr(d0, MemOperand(x1, 4048)))
+TEST_FP(ldr_3, ldr(h0, MemOperand(x1, -76, PostIndex)))
+TEST_FP(ldr_4, ldr(h0, MemOperand(x1, -124, PreIndex)))
+TEST_FP(ldr_5, ldr(h0, MemOperand(x1, 6230)))
+TEST_FP(ldr_6, ldr(s0, MemOperand(x1, 148, PostIndex)))
+TEST_FP(ldr_7, ldr(s0, MemOperand(x1, 68, PreIndex)))
+TEST_FP(ldr_8, ldr(s0, MemOperand(x1, 7424)))
+TEST_FP(ldr_9, ldr(d0, 0x35a20))
+TEST_FP(ldr_10, ldr(s0, 0x1053a))
+TEST_FP(ldr_11, ldr(d0, MemOperand(x1, w2, SXTW, 3)))
+TEST_FP(ldr_12, ldr(d0, MemOperand(x1, x2, SXTX, 3)))
+TEST_FP(ldr_13, ldr(h0, MemOperand(x1, w2, UXTW, 1)))
 TEST_FP(ldr_14, ldr(h0, MemOperand(x1, x2, SXTX, 0)))
-TEST_FP(ldr_15, ldr(s0, MemOperand(x1, w2, SXTW, 0)))
+TEST_FP(ldr_15, ldr(s0, MemOperand(x1, w2, SXTW, 2)))
 TEST_FP(ldr_16, ldr(s0, MemOperand(x1, x2, SXTX, 2)))
-TEST_FP(ldur_0, ldur(d0, MemOperand(x1, -255)))
-TEST_FP(ldur_1, ldur(h0, MemOperand(x1, 63)))
-TEST_FP(ldur_2, ldur(s0, MemOperand(x1, -199)))
+TEST_FP(ldur_0, ldur(d0, MemOperand(x1, -146)))
+TEST_FP(ldur_1, ldur(h0, MemOperand(x1, -117)))
+TEST_FP(ldur_2, ldur(s0, MemOperand(x1, 209)))
 TEST_FP(scvtf_0, scvtf(d0, w1, 5))
 TEST_FP(scvtf_1, scvtf(d0, x1, 5))
 TEST_FP(scvtf_2, scvtf(s0, w1, 5))
@@ -654,32 +654,32 @@ TEST_FP(scvtf_4, scvtf(d0, w1))
 TEST_FP(scvtf_5, scvtf(d0, x1))
 TEST_FP(scvtf_6, scvtf(s0, w1))
 TEST_FP(scvtf_7, scvtf(s0, x1))
-TEST_FP(stnp_0, stnp(d0, d1, MemOperand(x2, -200)))
-TEST_FP(stnp_1, stnp(s0, s1, MemOperand(x2, -216)))
-TEST_FP(stp_0, stp(d0, d1, MemOperand(x2, 504)))
-TEST_FP(stp_1, stp(d0, d1, MemOperand(x2, 32, PostIndex)))
-TEST_FP(stp_2, stp(d0, d1, MemOperand(x2, 480, PreIndex)))
-TEST_FP(stp_3, stp(s0, s1, MemOperand(x2, -60)))
-TEST_FP(stp_4, stp(s0, s1, MemOperand(x2, -92, PostIndex)))
-TEST_FP(stp_5, stp(s0, s1, MemOperand(x2, -180, PreIndex)))
-TEST_FP(str_0, str(d0, MemOperand(x1, 17, PostIndex)))
-TEST_FP(str_1, str(d0, MemOperand(x1, 84, PreIndex)))
-TEST_FP(str_2, str(d0, MemOperand(x1, 8632)))
-TEST_FP(str_3, str(h0, MemOperand(x1, -212, PostIndex)))
-TEST_FP(str_4, str(h0, MemOperand(x1, 61, PreIndex)))
-TEST_FP(str_5, str(h0, MemOperand(x1, 6858)))
-TEST_FP(str_6, str(s0, MemOperand(x1, -40, PostIndex)))
-TEST_FP(str_7, str(s0, MemOperand(x1, 191, PreIndex)))
-TEST_FP(str_8, str(s0, MemOperand(x1, 3872)))
-TEST_FP(str_9, str(d0, MemOperand(x1, w2, UXTW, 3)))
+TEST_FP(stnp_0, stnp(d0, d1, MemOperand(x2, 304)))
+TEST_FP(stnp_1, stnp(s0, s1, MemOperand(x2, -12)))
+TEST_FP(stp_0, stp(d0, d1, MemOperand(x2, 168)))
+TEST_FP(stp_1, stp(d0, d1, MemOperand(x2, -376, PostIndex)))
+TEST_FP(stp_2, stp(d0, d1, MemOperand(x2, 296, PreIndex)))
+TEST_FP(stp_3, stp(s0, s1, MemOperand(x2, -256)))
+TEST_FP(stp_4, stp(s0, s1, MemOperand(x2, 208, PostIndex)))
+TEST_FP(stp_5, stp(s0, s1, MemOperand(x2, -4, PreIndex)))
+TEST_FP(str_0, str(d0, MemOperand(x1, -181, PostIndex)))
+TEST_FP(str_1, str(d0, MemOperand(x1, 91, PreIndex)))
+TEST_FP(str_2, str(d0, MemOperand(x1, 32672)))
+TEST_FP(str_3, str(h0, MemOperand(x1, -5, PostIndex)))
+TEST_FP(str_4, str(h0, MemOperand(x1, 213, PreIndex)))
+TEST_FP(str_5, str(h0, MemOperand(x1, 6406)))
+TEST_FP(str_6, str(s0, MemOperand(x1, -81, PostIndex)))
+TEST_FP(str_7, str(s0, MemOperand(x1, -126, PreIndex)))
+TEST_FP(str_8, str(s0, MemOperand(x1, 15692)))
+TEST_FP(str_9, str(d0, MemOperand(x1, w2, SXTW, 0)))
 TEST_FP(str_10, str(d0, MemOperand(x1, x2, LSL, 0)))
 TEST_FP(str_11, str(h0, MemOperand(x1, w2, UXTW, 1)))
 TEST_FP(str_12, str(h0, MemOperand(x1, x2, SXTX, 1)))
 TEST_FP(str_13, str(s0, MemOperand(x1, w2, UXTW, 0)))
-TEST_FP(str_14, str(s0, MemOperand(x1, x2, SXTX, 0)))
-TEST_FP(stur_0, stur(d0, MemOperand(x1, 154)))
-TEST_FP(stur_1, stur(h0, MemOperand(x1, 123)))
-TEST_FP(stur_2, stur(s0, MemOperand(x1, -71)))
+TEST_FP(str_14, str(s0, MemOperand(x1, x2, SXTX, 2)))
+TEST_FP(stur_0, stur(d0, MemOperand(x1, 22)))
+TEST_FP(stur_1, stur(h0, MemOperand(x1, -236)))
+TEST_FP(stur_2, stur(s0, MemOperand(x1, 23)))
 TEST_FP(ucvtf_0, ucvtf(d0, w1, 5))
 TEST_FP(ucvtf_1, ucvtf(d0, x1, 5))
 TEST_FP(ucvtf_2, ucvtf(s0, w1, 5))
@@ -728,16 +728,12 @@ TEST_NEON(add_6, add(v0.V2D(), v1.V2D(), v2.V2D()))
 TEST_NEON(add_7, add(d0, d1, d2))
 TEST_NEON(and_0, and_(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(and_1, and_(v0.V16B(), v1.V16B(), v2.V16B()))
-TEST_NEON(bic_0, bic(v0.V4H(), 0x7d, 0))
-TEST_NEON(bic_1, bic(v0.V8H(), 0x8a, 0))
-TEST_NEON(bic_2, bic(v0.V2S(), 0x3b, 16))
-TEST_NEON(bic_3, bic(v0.V4S(), 0xd6, 8))
-TEST_NEON(bic_4, bic(v0.V4H(), 0x27, 0))
-TEST_NEON(bic_5, bic(v0.V8H(), 0x3f, 8))
-TEST_NEON(bic_6, bic(v0.V2S(), 0xed, 0))
-TEST_NEON(bic_7, bic(v0.V4S(), 0x36, 16))
-TEST_NEON(bic_8, bic(v0.V8B(), v1.V8B(), v2.V8B()))
-TEST_NEON(bic_9, bic(v0.V16B(), v1.V16B(), v2.V16B()))
+TEST_NEON(bic_0, bic(v0.V4H(), 0x55, 0))
+TEST_NEON(bic_1, bic(v0.V8H(), 0x3a, 0))
+TEST_NEON(bic_2, bic(v0.V2S(), 0xd8, 0))
+TEST_NEON(bic_3, bic(v0.V4S(), 0x15, 0))
+TEST_NEON(bic_4, bic(v0.V8B(), v1.V8B(), v2.V8B()))
+TEST_NEON(bic_5, bic(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(bif_0, bif(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(bif_1, bif(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(bit_0, bit(v0.V8B(), v1.V8B(), v2.V8B()))
@@ -846,16 +842,16 @@ TEST_NEON(cmtst_6, cmtst(v0.V2D(), v1.V2D(), v2.V2D()))
 TEST_NEON(cmtst_7, cmtst(d0, d1, d2))
 TEST_NEON(cnt_0, cnt(v0.V8B(), v1.V8B()))
 TEST_NEON(cnt_1, cnt(v0.V16B(), v1.V16B()))
-TEST_NEON(dup_0, dup(v0.V8B(), v1.B(), 13))
-TEST_NEON(dup_1, dup(v0.V16B(), v1.B(), 2))
-TEST_NEON(dup_2, dup(v0.V4H(), v1.H(), 4))
+TEST_NEON(dup_0, dup(v0.V8B(), v1.B(), 11))
+TEST_NEON(dup_1, dup(v0.V16B(), v1.B(), 11))
+TEST_NEON(dup_2, dup(v0.V4H(), v1.H(), 2))
 TEST_NEON(dup_3, dup(v0.V8H(), v1.H(), 5))
-TEST_NEON(dup_4, dup(v0.V2S(), v1.S(), 2))
+TEST_NEON(dup_4, dup(v0.V2S(), v1.S(), 3))
 TEST_NEON(dup_5, dup(v0.V4S(), v1.S(), 0))
 TEST_NEON(dup_6, dup(v0.V2D(), v1.D(), 0))
-TEST_NEON(dup_7, dup(b0, v1.B(), 0))
+TEST_NEON(dup_7, dup(b0, v1.B(), 14))
 TEST_NEON(dup_8, dup(h0, v1.H(), 7))
-TEST_NEON(dup_9, dup(s0, v1.S(), 3))
+TEST_NEON(dup_9, dup(s0, v1.S(), 2))
 TEST_NEON(dup_10, dup(d0, v1.D(), 0))
 TEST_NEON(dup_11, dup(v0.V8B(), w1))
 TEST_NEON(dup_12, dup(v0.V16B(), w1))
@@ -866,15 +862,15 @@ TEST_NEON(dup_16, dup(v0.V4S(), w1))
 TEST_NEON(dup_17, dup(v0.V2D(), x1))
 TEST_NEON(eor_0, eor(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(eor_1, eor(v0.V16B(), v1.V16B(), v2.V16B()))
-TEST_NEON(ext_0, ext(v0.V8B(), v1.V8B(), v2.V8B(), 7))
-TEST_NEON(ext_1, ext(v0.V16B(), v1.V16B(), v2.V16B(), 7))
-TEST_NEON(ins_0, ins(v0.B(), 13, v1.B(), 9))
-TEST_NEON(ins_1, ins(v0.H(), 3, v1.H(), 3))
-TEST_NEON(ins_2, ins(v0.S(), 3, v1.S(), 0))
-TEST_NEON(ins_3, ins(v0.D(), 1, v1.D(), 0))
-TEST_NEON(ins_4, ins(v0.B(), 11, w1))
-TEST_NEON(ins_5, ins(v0.H(), 1, w1))
-TEST_NEON(ins_6, ins(v0.S(), 1, w1))
+TEST_NEON(ext_0, ext(v0.V8B(), v1.V8B(), v2.V8B(), 3))
+TEST_NEON(ext_1, ext(v0.V16B(), v1.V16B(), v2.V16B(), 5))
+TEST_NEON(ins_0, ins(v0.B(), 6, v1.B(), 13))
+TEST_NEON(ins_1, ins(v0.H(), 1, v1.H(), 5))
+TEST_NEON(ins_2, ins(v0.S(), 2, v1.S(), 1))
+TEST_NEON(ins_3, ins(v0.D(), 1, v1.D(), 1))
+TEST_NEON(ins_4, ins(v0.B(), 15, w1))
+TEST_NEON(ins_5, ins(v0.H(), 4, w1))
+TEST_NEON(ins_6, ins(v0.S(), 2, w1))
 TEST_NEON(ins_7, ins(v0.D(), 1, x1))
 TEST_NEON(ld1r_0, ld1r(v0.V8B(), MemOperand(x1)))
 TEST_NEON(ld1r_1, ld1r(v0.V16B(), MemOperand(x1)))
@@ -1051,17 +1047,17 @@ TEST_NEON(
 TEST_NEON(
     ld1_95,
     ld1(v0.V2D(), v1.V2D(), v2.V2D(), v3.V2D(), MemOperand(x4, x5, PostIndex)))
-TEST_NEON(ld1_96, ld1(v0.B(), 1, MemOperand(x1)))
+TEST_NEON(ld1_96, ld1(v0.B(), 13, MemOperand(x1)))
 TEST_NEON(ld1_97, ld1(v0.D(), 0, MemOperand(x1)))
-TEST_NEON(ld1_98, ld1(v0.H(), 1, MemOperand(x1)))
-TEST_NEON(ld1_99, ld1(v0.S(), 0, MemOperand(x1)))
-TEST_NEON(ld1_100, ld1(v0.B(), 6, MemOperand(x1, 1, PostIndex)))
-TEST_NEON(ld1_101, ld1(v0.B(), 1, MemOperand(x1, x2, PostIndex)))
-TEST_NEON(ld1_102, ld1(v0.D(), 1, MemOperand(x1, 8, PostIndex)))
+TEST_NEON(ld1_98, ld1(v0.H(), 5, MemOperand(x1)))
+TEST_NEON(ld1_99, ld1(v0.S(), 2, MemOperand(x1)))
+TEST_NEON(ld1_100, ld1(v0.B(), 3, MemOperand(x1, 1, PostIndex)))
+TEST_NEON(ld1_101, ld1(v0.B(), 14, MemOperand(x1, x2, PostIndex)))
+TEST_NEON(ld1_102, ld1(v0.D(), 0, MemOperand(x1, 8, PostIndex)))
 TEST_NEON(ld1_103, ld1(v0.D(), 1, MemOperand(x1, x2, PostIndex)))
-TEST_NEON(ld1_104, ld1(v0.H(), 1, MemOperand(x1, 2, PostIndex)))
-TEST_NEON(ld1_105, ld1(v0.H(), 5, MemOperand(x1, x2, PostIndex)))
-TEST_NEON(ld1_106, ld1(v0.S(), 2, MemOperand(x1, 4, PostIndex)))
+TEST_NEON(ld1_104, ld1(v0.H(), 3, MemOperand(x1, 2, PostIndex)))
+TEST_NEON(ld1_105, ld1(v0.H(), 6, MemOperand(x1, x2, PostIndex)))
+TEST_NEON(ld1_106, ld1(v0.S(), 0, MemOperand(x1, 4, PostIndex)))
 TEST_NEON(ld1_107, ld1(v0.S(), 3, MemOperand(x1, x2, PostIndex)))
 TEST_NEON(ld2r_0, ld2r(v0.V8B(), v1.V8B(), MemOperand(x2)))
 TEST_NEON(ld2r_1, ld2r(v0.V16B(), v1.V16B(), MemOperand(x2)))
@@ -1108,18 +1104,18 @@ TEST_NEON(ld2_17, ld2(v0.V8H(), v1.V8H(), MemOperand(x2, x3, PostIndex)))
 TEST_NEON(ld2_18, ld2(v0.V2S(), v1.V2S(), MemOperand(x2, x3, PostIndex)))
 TEST_NEON(ld2_19, ld2(v0.V4S(), v1.V4S(), MemOperand(x2, x3, PostIndex)))
 TEST_NEON(ld2_20, ld2(v0.V2D(), v1.V2D(), MemOperand(x2, x3, PostIndex)))
-TEST_NEON(ld2_21, ld2(v0.B(), v1.B(), 7, MemOperand(x2)))
+TEST_NEON(ld2_21, ld2(v0.B(), v1.B(), 10, MemOperand(x2)))
 TEST_NEON(ld2_22, ld2(v0.D(), v1.D(), 0, MemOperand(x2)))
-TEST_NEON(ld2_23, ld2(v0.H(), v1.H(), 4, MemOperand(x2)))
-TEST_NEON(ld2_24, ld2(v0.S(), v1.S(), 3, MemOperand(x2)))
-TEST_NEON(ld2_25, ld2(v0.B(), v1.B(), 9, MemOperand(x2, 2, PostIndex)))
-TEST_NEON(ld2_26, ld2(v0.B(), v1.B(), 1, MemOperand(x2, x3, PostIndex)))
+TEST_NEON(ld2_23, ld2(v0.H(), v1.H(), 3, MemOperand(x2)))
+TEST_NEON(ld2_24, ld2(v0.S(), v1.S(), 1, MemOperand(x2)))
+TEST_NEON(ld2_25, ld2(v0.B(), v1.B(), 7, MemOperand(x2, 2, PostIndex)))
+TEST_NEON(ld2_26, ld2(v0.B(), v1.B(), 4, MemOperand(x2, x3, PostIndex)))
 TEST_NEON(ld2_27, ld2(v0.D(), v1.D(), 1, MemOperand(x2, 16, PostIndex)))
-TEST_NEON(ld2_28, ld2(v0.D(), v1.D(), 0, MemOperand(x2, x3, PostIndex)))
-TEST_NEON(ld2_29, ld2(v0.H(), v1.H(), 7, MemOperand(x2, 4, PostIndex)))
-TEST_NEON(ld2_30, ld2(v0.H(), v1.H(), 2, MemOperand(x2, x3, PostIndex)))
+TEST_NEON(ld2_28, ld2(v0.D(), v1.D(), 1, MemOperand(x2, x3, PostIndex)))
+TEST_NEON(ld2_29, ld2(v0.H(), v1.H(), 0, MemOperand(x2, 4, PostIndex)))
+TEST_NEON(ld2_30, ld2(v0.H(), v1.H(), 6, MemOperand(x2, x3, PostIndex)))
 TEST_NEON(ld2_31, ld2(v0.S(), v1.S(), 3, MemOperand(x2, 8, PostIndex)))
-TEST_NEON(ld2_32, ld2(v0.S(), v1.S(), 1, MemOperand(x2, x3, PostIndex)))
+TEST_NEON(ld2_32, ld2(v0.S(), v1.S(), 3, MemOperand(x2, x3, PostIndex)))
 TEST_NEON(ld3r_0, ld3r(v0.V8B(), v1.V8B(), v2.V8B(), MemOperand(x3)))
 TEST_NEON(ld3r_1, ld3r(v0.V16B(), v1.V16B(), v2.V16B(), MemOperand(x3)))
 TEST_NEON(ld3r_2, ld3r(v0.V4H(), v1.V4H(), v2.V4H(), MemOperand(x3)))
@@ -1195,19 +1191,19 @@ TEST_NEON(ld3_19,
           ld3(v0.V4S(), v1.V4S(), v2.V4S(), MemOperand(x3, x4, PostIndex)))
 TEST_NEON(ld3_20,
           ld3(v0.V2D(), v1.V2D(), v2.V2D(), MemOperand(x3, x4, PostIndex)))
-TEST_NEON(ld3_21, ld3(v0.B(), v1.B(), v2.B(), 1, MemOperand(x3)))
+TEST_NEON(ld3_21, ld3(v0.B(), v1.B(), v2.B(), 6, MemOperand(x3)))
 TEST_NEON(ld3_22, ld3(v0.D(), v1.D(), v2.D(), 1, MemOperand(x3)))
-TEST_NEON(ld3_23, ld3(v0.H(), v1.H(), v2.H(), 7, MemOperand(x3)))
-TEST_NEON(ld3_24, ld3(v0.S(), v1.S(), v2.S(), 1, MemOperand(x3)))
+TEST_NEON(ld3_23, ld3(v0.H(), v1.H(), v2.H(), 1, MemOperand(x3)))
+TEST_NEON(ld3_24, ld3(v0.S(), v1.S(), v2.S(), 2, MemOperand(x3)))
 TEST_NEON(ld3_25, ld3(v0.B(), v1.B(), v2.B(), 7, MemOperand(x3, 3, PostIndex)))
 TEST_NEON(ld3_26,
-          ld3(v0.B(), v1.B(), v2.B(), 13, MemOperand(x3, x4, PostIndex)))
+          ld3(v0.B(), v1.B(), v2.B(), 10, MemOperand(x3, x4, PostIndex)))
 TEST_NEON(ld3_27, ld3(v0.D(), v1.D(), v2.D(), 1, MemOperand(x3, 24, PostIndex)))
-TEST_NEON(ld3_28, ld3(v0.D(), v1.D(), v2.D(), 1, MemOperand(x3, x4, PostIndex)))
-TEST_NEON(ld3_29, ld3(v0.H(), v1.H(), v2.H(), 1, MemOperand(x3, 6, PostIndex)))
-TEST_NEON(ld3_30, ld3(v0.H(), v1.H(), v2.H(), 6, MemOperand(x3, x4, PostIndex)))
+TEST_NEON(ld3_28, ld3(v0.D(), v1.D(), v2.D(), 0, MemOperand(x3, x4, PostIndex)))
+TEST_NEON(ld3_29, ld3(v0.H(), v1.H(), v2.H(), 0, MemOperand(x3, 6, PostIndex)))
+TEST_NEON(ld3_30, ld3(v0.H(), v1.H(), v2.H(), 2, MemOperand(x3, x4, PostIndex)))
 TEST_NEON(ld3_31, ld3(v0.S(), v1.S(), v2.S(), 2, MemOperand(x3, 12, PostIndex)))
-TEST_NEON(ld3_32, ld3(v0.S(), v1.S(), v2.S(), 2, MemOperand(x3, x4, PostIndex)))
+TEST_NEON(ld3_32, ld3(v0.S(), v1.S(), v2.S(), 0, MemOperand(x3, x4, PostIndex)))
 TEST_NEON(ld4r_0, ld4r(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(), MemOperand(x4)))
 TEST_NEON(ld4r_1,
           ld4r(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), MemOperand(x4)))
@@ -1327,86 +1323,84 @@ TEST_NEON(
 TEST_NEON(
     ld4_20,
     ld4(v0.V2D(), v1.V2D(), v2.V2D(), v3.V2D(), MemOperand(x4, x5, PostIndex)))
-TEST_NEON(ld4_21, ld4(v0.B(), v1.B(), v2.B(), v3.B(), 13, MemOperand(x4)))
+TEST_NEON(ld4_21, ld4(v0.B(), v1.B(), v2.B(), v3.B(), 15, MemOperand(x4)))
 TEST_NEON(ld4_22, ld4(v0.D(), v1.D(), v2.D(), v3.D(), 1, MemOperand(x4)))
-TEST_NEON(ld4_23, ld4(v0.H(), v1.H(), v2.H(), v3.H(), 4, MemOperand(x4)))
-TEST_NEON(ld4_24, ld4(v0.S(), v1.S(), v2.S(), v3.S(), 1, MemOperand(x4)))
+TEST_NEON(ld4_23, ld4(v0.H(), v1.H(), v2.H(), v3.H(), 2, MemOperand(x4)))
+TEST_NEON(ld4_24, ld4(v0.S(), v1.S(), v2.S(), v3.S(), 0, MemOperand(x4)))
 TEST_NEON(ld4_25,
-          ld4(v0.B(), v1.B(), v2.B(), v3.B(), 5, MemOperand(x4, 4, PostIndex)))
-TEST_NEON(
-    ld4_26,
-    ld4(v0.B(), v1.B(), v2.B(), v3.B(), 11, MemOperand(x4, x5, PostIndex)))
+          ld4(v0.B(), v1.B(), v2.B(), v3.B(), 0, MemOperand(x4, 4, PostIndex)))
+TEST_NEON(ld4_26,
+          ld4(v0.B(), v1.B(), v2.B(), v3.B(), 0, MemOperand(x4, x5, PostIndex)))
 TEST_NEON(ld4_27,
-          ld4(v0.D(), v1.D(), v2.D(), v3.D(), 1, MemOperand(x4, 32, PostIndex)))
+          ld4(v0.D(), v1.D(), v2.D(), v3.D(), 0, MemOperand(x4, 32, PostIndex)))
 TEST_NEON(ld4_28,
-          ld4(v0.D(), v1.D(), v2.D(), v3.D(), 1, MemOperand(x4, x5, PostIndex)))
+          ld4(v0.D(), v1.D(), v2.D(), v3.D(), 0, MemOperand(x4, x5, PostIndex)))
 TEST_NEON(ld4_29,
-          ld4(v0.H(), v1.H(), v2.H(), v3.H(), 0, MemOperand(x4, 8, PostIndex)))
+          ld4(v0.H(), v1.H(), v2.H(), v3.H(), 1, MemOperand(x4, 8, PostIndex)))
 TEST_NEON(ld4_30,
-          ld4(v0.H(), v1.H(), v2.H(), v3.H(), 6, MemOperand(x4, x5, PostIndex)))
+          ld4(v0.H(), v1.H(), v2.H(), v3.H(), 7, MemOperand(x4, x5, PostIndex)))
 TEST_NEON(ld4_31,
-          ld4(v0.S(), v1.S(), v2.S(), v3.S(), 0, MemOperand(x4, 16, PostIndex)))
+          ld4(v0.S(), v1.S(), v2.S(), v3.S(), 3, MemOperand(x4, 16, PostIndex)))
 TEST_NEON(ld4_32,
-          ld4(v0.S(), v1.S(), v2.S(), v3.S(), 2, MemOperand(x4, x5, PostIndex)))
-TEST_NEON(ldnp_0, ldnp(d0, d1, MemOperand(x2, 504)))
-TEST_NEON(ldnp_1, ldnp(q0, q1, MemOperand(x2, -384)))
-TEST_NEON(ldnp_2, ldnp(s0, s1, MemOperand(x2, 184)))
-TEST_NEON(ldp_0, ldp(d0, d1, MemOperand(x2, -192)))
-TEST_NEON(ldp_1, ldp(d0, d1, MemOperand(x2, -104, PostIndex)))
-TEST_NEON(ldp_2, ldp(d0, d1, MemOperand(x2, -128, PreIndex)))
-TEST_NEON(ldp_3, ldp(q0, q1, MemOperand(x2, -768)))
-TEST_NEON(ldp_4, ldp(q0, q1, MemOperand(x2, -624, PostIndex)))
-TEST_NEON(ldp_5, ldp(q0, q1, MemOperand(x2, -208, PreIndex)))
-TEST_NEON(ldp_6, ldp(s0, s1, MemOperand(x2, 156)))
-TEST_NEON(ldp_7, ldp(s0, s1, MemOperand(x2, 224, PostIndex)))
-TEST_NEON(ldp_8, ldp(s0, s1, MemOperand(x2, -76, PreIndex)))
-TEST_NEON(ldr_0, ldr(b0, MemOperand(x1, 13, PostIndex)))
-TEST_NEON(ldr_1, ldr(b0, MemOperand(x1, -21, PreIndex)))
-TEST_NEON(ldr_2, ldr(b0, MemOperand(x1, 2300)))
-TEST_NEON(ldr_3, ldr(d0, MemOperand(x1, 219, PostIndex)))
-TEST_NEON(ldr_4, ldr(d0, MemOperand(x1, -45, PreIndex)))
-TEST_NEON(ldr_5, ldr(d0, MemOperand(x1, 25840)))
-TEST_NEON(ldr_6, ldr(h0, MemOperand(x1, 49, PostIndex)))
-TEST_NEON(ldr_7, ldr(h0, MemOperand(x1, -172, PreIndex)))
-TEST_NEON(ldr_8, ldr(h0, MemOperand(x1, 386)))
-TEST_NEON(ldr_9, ldr(q0, MemOperand(x1, 75, PostIndex)))
-TEST_NEON(ldr_10, ldr(q0, MemOperand(x1, -44, PreIndex)))
-TEST_NEON(ldr_11, ldr(q0, MemOperand(x1, 35680)))
-TEST_NEON(ldr_12, ldr(s0, MemOperand(x1, 105, PostIndex)))
-TEST_NEON(ldr_13, ldr(s0, MemOperand(x1, -148, PreIndex)))
-TEST_NEON(ldr_14, ldr(s0, MemOperand(x1, 944)))
-TEST_NEON(ldr_15, ldr(d0, 0x3739f))
-TEST_NEON(ldr_16, ldr(q0, 0x1a9a5))
-TEST_NEON(ldr_17, ldr(s0, 0x17874))
+          ld4(v0.S(), v1.S(), v2.S(), v3.S(), 1, MemOperand(x4, x5, PostIndex)))
+TEST_NEON(ldnp_0, ldnp(d0, d1, MemOperand(x2, -32)))
+TEST_NEON(ldnp_1, ldnp(q0, q1, MemOperand(x2, 288)))
+TEST_NEON(ldnp_2, ldnp(s0, s1, MemOperand(x2, -180)))
+TEST_NEON(ldp_0, ldp(d0, d1, MemOperand(x2, 112)))
+TEST_NEON(ldp_1, ldp(d0, d1, MemOperand(x2, 24, PostIndex)))
+TEST_NEON(ldp_2, ldp(d0, d1, MemOperand(x2, 192, PreIndex)))
+TEST_NEON(ldp_3, ldp(q0, q1, MemOperand(x2, 256)))
+TEST_NEON(ldp_4, ldp(q0, q1, MemOperand(x2, -976, PostIndex)))
+TEST_NEON(ldp_5, ldp(q0, q1, MemOperand(x2, -976, PreIndex)))
+TEST_NEON(ldp_6, ldp(s0, s1, MemOperand(x2, -72)))
+TEST_NEON(ldp_7, ldp(s0, s1, MemOperand(x2, 0, PostIndex)))
+TEST_NEON(ldp_8, ldp(s0, s1, MemOperand(x2, 144, PreIndex)))
+TEST_NEON(ldr_0, ldr(b0, MemOperand(x1, -172, PostIndex)))
+TEST_NEON(ldr_1, ldr(b0, MemOperand(x1, 39, PreIndex)))
+TEST_NEON(ldr_2, ldr(b0, MemOperand(x1, 1471)))
+TEST_NEON(ldr_3, ldr(d0, MemOperand(x1, -240, PostIndex)))
+TEST_NEON(ldr_4, ldr(d0, MemOperand(x1, 110, PreIndex)))
+TEST_NEON(ldr_5, ldr(d0, MemOperand(x1, 4048)))
+TEST_NEON(ldr_6, ldr(h0, MemOperand(x1, -76, PostIndex)))
+TEST_NEON(ldr_7, ldr(h0, MemOperand(x1, -124, PreIndex)))
+TEST_NEON(ldr_8, ldr(h0, MemOperand(x1, 6230)))
+TEST_NEON(ldr_9, ldr(q0, MemOperand(x1, -13, PostIndex)))
+TEST_NEON(ldr_10, ldr(q0, MemOperand(x1, 17, PreIndex)))
+TEST_NEON(ldr_11, ldr(q0, MemOperand(x1, 11376)))
+TEST_NEON(ldr_12, ldr(s0, MemOperand(x1, 148, PostIndex)))
+TEST_NEON(ldr_13, ldr(s0, MemOperand(x1, 68, PreIndex)))
+TEST_NEON(ldr_14, ldr(s0, MemOperand(x1, 7424)))
+TEST_NEON(ldr_15, ldr(d0, 0x35a20))
+TEST_NEON(ldr_16, ldr(q0, 0xc067))
+TEST_NEON(ldr_17, ldr(s0, 0x1053a))
 TEST_NEON(ldr_18, ldr(b0, MemOperand(x1, x2, LSL, 0)))
-TEST_NEON(ldr_19, ldr(b0, MemOperand(x1, w2, UXTW, 0)))
-TEST_NEON(ldr_20, ldr(b0, MemOperand(x1, x2, SXTX, 0)))
-TEST_NEON(ldr_21, ldr(d0, MemOperand(x1, w2, SXTW, 0)))
-TEST_NEON(ldr_22, ldr(d0, MemOperand(x1, x2, SXTX, 0)))
-TEST_NEON(ldr_23, ldr(h0, MemOperand(x1, w2, SXTW, 1)))
-TEST_NEON(ldr_24, ldr(h0, MemOperand(x1, x2, SXTX, 0)))
-TEST_NEON(ldr_25, ldr(q0, MemOperand(x1, w2, SXTW, 4)))
-TEST_NEON(ldr_26, ldr(q0, MemOperand(x1, x2, LSL, 0)))
-TEST_NEON(ldr_27, ldr(s0, MemOperand(x1, w2, SXTW, 0)))
-TEST_NEON(ldr_28, ldr(s0, MemOperand(x1, x2, SXTX, 2)))
-TEST_NEON(ldur_0, ldur(b0, MemOperand(x1, 22)))
-TEST_NEON(ldur_1, ldur(d0, MemOperand(x1, -255)))
-TEST_NEON(ldur_2, ldur(h0, MemOperand(x1, 63)))
-TEST_NEON(ldur_3, ldur(q0, MemOperand(x1, -130)))
-TEST_NEON(ldur_4, ldur(s0, MemOperand(x1, -199)))
-TEST_NEON(mla_0, mla(v0.V4H(), v1.V4H(), v2.H(), 6))
-TEST_NEON(mla_1, mla(v0.V8H(), v1.V8H(), v2.H(), 1))
+TEST_NEON(ldr_19, ldr(b0, MemOperand(x1, w2, SXTW, 0)))
+TEST_NEON(ldr_20, ldr(d0, MemOperand(x1, w2, SXTW, 3)))
+TEST_NEON(ldr_21, ldr(d0, MemOperand(x1, x2, SXTX, 3)))
+TEST_NEON(ldr_22, ldr(h0, MemOperand(x1, w2, UXTW, 1)))
+TEST_NEON(ldr_23, ldr(h0, MemOperand(x1, x2, SXTX, 0)))
+TEST_NEON(ldr_24, ldr(q0, MemOperand(x1, w2, UXTW, 4)))
+TEST_NEON(ldr_25, ldr(q0, MemOperand(x1, x2, SXTX, 4)))
+TEST_NEON(ldr_26, ldr(s0, MemOperand(x1, w2, SXTW, 2)))
+TEST_NEON(ldr_27, ldr(s0, MemOperand(x1, x2, SXTX, 2)))
+TEST_NEON(ldur_0, ldur(b0, MemOperand(x1, 153)))
+TEST_NEON(ldur_1, ldur(d0, MemOperand(x1, -146)))
+TEST_NEON(ldur_2, ldur(h0, MemOperand(x1, -117)))
+TEST_NEON(ldur_3, ldur(q0, MemOperand(x1, -81)))
+TEST_NEON(ldur_4, ldur(s0, MemOperand(x1, 209)))
+TEST_NEON(mla_0, mla(v0.V4H(), v1.V4H(), v2.H(), 1))
+TEST_NEON(mla_1, mla(v0.V8H(), v1.V8H(), v2.H(), 7))
 TEST_NEON(mla_2, mla(v0.V2S(), v1.V2S(), v2.S(), 0))
-TEST_NEON(mla_3, mla(v0.V4S(), v1.V4S(), v2.S(), 2))
+TEST_NEON(mla_3, mla(v0.V4S(), v1.V4S(), v2.S(), 3))
 TEST_NEON(mla_4, mla(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(mla_5, mla(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(mla_6, mla(v0.V4H(), v1.V4H(), v2.V4H()))
 TEST_NEON(mla_7, mla(v0.V8H(), v1.V8H(), v2.V8H()))
 TEST_NEON(mla_8, mla(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(mla_9, mla(v0.V4S(), v1.V4S(), v2.V4S()))
-TEST_NEON(mls_0, mls(v0.V4H(), v1.V4H(), v2.H(), 1))
-TEST_NEON(mls_1, mls(v0.V8H(), v1.V8H(), v2.H(), 6))
-TEST_NEON(mls_2, mls(v0.V2S(), v1.V2S(), v2.S(), 2))
+TEST_NEON(mls_0, mls(v0.V4H(), v1.V4H(), v2.H(), 3))
+TEST_NEON(mls_1, mls(v0.V8H(), v1.V8H(), v2.H(), 5))
+TEST_NEON(mls_2, mls(v0.V2S(), v1.V2S(), v2.S(), 0))
 TEST_NEON(mls_3, mls(v0.V4S(), v1.V4S(), v2.S(), 1))
 TEST_NEON(mls_4, mls(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(mls_5, mls(v0.V16B(), v1.V16B(), v2.V16B()))
@@ -1414,39 +1408,35 @@ TEST_NEON(mls_6, mls(v0.V4H(), v1.V4H(), v2.V4H()))
 TEST_NEON(mls_7, mls(v0.V8H(), v1.V8H(), v2.V8H()))
 TEST_NEON(mls_8, mls(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(mls_9, mls(v0.V4S(), v1.V4S(), v2.V4S()))
-TEST_NEON(movi_0, movi(v0.V2D(), 0x00ff000000ff00ff))
-TEST_NEON(movi_1, movi(d0, 0x0000ffff00ff00ff))
-TEST_NEON(movi_2, movi(v0.V4H(), 0x22, LSL, 0))
-TEST_NEON(movi_3, movi(v0.V8H(), 0x7b, LSL, 8))
-TEST_NEON(movi_4, movi(v0.V2S(), 0x11, LSL, 24))
-TEST_NEON(movi_5, movi(v0.V4S(), 0x11, LSL, 24))
-TEST_NEON(movi_6, movi(v0.V4H(), 0x73, LSL, 8))
-TEST_NEON(movi_7, movi(v0.V8H(), 0xcb, LSL, 0))
-TEST_NEON(movi_8, movi(v0.V2S(), 0x65, LSL, 16))
-TEST_NEON(movi_9, movi(v0.V4S(), 0x1b, LSL, 24))
-TEST_NEON(movi_10, movi(v0.V2S(), 0x4f, MSL, 16))
-TEST_NEON(movi_11, movi(v0.V4S(), 0x9a, MSL, 8))
-TEST_NEON(movi_12, movi(v0.V8B(), 0x1d))
-TEST_NEON(movi_13, movi(v0.V16B(), 0xc0))
-TEST_NEON(mov_0, mov(b0, v1.B(), 7))
-TEST_NEON(mov_1, mov(h0, v1.H(), 2))
-TEST_NEON(mov_2, mov(s0, v1.S(), 0))
-TEST_NEON(mov_3, mov(d0, v1.D(), 1))
-TEST_NEON(mov_4, mov(v0.B(), 5, v1.B(), 7))
-TEST_NEON(mov_5, mov(v0.H(), 3, v1.H(), 0))
+TEST_NEON(movi_0, movi(v0.V2D(), 0x0000ff000000ff00))
+TEST_NEON(movi_1, movi(d0, 0xffffffff00ffff00))
+TEST_NEON(movi_2, movi(v0.V4H(), 0xda, LSL, 8))
+TEST_NEON(movi_3, movi(v0.V8H(), 0x32, LSL, 0))
+TEST_NEON(movi_4, movi(v0.V2S(), 0xfe, LSL, 0))
+TEST_NEON(movi_5, movi(v0.V4S(), 0xf0, LSL, 8))
+TEST_NEON(movi_6, movi(v0.V2S(), 0x81, MSL, 8))
+TEST_NEON(movi_7, movi(v0.V4S(), 0x7, MSL, 8))
+TEST_NEON(movi_8, movi(v0.V8B(), 0x18))
+TEST_NEON(movi_9, movi(v0.V16B(), 0x94))
+TEST_NEON(mov_0, mov(b0, v1.B(), 5))
+TEST_NEON(mov_1, mov(h0, v1.H(), 1))
+TEST_NEON(mov_2, mov(s0, v1.S(), 3))
+TEST_NEON(mov_3, mov(d0, v1.D(), 0))
+TEST_NEON(mov_4, mov(v0.B(), 14, v1.B(), 11))
+TEST_NEON(mov_5, mov(v0.H(), 1, v1.H(), 7))
 TEST_NEON(mov_6, mov(v0.S(), 1, v1.S(), 1))
-TEST_NEON(mov_7, mov(v0.D(), 0, v1.D(), 0))
-TEST_NEON(mov_8, mov(v0.B(), 7, w1))
-TEST_NEON(mov_9, mov(v0.H(), 3, w1))
+TEST_NEON(mov_7, mov(v0.D(), 0, v1.D(), 1))
+TEST_NEON(mov_8, mov(v0.B(), 14, w1))
+TEST_NEON(mov_9, mov(v0.H(), 7, w1))
 TEST_NEON(mov_10, mov(v0.S(), 0, w1))
-TEST_NEON(mov_11, mov(v0.D(), 0, x1))
+TEST_NEON(mov_11, mov(v0.D(), 1, x1))
 TEST_NEON(mov_12, mov(v0.V8B(), v1.V8B()))
 TEST_NEON(mov_13, mov(v0.V16B(), v1.V16B()))
 TEST_NEON(mov_14, mov(w0, v1.S(), 3))
 TEST_NEON(mov_15, mov(x0, v1.D(), 1))
 TEST_NEON(mul_0, mul(v0.V4H(), v1.V4H(), v2.H(), 0))
-TEST_NEON(mul_1, mul(v0.V8H(), v1.V8H(), v2.H(), 1))
-TEST_NEON(mul_2, mul(v0.V2S(), v1.V2S(), v2.S(), 0))
+TEST_NEON(mul_1, mul(v0.V8H(), v1.V8H(), v2.H(), 2))
+TEST_NEON(mul_2, mul(v0.V2S(), v1.V2S(), v2.S(), 1))
 TEST_NEON(mul_3, mul(v0.V4S(), v1.V4S(), v2.S(), 1))
 TEST_NEON(mul_4, mul(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(mul_5, mul(v0.V16B(), v1.V16B(), v2.V16B()))
@@ -1454,16 +1444,12 @@ TEST_NEON(mul_6, mul(v0.V4H(), v1.V4H(), v2.V4H()))
 TEST_NEON(mul_7, mul(v0.V8H(), v1.V8H(), v2.V8H()))
 TEST_NEON(mul_8, mul(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(mul_9, mul(v0.V4S(), v1.V4S(), v2.V4S()))
-TEST_NEON(mvni_0, mvni(v0.V4H(), 0x9, LSL, 0))
-TEST_NEON(mvni_1, mvni(v0.V8H(), 0xef, LSL, 0))
-TEST_NEON(mvni_2, mvni(v0.V2S(), 0x19, LSL, 8))
-TEST_NEON(mvni_3, mvni(v0.V4S(), 0xd9, LSL, 24))
-TEST_NEON(mvni_4, mvni(v0.V4H(), 0x3c, LSL, 0))
-TEST_NEON(mvni_5, mvni(v0.V8H(), 0xad, LSL, 8))
-TEST_NEON(mvni_6, mvni(v0.V2S(), 0xe3, LSL, 24))
-TEST_NEON(mvni_7, mvni(v0.V4S(), 0x94, LSL, 8))
-TEST_NEON(mvni_8, mvni(v0.V2S(), 0xb, MSL, 16))
-TEST_NEON(mvni_9, mvni(v0.V4S(), 0xff, MSL, 8))
+TEST_NEON(mvni_0, mvni(v0.V4H(), 0xd9, LSL, 8))
+TEST_NEON(mvni_1, mvni(v0.V8H(), 0x86, LSL, 0))
+TEST_NEON(mvni_2, mvni(v0.V2S(), 0xde, LSL, 16))
+TEST_NEON(mvni_3, mvni(v0.V4S(), 0x96, LSL, 24))
+TEST_NEON(mvni_4, mvni(v0.V2S(), 0x1e, MSL, 16))
+TEST_NEON(mvni_5, mvni(v0.V4S(), 0x9b, MSL, 16))
 TEST_NEON(mvn_0, mvn(v0.V8B(), v1.V8B()))
 TEST_NEON(mvn_1, mvn(v0.V16B(), v1.V16B()))
 TEST_NEON(neg_0, neg(v0.V8B(), v1.V8B()))
@@ -1478,16 +1464,12 @@ TEST_NEON(not_0, not_(v0.V8B(), v1.V8B()))
 TEST_NEON(not_1, not_(v0.V16B(), v1.V16B()))
 TEST_NEON(orn_0, orn(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(orn_1, orn(v0.V16B(), v1.V16B(), v2.V16B()))
-TEST_NEON(orr_0, orr(v0.V4H(), 0xc0, 0))
-TEST_NEON(orr_1, orr(v0.V8H(), 0x85, 0))
-TEST_NEON(orr_2, orr(v0.V2S(), 0xe, 16))
-TEST_NEON(orr_3, orr(v0.V4S(), 0x89, 16))
-TEST_NEON(orr_4, orr(v0.V4H(), 0x76, 8))
-TEST_NEON(orr_5, orr(v0.V8H(), 0xfb, 0))
-TEST_NEON(orr_6, orr(v0.V2S(), 0xac, 8))
-TEST_NEON(orr_7, orr(v0.V4S(), 0xd3, 0))
-TEST_NEON(orr_8, orr(v0.V8B(), v1.V8B(), v2.V8B()))
-TEST_NEON(orr_9, orr(v0.V16B(), v1.V16B(), v2.V16B()))
+TEST_NEON(orr_0, orr(v0.V4H(), 0xb1, 0))
+TEST_NEON(orr_1, orr(v0.V8H(), 0xe3, 8))
+TEST_NEON(orr_2, orr(v0.V2S(), 0x26, 0))
+TEST_NEON(orr_3, orr(v0.V4S(), 0x67, 0))
+TEST_NEON(orr_4, orr(v0.V8B(), v1.V8B(), v2.V8B()))
+TEST_NEON(orr_5, orr(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(pmull_0, pmull(v0.V8H(), v1.V8B(), v2.V8B()))
 TEST_NEON(pmull2_0, pmull2(v0.V8H(), v1.V16B(), v2.V16B()))
 TEST_NEON(pmul_0, pmul(v0.V8B(), v1.V8B(), v2.V8B()))
@@ -1512,12 +1494,12 @@ TEST_NEON(rev64_2, rev64(v0.V4H(), v1.V4H()))
 TEST_NEON(rev64_3, rev64(v0.V8H(), v1.V8H()))
 TEST_NEON(rev64_4, rev64(v0.V2S(), v1.V2S()))
 TEST_NEON(rev64_5, rev64(v0.V4S(), v1.V4S()))
-TEST_NEON(rshrn_0, rshrn(v0.V8B(), v1.V8H(), 4))
-TEST_NEON(rshrn_1, rshrn(v0.V4H(), v1.V4S(), 14))
-TEST_NEON(rshrn_2, rshrn(v0.V2S(), v1.V2D(), 4))
+TEST_NEON(rshrn_0, rshrn(v0.V8B(), v1.V8H(), 6))
+TEST_NEON(rshrn_1, rshrn(v0.V4H(), v1.V4S(), 9))
+TEST_NEON(rshrn_2, rshrn(v0.V2S(), v1.V2D(), 30))
 TEST_NEON(rshrn2_0, rshrn2(v0.V16B(), v1.V8H(), 1))
-TEST_NEON(rshrn2_1, rshrn2(v0.V8H(), v1.V4S(), 5))
-TEST_NEON(rshrn2_2, rshrn2(v0.V4S(), v1.V2D(), 8))
+TEST_NEON(rshrn2_1, rshrn2(v0.V8H(), v1.V4S(), 6))
+TEST_NEON(rshrn2_2, rshrn2(v0.V4S(), v1.V2D(), 12))
 TEST_NEON(rsubhn_0, rsubhn(v0.V8B(), v1.V8H(), v2.V8H()))
 TEST_NEON(rsubhn_1, rsubhn(v0.V4H(), v1.V4S(), v2.V4S()))
 TEST_NEON(rsubhn_2, rsubhn(v0.V2S(), v1.V2D(), v2.V2D()))
@@ -1589,34 +1571,34 @@ TEST_NEON(shll_2, shll(v0.V2D(), v1.V2S(), 32))
 TEST_NEON(shll2_0, shll2(v0.V8H(), v1.V16B(), 8))
 TEST_NEON(shll2_1, shll2(v0.V4S(), v1.V8H(), 16))
 TEST_NEON(shll2_2, shll2(v0.V2D(), v1.V4S(), 32))
-TEST_NEON(shl_0, shl(v0.V8B(), v1.V8B(), 6))
-TEST_NEON(shl_1, shl(v0.V16B(), v1.V16B(), 2))
-TEST_NEON(shl_2, shl(v0.V4H(), v1.V4H(), 7))
-TEST_NEON(shl_3, shl(v0.V8H(), v1.V8H(), 2))
-TEST_NEON(shl_4, shl(v0.V2S(), v1.V2S(), 1))
-TEST_NEON(shl_5, shl(v0.V4S(), v1.V4S(), 14))
-TEST_NEON(shl_6, shl(v0.V2D(), v1.V2D(), 26))
-TEST_NEON(shl_7, shl(d0, d1, 24))
+TEST_NEON(shl_0, shl(v0.V8B(), v1.V8B(), 2))
+TEST_NEON(shl_1, shl(v0.V16B(), v1.V16B(), 5))
+TEST_NEON(shl_2, shl(v0.V4H(), v1.V4H(), 10))
+TEST_NEON(shl_3, shl(v0.V8H(), v1.V8H(), 14))
+TEST_NEON(shl_4, shl(v0.V2S(), v1.V2S(), 24))
+TEST_NEON(shl_5, shl(v0.V4S(), v1.V4S(), 2))
+TEST_NEON(shl_6, shl(v0.V2D(), v1.V2D(), 44))
+TEST_NEON(shl_7, shl(d0, d1, 7))
 TEST_NEON(shrn_0, shrn(v0.V8B(), v1.V8H(), 7))
 TEST_NEON(shrn_1, shrn(v0.V4H(), v1.V4S(), 14))
-TEST_NEON(shrn_2, shrn(v0.V2S(), v1.V2D(), 25))
-TEST_NEON(shrn2_0, shrn2(v0.V16B(), v1.V8H(), 5))
-TEST_NEON(shrn2_1, shrn2(v0.V8H(), v1.V4S(), 6))
-TEST_NEON(shrn2_2, shrn2(v0.V4S(), v1.V2D(), 27))
+TEST_NEON(shrn_2, shrn(v0.V2S(), v1.V2D(), 20))
+TEST_NEON(shrn2_0, shrn2(v0.V16B(), v1.V8H(), 2))
+TEST_NEON(shrn2_1, shrn2(v0.V8H(), v1.V4S(), 14))
+TEST_NEON(shrn2_2, shrn2(v0.V4S(), v1.V2D(), 18))
 TEST_NEON(shsub_0, shsub(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(shsub_1, shsub(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(shsub_2, shsub(v0.V4H(), v1.V4H(), v2.V4H()))
 TEST_NEON(shsub_3, shsub(v0.V8H(), v1.V8H(), v2.V8H()))
 TEST_NEON(shsub_4, shsub(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(shsub_5, shsub(v0.V4S(), v1.V4S(), v2.V4S()))
-TEST_NEON(sli_0, sli(v0.V8B(), v1.V8B(), 1))
-TEST_NEON(sli_1, sli(v0.V16B(), v1.V16B(), 4))
-TEST_NEON(sli_2, sli(v0.V4H(), v1.V4H(), 5))
-TEST_NEON(sli_3, sli(v0.V8H(), v1.V8H(), 15))
-TEST_NEON(sli_4, sli(v0.V2S(), v1.V2S(), 9))
-TEST_NEON(sli_5, sli(v0.V4S(), v1.V4S(), 6))
-TEST_NEON(sli_6, sli(v0.V2D(), v1.V2D(), 59))
-TEST_NEON(sli_7, sli(d0, d1, 55))
+TEST_NEON(sli_0, sli(v0.V8B(), v1.V8B(), 6))
+TEST_NEON(sli_1, sli(v0.V16B(), v1.V16B(), 2))
+TEST_NEON(sli_2, sli(v0.V4H(), v1.V4H(), 7))
+TEST_NEON(sli_3, sli(v0.V8H(), v1.V8H(), 7))
+TEST_NEON(sli_4, sli(v0.V2S(), v1.V2S(), 13))
+TEST_NEON(sli_5, sli(v0.V4S(), v1.V4S(), 16))
+TEST_NEON(sli_6, sli(v0.V2D(), v1.V2D(), 21))
+TEST_NEON(sli_7, sli(d0, d1, 34))
 TEST_NEON(smaxp_0, smaxp(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(smaxp_1, smaxp(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(smaxp_2, smaxp(v0.V4H(), v1.V4H(), v2.V4H()))
@@ -1651,35 +1633,35 @@ TEST_NEON(smin_2, smin(v0.V4H(), v1.V4H(), v2.V4H()))
 TEST_NEON(smin_3, smin(v0.V8H(), v1.V8H(), v2.V8H()))
 TEST_NEON(smin_4, smin(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(smin_5, smin(v0.V4S(), v1.V4S(), v2.V4S()))
-TEST_NEON(smlal_0, smlal(v0.V4S(), v1.V4H(), v2.H(), 0))
+TEST_NEON(smlal_0, smlal(v0.V4S(), v1.V4H(), v2.H(), 5))
 TEST_NEON(smlal_1, smlal(v0.V2D(), v1.V2S(), v2.S(), 0))
-TEST_NEON(smlal2_0, smlal2(v0.V4S(), v1.V8H(), v2.H(), 4))
-TEST_NEON(smlal2_1, smlal2(v0.V2D(), v1.V4S(), v2.S(), 3))
+TEST_NEON(smlal2_0, smlal2(v0.V4S(), v1.V8H(), v2.H(), 7))
+TEST_NEON(smlal2_1, smlal2(v0.V2D(), v1.V4S(), v2.S(), 1))
 TEST_NEON(smlal_2, smlal(v0.V8H(), v1.V8B(), v2.V8B()))
 TEST_NEON(smlal_3, smlal(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(smlal_4, smlal(v0.V2D(), v1.V2S(), v2.V2S()))
 TEST_NEON(smlal2_2, smlal2(v0.V8H(), v1.V16B(), v2.V16B()))
 TEST_NEON(smlal2_3, smlal2(v0.V4S(), v1.V8H(), v2.V8H()))
 TEST_NEON(smlal2_4, smlal2(v0.V2D(), v1.V4S(), v2.V4S()))
-TEST_NEON(smlsl_0, smlsl(v0.V4S(), v1.V4H(), v2.H(), 1))
+TEST_NEON(smlsl_0, smlsl(v0.V4S(), v1.V4H(), v2.H(), 3))
 TEST_NEON(smlsl_1, smlsl(v0.V2D(), v1.V2S(), v2.S(), 3))
-TEST_NEON(smlsl2_0, smlsl2(v0.V4S(), v1.V8H(), v2.H(), 0))
-TEST_NEON(smlsl2_1, smlsl2(v0.V2D(), v1.V4S(), v2.S(), 3))
+TEST_NEON(smlsl2_0, smlsl2(v0.V4S(), v1.V8H(), v2.H(), 1))
+TEST_NEON(smlsl2_1, smlsl2(v0.V2D(), v1.V4S(), v2.S(), 2))
 TEST_NEON(smlsl_2, smlsl(v0.V8H(), v1.V8B(), v2.V8B()))
 TEST_NEON(smlsl_3, smlsl(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(smlsl_4, smlsl(v0.V2D(), v1.V2S(), v2.V2S()))
 TEST_NEON(smlsl2_2, smlsl2(v0.V8H(), v1.V16B(), v2.V16B()))
 TEST_NEON(smlsl2_3, smlsl2(v0.V4S(), v1.V8H(), v2.V8H()))
 TEST_NEON(smlsl2_4, smlsl2(v0.V2D(), v1.V4S(), v2.V4S()))
-TEST_NEON(smov_0, smov(w0, v1.B(), 12))
+TEST_NEON(smov_0, smov(w0, v1.B(), 4))
 TEST_NEON(smov_1, smov(w0, v1.H(), 1))
-TEST_NEON(smov_2, smov(x0, v1.B(), 10))
+TEST_NEON(smov_2, smov(x0, v1.B(), 6))
 TEST_NEON(smov_3, smov(x0, v1.H(), 7))
-TEST_NEON(smov_4, smov(x0, v1.S(), 0))
-TEST_NEON(smull_0, smull(v0.V4S(), v1.V4H(), v2.H(), 0))
-TEST_NEON(smull_1, smull(v0.V2D(), v1.V2S(), v2.S(), 1))
-TEST_NEON(smull2_0, smull2(v0.V4S(), v1.V8H(), v2.H(), 0))
-TEST_NEON(smull2_1, smull2(v0.V2D(), v1.V4S(), v2.S(), 1))
+TEST_NEON(smov_4, smov(x0, v1.S(), 2))
+TEST_NEON(smull_0, smull(v0.V4S(), v1.V4H(), v2.H(), 6))
+TEST_NEON(smull_1, smull(v0.V2D(), v1.V2S(), v2.S(), 3))
+TEST_NEON(smull2_0, smull2(v0.V4S(), v1.V8H(), v2.H(), 3))
+TEST_NEON(smull2_1, smull2(v0.V2D(), v1.V4S(), v2.S(), 2))
 TEST_NEON(smull_2, smull(v0.V8H(), v1.V8B(), v2.V8B()))
 TEST_NEON(smull_3, smull(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(smull_4, smull(v0.V2D(), v1.V2S(), v2.V2S()))
@@ -1708,11 +1690,11 @@ TEST_NEON(sqadd_7, sqadd(b0, b1, b2))
 TEST_NEON(sqadd_8, sqadd(h0, h1, h2))
 TEST_NEON(sqadd_9, sqadd(s0, s1, s2))
 TEST_NEON(sqadd_10, sqadd(d0, d1, d2))
-TEST_NEON(sqdmlal_0, sqdmlal(v0.V4S(), v1.V4H(), v2.H(), 7))
-TEST_NEON(sqdmlal_1, sqdmlal(v0.V2D(), v1.V2S(), v2.S(), 1))
+TEST_NEON(sqdmlal_0, sqdmlal(v0.V4S(), v1.V4H(), v2.H(), 3))
+TEST_NEON(sqdmlal_1, sqdmlal(v0.V2D(), v1.V2S(), v2.S(), 2))
 TEST_NEON(sqdmlal2_0, sqdmlal2(v0.V4S(), v1.V8H(), v2.H(), 3))
 TEST_NEON(sqdmlal2_1, sqdmlal2(v0.V2D(), v1.V4S(), v2.S(), 0))
-TEST_NEON(sqdmlal_2, sqdmlal(s0, h1, v2.H(), 7))
+TEST_NEON(sqdmlal_2, sqdmlal(s0, h1, v2.H(), 1))
 TEST_NEON(sqdmlal_3, sqdmlal(d0, s1, v2.S(), 1))
 TEST_NEON(sqdmlal_4, sqdmlal(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(sqdmlal_5, sqdmlal(v0.V2D(), v1.V2S(), v2.V2S()))
@@ -1720,36 +1702,36 @@ TEST_NEON(sqdmlal2_2, sqdmlal2(v0.V4S(), v1.V8H(), v2.V8H()))
 TEST_NEON(sqdmlal2_3, sqdmlal2(v0.V2D(), v1.V4S(), v2.V4S()))
 TEST_NEON(sqdmlal_6, sqdmlal(s0, h1, h2))
 TEST_NEON(sqdmlal_7, sqdmlal(d0, s1, s2))
-TEST_NEON(sqdmlsl_0, sqdmlsl(v0.V4S(), v1.V4H(), v2.H(), 5))
-TEST_NEON(sqdmlsl_1, sqdmlsl(v0.V2D(), v1.V2S(), v2.S(), 1))
-TEST_NEON(sqdmlsl2_0, sqdmlsl2(v0.V4S(), v1.V8H(), v2.H(), 3))
-TEST_NEON(sqdmlsl2_1, sqdmlsl2(v0.V2D(), v1.V4S(), v2.S(), 2))
-TEST_NEON(sqdmlsl_2, sqdmlsl(s0, h1, v2.H(), 7))
-TEST_NEON(sqdmlsl_3, sqdmlsl(d0, s1, v2.S(), 1))
+TEST_NEON(sqdmlsl_0, sqdmlsl(v0.V4S(), v1.V4H(), v2.H(), 6))
+TEST_NEON(sqdmlsl_1, sqdmlsl(v0.V2D(), v1.V2S(), v2.S(), 0))
+TEST_NEON(sqdmlsl2_0, sqdmlsl2(v0.V4S(), v1.V8H(), v2.H(), 6))
+TEST_NEON(sqdmlsl2_1, sqdmlsl2(v0.V2D(), v1.V4S(), v2.S(), 3))
+TEST_NEON(sqdmlsl_2, sqdmlsl(s0, h1, v2.H(), 1))
+TEST_NEON(sqdmlsl_3, sqdmlsl(d0, s1, v2.S(), 2))
 TEST_NEON(sqdmlsl_4, sqdmlsl(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(sqdmlsl_5, sqdmlsl(v0.V2D(), v1.V2S(), v2.V2S()))
 TEST_NEON(sqdmlsl2_2, sqdmlsl2(v0.V4S(), v1.V8H(), v2.V8H()))
 TEST_NEON(sqdmlsl2_3, sqdmlsl2(v0.V2D(), v1.V4S(), v2.V4S()))
 TEST_NEON(sqdmlsl_6, sqdmlsl(s0, h1, h2))
 TEST_NEON(sqdmlsl_7, sqdmlsl(d0, s1, s2))
-TEST_NEON(sqdmulh_0, sqdmulh(v0.V4H(), v1.V4H(), v2.H(), 5))
+TEST_NEON(sqdmulh_0, sqdmulh(v0.V4H(), v1.V4H(), v2.H(), 2))
 TEST_NEON(sqdmulh_1, sqdmulh(v0.V8H(), v1.V8H(), v2.H(), 2))
 TEST_NEON(sqdmulh_2, sqdmulh(v0.V2S(), v1.V2S(), v2.S(), 1))
 TEST_NEON(sqdmulh_3, sqdmulh(v0.V4S(), v1.V4S(), v2.S(), 2))
-TEST_NEON(sqdmulh_4, sqdmulh(h0, h1, v2.H(), 6))
-TEST_NEON(sqdmulh_5, sqdmulh(s0, s1, v2.S(), 3))
+TEST_NEON(sqdmulh_4, sqdmulh(h0, h1, v2.H(), 2))
+TEST_NEON(sqdmulh_5, sqdmulh(s0, s1, v2.S(), 0))
 TEST_NEON(sqdmulh_6, sqdmulh(v0.V4H(), v1.V4H(), v2.V4H()))
 TEST_NEON(sqdmulh_7, sqdmulh(v0.V8H(), v1.V8H(), v2.V8H()))
 TEST_NEON(sqdmulh_8, sqdmulh(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(sqdmulh_9, sqdmulh(v0.V4S(), v1.V4S(), v2.V4S()))
 TEST_NEON(sqdmulh_10, sqdmulh(h0, h1, h2))
 TEST_NEON(sqdmulh_11, sqdmulh(s0, s1, s2))
-TEST_NEON(sqdmull_0, sqdmull(v0.V4S(), v1.V4H(), v2.H(), 2))
+TEST_NEON(sqdmull_0, sqdmull(v0.V4S(), v1.V4H(), v2.H(), 1))
 TEST_NEON(sqdmull_1, sqdmull(v0.V2D(), v1.V2S(), v2.S(), 3))
-TEST_NEON(sqdmull2_0, sqdmull2(v0.V4S(), v1.V8H(), v2.H(), 3))
+TEST_NEON(sqdmull2_0, sqdmull2(v0.V4S(), v1.V8H(), v2.H(), 0))
 TEST_NEON(sqdmull2_1, sqdmull2(v0.V2D(), v1.V4S(), v2.S(), 3))
 TEST_NEON(sqdmull_2, sqdmull(s0, h1, v2.H(), 2))
-TEST_NEON(sqdmull_3, sqdmull(d0, s1, v2.S(), 0))
+TEST_NEON(sqdmull_3, sqdmull(d0, s1, v2.S(), 1))
 TEST_NEON(sqdmull_4, sqdmull(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(sqdmull_5, sqdmull(v0.V2D(), v1.V2S(), v2.V2S()))
 TEST_NEON(sqdmull2_2, sqdmull2(v0.V4S(), v1.V8H(), v2.V8H()))
@@ -1767,11 +1749,11 @@ TEST_NEON(sqneg_7, sqneg(b0, b1))
 TEST_NEON(sqneg_8, sqneg(h0, h1))
 TEST_NEON(sqneg_9, sqneg(s0, s1))
 TEST_NEON(sqneg_10, sqneg(d0, d1))
-TEST_NEON(sqrdmulh_0, sqrdmulh(v0.V4H(), v1.V4H(), v2.H(), 4))
+TEST_NEON(sqrdmulh_0, sqrdmulh(v0.V4H(), v1.V4H(), v2.H(), 0))
 TEST_NEON(sqrdmulh_1, sqrdmulh(v0.V8H(), v1.V8H(), v2.H(), 2))
-TEST_NEON(sqrdmulh_2, sqrdmulh(v0.V2S(), v1.V2S(), v2.S(), 1))
-TEST_NEON(sqrdmulh_3, sqrdmulh(v0.V4S(), v1.V4S(), v2.S(), 0))
-TEST_NEON(sqrdmulh_4, sqrdmulh(h0, h1, v2.H(), 6))
+TEST_NEON(sqrdmulh_2, sqrdmulh(v0.V2S(), v1.V2S(), v2.S(), 3))
+TEST_NEON(sqrdmulh_3, sqrdmulh(v0.V4S(), v1.V4S(), v2.S(), 1))
+TEST_NEON(sqrdmulh_4, sqrdmulh(h0, h1, v2.H(), 2))
 TEST_NEON(sqrdmulh_5, sqrdmulh(s0, s1, v2.S(), 0))
 TEST_NEON(sqrdmulh_6, sqrdmulh(v0.V4H(), v1.V4H(), v2.V4H()))
 TEST_NEON(sqrdmulh_7, sqrdmulh(v0.V8H(), v1.V8H(), v2.V8H()))
@@ -1790,46 +1772,46 @@ TEST_NEON(sqrshl_7, sqrshl(b0, b1, b2))
 TEST_NEON(sqrshl_8, sqrshl(h0, h1, h2))
 TEST_NEON(sqrshl_9, sqrshl(s0, s1, s2))
 TEST_NEON(sqrshl_10, sqrshl(d0, d1, d2))
-TEST_NEON(sqrshrn_0, sqrshrn(v0.V8B(), v1.V8H(), 4))
-TEST_NEON(sqrshrn_1, sqrshrn(v0.V4H(), v1.V4S(), 4))
-TEST_NEON(sqrshrn_2, sqrshrn(v0.V2S(), v1.V2D(), 23))
-TEST_NEON(sqrshrn2_0, sqrshrn2(v0.V16B(), v1.V8H(), 2))
-TEST_NEON(sqrshrn2_1, sqrshrn2(v0.V8H(), v1.V4S(), 7))
-TEST_NEON(sqrshrn2_2, sqrshrn2(v0.V4S(), v1.V2D(), 5))
-TEST_NEON(sqrshrn_3, sqrshrn(b0, h1, 2))
+TEST_NEON(sqrshrn_0, sqrshrn(v0.V8B(), v1.V8H(), 1))
+TEST_NEON(sqrshrn_1, sqrshrn(v0.V4H(), v1.V4S(), 14))
+TEST_NEON(sqrshrn_2, sqrshrn(v0.V2S(), v1.V2D(), 29))
+TEST_NEON(sqrshrn2_0, sqrshrn2(v0.V16B(), v1.V8H(), 3))
+TEST_NEON(sqrshrn2_1, sqrshrn2(v0.V8H(), v1.V4S(), 11))
+TEST_NEON(sqrshrn2_2, sqrshrn2(v0.V4S(), v1.V2D(), 25))
+TEST_NEON(sqrshrn_3, sqrshrn(b0, h1, 5))
 TEST_NEON(sqrshrn_4, sqrshrn(h0, s1, 4))
-TEST_NEON(sqrshrn_5, sqrshrn(s0, d1, 13))
-TEST_NEON(sqrshrun_0, sqrshrun(v0.V8B(), v1.V8H(), 5))
-TEST_NEON(sqrshrun_1, sqrshrun(v0.V4H(), v1.V4S(), 1))
-TEST_NEON(sqrshrun_2, sqrshrun(v0.V2S(), v1.V2D(), 6))
-TEST_NEON(sqrshrun2_0, sqrshrun2(v0.V16B(), v1.V8H(), 4))
-TEST_NEON(sqrshrun2_1, sqrshrun2(v0.V8H(), v1.V4S(), 11))
-TEST_NEON(sqrshrun2_2, sqrshrun2(v0.V4S(), v1.V2D(), 19))
-TEST_NEON(sqrshrun_3, sqrshrun(b0, h1, 2))
-TEST_NEON(sqrshrun_4, sqrshrun(h0, s1, 14))
-TEST_NEON(sqrshrun_5, sqrshrun(s0, d1, 8))
-TEST_NEON(sqshlu_0, sqshlu(v0.V8B(), v1.V8B(), 5))
-TEST_NEON(sqshlu_1, sqshlu(v0.V16B(), v1.V16B(), 1))
-TEST_NEON(sqshlu_2, sqshlu(v0.V4H(), v1.V4H(), 11))
-TEST_NEON(sqshlu_3, sqshlu(v0.V8H(), v1.V8H(), 11))
-TEST_NEON(sqshlu_4, sqshlu(v0.V2S(), v1.V2S(), 12))
-TEST_NEON(sqshlu_5, sqshlu(v0.V4S(), v1.V4S(), 13))
-TEST_NEON(sqshlu_6, sqshlu(v0.V2D(), v1.V2D(), 49))
+TEST_NEON(sqrshrn_5, sqrshrn(s0, d1, 30))
+TEST_NEON(sqrshrun_0, sqrshrun(v0.V8B(), v1.V8H(), 3))
+TEST_NEON(sqrshrun_1, sqrshrun(v0.V4H(), v1.V4S(), 6))
+TEST_NEON(sqrshrun_2, sqrshrun(v0.V2S(), v1.V2D(), 13))
+TEST_NEON(sqrshrun2_0, sqrshrun2(v0.V16B(), v1.V8H(), 1))
+TEST_NEON(sqrshrun2_1, sqrshrun2(v0.V8H(), v1.V4S(), 7))
+TEST_NEON(sqrshrun2_2, sqrshrun2(v0.V4S(), v1.V2D(), 29))
+TEST_NEON(sqrshrun_3, sqrshrun(b0, h1, 7))
+TEST_NEON(sqrshrun_4, sqrshrun(h0, s1, 13))
+TEST_NEON(sqrshrun_5, sqrshrun(s0, d1, 29))
+TEST_NEON(sqshlu_0, sqshlu(v0.V8B(), v1.V8B(), 4))
+TEST_NEON(sqshlu_1, sqshlu(v0.V16B(), v1.V16B(), 7))
+TEST_NEON(sqshlu_2, sqshlu(v0.V4H(), v1.V4H(), 14))
+TEST_NEON(sqshlu_3, sqshlu(v0.V8H(), v1.V8H(), 15))
+TEST_NEON(sqshlu_4, sqshlu(v0.V2S(), v1.V2S(), 13))
+TEST_NEON(sqshlu_5, sqshlu(v0.V4S(), v1.V4S(), 6))
+TEST_NEON(sqshlu_6, sqshlu(v0.V2D(), v1.V2D(), 42))
 TEST_NEON(sqshlu_7, sqshlu(b0, b1, 3))
-TEST_NEON(sqshlu_8, sqshlu(h0, h1, 13))
-TEST_NEON(sqshlu_9, sqshlu(s0, s1, 8))
-TEST_NEON(sqshlu_10, sqshlu(d0, d1, 25))
-TEST_NEON(sqshl_0, sqshl(v0.V8B(), v1.V8B(), 5))
-TEST_NEON(sqshl_1, sqshl(v0.V16B(), v1.V16B(), 1))
-TEST_NEON(sqshl_2, sqshl(v0.V4H(), v1.V4H(), 12))
-TEST_NEON(sqshl_3, sqshl(v0.V8H(), v1.V8H(), 13))
-TEST_NEON(sqshl_4, sqshl(v0.V2S(), v1.V2S(), 5))
-TEST_NEON(sqshl_5, sqshl(v0.V4S(), v1.V4S(), 10))
-TEST_NEON(sqshl_6, sqshl(v0.V2D(), v1.V2D(), 62))
-TEST_NEON(sqshl_7, sqshl(b0, b1, 7))
+TEST_NEON(sqshlu_8, sqshlu(h0, h1, 15))
+TEST_NEON(sqshlu_9, sqshlu(s0, s1, 21))
+TEST_NEON(sqshlu_10, sqshlu(d0, d1, 15))
+TEST_NEON(sqshl_0, sqshl(v0.V8B(), v1.V8B(), 6))
+TEST_NEON(sqshl_1, sqshl(v0.V16B(), v1.V16B(), 6))
+TEST_NEON(sqshl_2, sqshl(v0.V4H(), v1.V4H(), 8))
+TEST_NEON(sqshl_3, sqshl(v0.V8H(), v1.V8H(), 9))
+TEST_NEON(sqshl_4, sqshl(v0.V2S(), v1.V2S(), 28))
+TEST_NEON(sqshl_5, sqshl(v0.V4S(), v1.V4S(), 27))
+TEST_NEON(sqshl_6, sqshl(v0.V2D(), v1.V2D(), 50))
+TEST_NEON(sqshl_7, sqshl(b0, b1, 4))
 TEST_NEON(sqshl_8, sqshl(h0, h1, 13))
-TEST_NEON(sqshl_9, sqshl(s0, s1, 3))
-TEST_NEON(sqshl_10, sqshl(d0, d1, 63))
+TEST_NEON(sqshl_9, sqshl(s0, s1, 15))
+TEST_NEON(sqshl_10, sqshl(d0, d1, 40))
 TEST_NEON(sqshl_11, sqshl(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(sqshl_12, sqshl(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(sqshl_13, sqshl(v0.V4H(), v1.V4H(), v2.V4H()))
@@ -1841,24 +1823,24 @@ TEST_NEON(sqshl_18, sqshl(b0, b1, b2))
 TEST_NEON(sqshl_19, sqshl(h0, h1, h2))
 TEST_NEON(sqshl_20, sqshl(s0, s1, s2))
 TEST_NEON(sqshl_21, sqshl(d0, d1, d2))
-TEST_NEON(sqshrn_0, sqshrn(v0.V8B(), v1.V8H(), 6))
-TEST_NEON(sqshrn_1, sqshrn(v0.V4H(), v1.V4S(), 9))
-TEST_NEON(sqshrn_2, sqshrn(v0.V2S(), v1.V2D(), 26))
-TEST_NEON(sqshrn2_0, sqshrn2(v0.V16B(), v1.V8H(), 7))
-TEST_NEON(sqshrn2_1, sqshrn2(v0.V8H(), v1.V4S(), 9))
-TEST_NEON(sqshrn2_2, sqshrn2(v0.V4S(), v1.V2D(), 21))
-TEST_NEON(sqshrn_3, sqshrn(b0, h1, 3))
-TEST_NEON(sqshrn_4, sqshrn(h0, s1, 6))
-TEST_NEON(sqshrn_5, sqshrn(s0, d1, 13))
-TEST_NEON(sqshrun_0, sqshrun(v0.V8B(), v1.V8H(), 7))
-TEST_NEON(sqshrun_1, sqshrun(v0.V4H(), v1.V4S(), 14))
-TEST_NEON(sqshrun_2, sqshrun(v0.V2S(), v1.V2D(), 23))
-TEST_NEON(sqshrun2_0, sqshrun2(v0.V16B(), v1.V8H(), 5))
-TEST_NEON(sqshrun2_1, sqshrun2(v0.V8H(), v1.V4S(), 11))
-TEST_NEON(sqshrun2_2, sqshrun2(v0.V4S(), v1.V2D(), 25))
-TEST_NEON(sqshrun_3, sqshrun(b0, h1, 7))
-TEST_NEON(sqshrun_4, sqshrun(h0, s1, 7))
-TEST_NEON(sqshrun_5, sqshrun(s0, d1, 14))
+TEST_NEON(sqshrn_0, sqshrn(v0.V8B(), v1.V8H(), 5))
+TEST_NEON(sqshrn_1, sqshrn(v0.V4H(), v1.V4S(), 5))
+TEST_NEON(sqshrn_2, sqshrn(v0.V2S(), v1.V2D(), 2))
+TEST_NEON(sqshrn2_0, sqshrn2(v0.V16B(), v1.V8H(), 6))
+TEST_NEON(sqshrn2_1, sqshrn2(v0.V8H(), v1.V4S(), 10))
+TEST_NEON(sqshrn2_2, sqshrn2(v0.V4S(), v1.V2D(), 2))
+TEST_NEON(sqshrn_3, sqshrn(b0, h1, 2))
+TEST_NEON(sqshrn_4, sqshrn(h0, s1, 8))
+TEST_NEON(sqshrn_5, sqshrn(s0, d1, 27))
+TEST_NEON(sqshrun_0, sqshrun(v0.V8B(), v1.V8H(), 4))
+TEST_NEON(sqshrun_1, sqshrun(v0.V4H(), v1.V4S(), 11))
+TEST_NEON(sqshrun_2, sqshrun(v0.V2S(), v1.V2D(), 20))
+TEST_NEON(sqshrun2_0, sqshrun2(v0.V16B(), v1.V8H(), 6))
+TEST_NEON(sqshrun2_1, sqshrun2(v0.V8H(), v1.V4S(), 5))
+TEST_NEON(sqshrun2_2, sqshrun2(v0.V4S(), v1.V2D(), 18))
+TEST_NEON(sqshrun_3, sqshrun(b0, h1, 2))
+TEST_NEON(sqshrun_4, sqshrun(h0, s1, 10))
+TEST_NEON(sqshrun_5, sqshrun(s0, d1, 16))
 TEST_NEON(sqsub_0, sqsub(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(sqsub_1, sqsub(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(sqsub_2, sqsub(v0.V4H(), v1.V4H(), v2.V4H()))
@@ -1894,14 +1876,14 @@ TEST_NEON(srhadd_2, srhadd(v0.V4H(), v1.V4H(), v2.V4H()))
 TEST_NEON(srhadd_3, srhadd(v0.V8H(), v1.V8H(), v2.V8H()))
 TEST_NEON(srhadd_4, srhadd(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(srhadd_5, srhadd(v0.V4S(), v1.V4S(), v2.V4S()))
-TEST_NEON(sri_0, sri(v0.V8B(), v1.V8B(), 6))
-TEST_NEON(sri_1, sri(v0.V16B(), v1.V16B(), 4))
-TEST_NEON(sri_2, sri(v0.V4H(), v1.V4H(), 4))
-TEST_NEON(sri_3, sri(v0.V8H(), v1.V8H(), 12))
-TEST_NEON(sri_4, sri(v0.V2S(), v1.V2S(), 16))
-TEST_NEON(sri_5, sri(v0.V4S(), v1.V4S(), 11))
-TEST_NEON(sri_6, sri(v0.V2D(), v1.V2D(), 11))
-TEST_NEON(sri_7, sri(d0, d1, 10))
+TEST_NEON(sri_0, sri(v0.V8B(), v1.V8B(), 7))
+TEST_NEON(sri_1, sri(v0.V16B(), v1.V16B(), 3))
+TEST_NEON(sri_2, sri(v0.V4H(), v1.V4H(), 10))
+TEST_NEON(sri_3, sri(v0.V8H(), v1.V8H(), 7))
+TEST_NEON(sri_4, sri(v0.V2S(), v1.V2S(), 12))
+TEST_NEON(sri_5, sri(v0.V4S(), v1.V4S(), 15))
+TEST_NEON(sri_6, sri(v0.V2D(), v1.V2D(), 51))
+TEST_NEON(sri_7, sri(d0, d1, 47))
 TEST_NEON(srshl_0, srshl(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(srshl_1, srshl(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(srshl_2, srshl(v0.V4H(), v1.V4H(), v2.V4H()))
@@ -1910,28 +1892,28 @@ TEST_NEON(srshl_4, srshl(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(srshl_5, srshl(v0.V4S(), v1.V4S(), v2.V4S()))
 TEST_NEON(srshl_6, srshl(v0.V2D(), v1.V2D(), v2.V2D()))
 TEST_NEON(srshl_7, srshl(d0, d1, d2))
-TEST_NEON(srshr_0, srshr(v0.V8B(), v1.V8B(), 1))
-TEST_NEON(srshr_1, srshr(v0.V16B(), v1.V16B(), 1))
-TEST_NEON(srshr_2, srshr(v0.V4H(), v1.V4H(), 13))
-TEST_NEON(srshr_3, srshr(v0.V8H(), v1.V8H(), 15))
-TEST_NEON(srshr_4, srshr(v0.V2S(), v1.V2S(), 22))
-TEST_NEON(srshr_5, srshr(v0.V4S(), v1.V4S(), 12))
-TEST_NEON(srshr_6, srshr(v0.V2D(), v1.V2D(), 1))
-TEST_NEON(srshr_7, srshr(d0, d1, 2))
-TEST_NEON(srsra_0, srsra(v0.V8B(), v1.V8B(), 1))
+TEST_NEON(srshr_0, srshr(v0.V8B(), v1.V8B(), 2))
+TEST_NEON(srshr_1, srshr(v0.V16B(), v1.V16B(), 3))
+TEST_NEON(srshr_2, srshr(v0.V4H(), v1.V4H(), 2))
+TEST_NEON(srshr_3, srshr(v0.V8H(), v1.V8H(), 7))
+TEST_NEON(srshr_4, srshr(v0.V2S(), v1.V2S(), 25))
+TEST_NEON(srshr_5, srshr(v0.V4S(), v1.V4S(), 27))
+TEST_NEON(srshr_6, srshr(v0.V2D(), v1.V2D(), 43))
+TEST_NEON(srshr_7, srshr(d0, d1, 28))
+TEST_NEON(srsra_0, srsra(v0.V8B(), v1.V8B(), 4))
 TEST_NEON(srsra_1, srsra(v0.V16B(), v1.V16B(), 2))
-TEST_NEON(srsra_2, srsra(v0.V4H(), v1.V4H(), 1))
-TEST_NEON(srsra_3, srsra(v0.V8H(), v1.V8H(), 13))
-TEST_NEON(srsra_4, srsra(v0.V2S(), v1.V2S(), 9))
-TEST_NEON(srsra_5, srsra(v0.V4S(), v1.V4S(), 30))
-TEST_NEON(srsra_6, srsra(v0.V2D(), v1.V2D(), 7))
-TEST_NEON(srsra_7, srsra(d0, d1, 27))
-TEST_NEON(sshll_0, sshll(v0.V8H(), v1.V8B(), 3))
-TEST_NEON(sshll_1, sshll(v0.V4S(), v1.V4H(), 5))
-TEST_NEON(sshll_2, sshll(v0.V2D(), v1.V2S(), 7))
-TEST_NEON(sshll2_0, sshll2(v0.V8H(), v1.V16B(), 1))
-TEST_NEON(sshll2_1, sshll2(v0.V4S(), v1.V8H(), 1))
-TEST_NEON(sshll2_2, sshll2(v0.V2D(), v1.V4S(), 9))
+TEST_NEON(srsra_2, srsra(v0.V4H(), v1.V4H(), 13))
+TEST_NEON(srsra_3, srsra(v0.V8H(), v1.V8H(), 6))
+TEST_NEON(srsra_4, srsra(v0.V2S(), v1.V2S(), 4))
+TEST_NEON(srsra_5, srsra(v0.V4S(), v1.V4S(), 1))
+TEST_NEON(srsra_6, srsra(v0.V2D(), v1.V2D(), 17))
+TEST_NEON(srsra_7, srsra(d0, d1, 16))
+TEST_NEON(sshll_0, sshll(v0.V8H(), v1.V8B(), 2))
+TEST_NEON(sshll_1, sshll(v0.V4S(), v1.V4H(), 4))
+TEST_NEON(sshll_2, sshll(v0.V2D(), v1.V2S(), 28))
+TEST_NEON(sshll2_0, sshll2(v0.V8H(), v1.V16B(), 6))
+TEST_NEON(sshll2_1, sshll2(v0.V4S(), v1.V8H(), 2))
+TEST_NEON(sshll2_2, sshll2(v0.V2D(), v1.V4S(), 22))
 TEST_NEON(sshl_0, sshl(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(sshl_1, sshl(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(sshl_2, sshl(v0.V4H(), v1.V4H(), v2.V4H()))
@@ -1940,22 +1922,22 @@ TEST_NEON(sshl_4, sshl(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(sshl_5, sshl(v0.V4S(), v1.V4S(), v2.V4S()))
 TEST_NEON(sshl_6, sshl(v0.V2D(), v1.V2D(), v2.V2D()))
 TEST_NEON(sshl_7, sshl(d0, d1, d2))
-TEST_NEON(sshr_0, sshr(v0.V8B(), v1.V8B(), 3))
-TEST_NEON(sshr_1, sshr(v0.V16B(), v1.V16B(), 6))
-TEST_NEON(sshr_2, sshr(v0.V4H(), v1.V4H(), 14))
-TEST_NEON(sshr_3, sshr(v0.V8H(), v1.V8H(), 11))
-TEST_NEON(sshr_4, sshr(v0.V2S(), v1.V2S(), 18))
-TEST_NEON(sshr_5, sshr(v0.V4S(), v1.V4S(), 24))
-TEST_NEON(sshr_6, sshr(v0.V2D(), v1.V2D(), 57))
-TEST_NEON(sshr_7, sshr(d0, d1, 14))
-TEST_NEON(ssra_0, ssra(v0.V8B(), v1.V8B(), 6))
+TEST_NEON(sshr_0, sshr(v0.V8B(), v1.V8B(), 7))
+TEST_NEON(sshr_1, sshr(v0.V16B(), v1.V16B(), 1))
+TEST_NEON(sshr_2, sshr(v0.V4H(), v1.V4H(), 9))
+TEST_NEON(sshr_3, sshr(v0.V8H(), v1.V8H(), 13))
+TEST_NEON(sshr_4, sshr(v0.V2S(), v1.V2S(), 19))
+TEST_NEON(sshr_5, sshr(v0.V4S(), v1.V4S(), 26))
+TEST_NEON(sshr_6, sshr(v0.V2D(), v1.V2D(), 63))
+TEST_NEON(sshr_7, sshr(d0, d1, 39))
+TEST_NEON(ssra_0, ssra(v0.V8B(), v1.V8B(), 5))
 TEST_NEON(ssra_1, ssra(v0.V16B(), v1.V16B(), 7))
-TEST_NEON(ssra_2, ssra(v0.V4H(), v1.V4H(), 3))
-TEST_NEON(ssra_3, ssra(v0.V8H(), v1.V8H(), 7))
-TEST_NEON(ssra_4, ssra(v0.V2S(), v1.V2S(), 20))
-TEST_NEON(ssra_5, ssra(v0.V4S(), v1.V4S(), 13))
-TEST_NEON(ssra_6, ssra(v0.V2D(), v1.V2D(), 39))
-TEST_NEON(ssra_7, ssra(d0, d1, 17))
+TEST_NEON(ssra_2, ssra(v0.V4H(), v1.V4H(), 14))
+TEST_NEON(ssra_3, ssra(v0.V8H(), v1.V8H(), 6))
+TEST_NEON(ssra_4, ssra(v0.V2S(), v1.V2S(), 12))
+TEST_NEON(ssra_5, ssra(v0.V4S(), v1.V4S(), 4))
+TEST_NEON(ssra_6, ssra(v0.V2D(), v1.V2D(), 16))
+TEST_NEON(ssra_7, ssra(d0, d1, 53))
 TEST_NEON(ssubl_0, ssubl(v0.V8H(), v1.V8B(), v2.V8B()))
 TEST_NEON(ssubl_1, ssubl(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(ssubl_2, ssubl(v0.V2D(), v1.V2S(), v2.V2S()))
@@ -2119,18 +2101,18 @@ TEST_NEON(
 TEST_NEON(
     st1_95,
     st1(v0.V2D(), v1.V2D(), v2.V2D(), v3.V2D(), MemOperand(x4, x5, PostIndex)))
-TEST_NEON(st1_96, st1(v0.B(), 10, MemOperand(x1)))
-TEST_NEON(st1_97, st1(v0.D(), 1, MemOperand(x1)))
-TEST_NEON(st1_98, st1(v0.H(), 4, MemOperand(x1)))
-TEST_NEON(st1_99, st1(v0.S(), 3, MemOperand(x1)))
-TEST_NEON(st1_100, st1(v0.B(), 7, MemOperand(x1, 1, PostIndex)))
-TEST_NEON(st1_101, st1(v0.B(), 0, MemOperand(x1, x2, PostIndex)))
+TEST_NEON(st1_96, st1(v0.B(), 13, MemOperand(x1)))
+TEST_NEON(st1_97, st1(v0.D(), 0, MemOperand(x1)))
+TEST_NEON(st1_98, st1(v0.H(), 2, MemOperand(x1)))
+TEST_NEON(st1_99, st1(v0.S(), 2, MemOperand(x1)))
+TEST_NEON(st1_100, st1(v0.B(), 0, MemOperand(x1, 1, PostIndex)))
+TEST_NEON(st1_101, st1(v0.B(), 7, MemOperand(x1, x2, PostIndex)))
 TEST_NEON(st1_102, st1(v0.D(), 1, MemOperand(x1, 8, PostIndex)))
-TEST_NEON(st1_103, st1(v0.D(), 0, MemOperand(x1, x2, PostIndex)))
-TEST_NEON(st1_104, st1(v0.H(), 0, MemOperand(x1, 2, PostIndex)))
-TEST_NEON(st1_105, st1(v0.H(), 3, MemOperand(x1, x2, PostIndex)))
-TEST_NEON(st1_106, st1(v0.S(), 2, MemOperand(x1, 4, PostIndex)))
-TEST_NEON(st1_107, st1(v0.S(), 1, MemOperand(x1, x2, PostIndex)))
+TEST_NEON(st1_103, st1(v0.D(), 1, MemOperand(x1, x2, PostIndex)))
+TEST_NEON(st1_104, st1(v0.H(), 6, MemOperand(x1, 2, PostIndex)))
+TEST_NEON(st1_105, st1(v0.H(), 7, MemOperand(x1, x2, PostIndex)))
+TEST_NEON(st1_106, st1(v0.S(), 0, MemOperand(x1, 4, PostIndex)))
+TEST_NEON(st1_107, st1(v0.S(), 2, MemOperand(x1, x2, PostIndex)))
 TEST_NEON(st2_0, st2(v0.V8B(), v1.V8B(), MemOperand(x2)))
 TEST_NEON(st2_1, st2(v0.V16B(), v1.V16B(), MemOperand(x2)))
 TEST_NEON(st2_2, st2(v0.V4H(), v1.V4H(), MemOperand(x2)))
@@ -2152,18 +2134,18 @@ TEST_NEON(st2_17, st2(v0.V8H(), v1.V8H(), MemOperand(x2, x3, PostIndex)))
 TEST_NEON(st2_18, st2(v0.V2S(), v1.V2S(), MemOperand(x2, x3, PostIndex)))
 TEST_NEON(st2_19, st2(v0.V4S(), v1.V4S(), MemOperand(x2, x3, PostIndex)))
 TEST_NEON(st2_20, st2(v0.V2D(), v1.V2D(), MemOperand(x2, x3, PostIndex)))
-TEST_NEON(st2_21, st2(v0.B(), v1.B(), 7, MemOperand(x2)))
-TEST_NEON(st2_22, st2(v0.D(), v1.D(), 0, MemOperand(x2)))
-TEST_NEON(st2_23, st2(v0.H(), v1.H(), 2, MemOperand(x2)))
-TEST_NEON(st2_24, st2(v0.S(), v1.S(), 3, MemOperand(x2)))
-TEST_NEON(st2_25, st2(v0.B(), v1.B(), 7, MemOperand(x2, 2, PostIndex)))
-TEST_NEON(st2_26, st2(v0.B(), v1.B(), 10, MemOperand(x2, x3, PostIndex)))
-TEST_NEON(st2_27, st2(v0.D(), v1.D(), 0, MemOperand(x2, 16, PostIndex)))
-TEST_NEON(st2_28, st2(v0.D(), v1.D(), 0, MemOperand(x2, x3, PostIndex)))
-TEST_NEON(st2_29, st2(v0.H(), v1.H(), 0, MemOperand(x2, 4, PostIndex)))
+TEST_NEON(st2_21, st2(v0.B(), v1.B(), 0, MemOperand(x2)))
+TEST_NEON(st2_22, st2(v0.D(), v1.D(), 1, MemOperand(x2)))
+TEST_NEON(st2_23, st2(v0.H(), v1.H(), 5, MemOperand(x2)))
+TEST_NEON(st2_24, st2(v0.S(), v1.S(), 1, MemOperand(x2)))
+TEST_NEON(st2_25, st2(v0.B(), v1.B(), 13, MemOperand(x2, 2, PostIndex)))
+TEST_NEON(st2_26, st2(v0.B(), v1.B(), 14, MemOperand(x2, x3, PostIndex)))
+TEST_NEON(st2_27, st2(v0.D(), v1.D(), 1, MemOperand(x2, 16, PostIndex)))
+TEST_NEON(st2_28, st2(v0.D(), v1.D(), 1, MemOperand(x2, x3, PostIndex)))
+TEST_NEON(st2_29, st2(v0.H(), v1.H(), 2, MemOperand(x2, 4, PostIndex)))
 TEST_NEON(st2_30, st2(v0.H(), v1.H(), 4, MemOperand(x2, x3, PostIndex)))
-TEST_NEON(st2_31, st2(v0.S(), v1.S(), 1, MemOperand(x2, 8, PostIndex)))
-TEST_NEON(st2_32, st2(v0.S(), v1.S(), 2, MemOperand(x2, x3, PostIndex)))
+TEST_NEON(st2_31, st2(v0.S(), v1.S(), 0, MemOperand(x2, 8, PostIndex)))
+TEST_NEON(st2_32, st2(v0.S(), v1.S(), 0, MemOperand(x2, x3, PostIndex)))
 TEST_NEON(st3_0, st3(v0.V8B(), v1.V8B(), v2.V8B(), MemOperand(x3)))
 TEST_NEON(st3_1, st3(v0.V16B(), v1.V16B(), v2.V16B(), MemOperand(x3)))
 TEST_NEON(st3_2, st3(v0.V4H(), v1.V4H(), v2.V4H(), MemOperand(x3)))
@@ -2199,18 +2181,19 @@ TEST_NEON(st3_19,
           st3(v0.V4S(), v1.V4S(), v2.V4S(), MemOperand(x3, x4, PostIndex)))
 TEST_NEON(st3_20,
           st3(v0.V2D(), v1.V2D(), v2.V2D(), MemOperand(x3, x4, PostIndex)))
-TEST_NEON(st3_21, st3(v0.B(), v1.B(), v2.B(), 11, MemOperand(x3)))
-TEST_NEON(st3_22, st3(v0.D(), v1.D(), v2.D(), 0, MemOperand(x3)))
-TEST_NEON(st3_23, st3(v0.H(), v1.H(), v2.H(), 4, MemOperand(x3)))
-TEST_NEON(st3_24, st3(v0.S(), v1.S(), v2.S(), 3, MemOperand(x3)))
-TEST_NEON(st3_25, st3(v0.B(), v1.B(), v2.B(), 0, MemOperand(x3, 3, PostIndex)))
-TEST_NEON(st3_26, st3(v0.B(), v1.B(), v2.B(), 8, MemOperand(x3, x4, PostIndex)))
-TEST_NEON(st3_27, st3(v0.D(), v1.D(), v2.D(), 1, MemOperand(x3, 24, PostIndex)))
-TEST_NEON(st3_28, st3(v0.D(), v1.D(), v2.D(), 1, MemOperand(x3, x4, PostIndex)))
-TEST_NEON(st3_29, st3(v0.H(), v1.H(), v2.H(), 1, MemOperand(x3, 6, PostIndex)))
-TEST_NEON(st3_30, st3(v0.H(), v1.H(), v2.H(), 7, MemOperand(x3, x4, PostIndex)))
-TEST_NEON(st3_31, st3(v0.S(), v1.S(), v2.S(), 0, MemOperand(x3, 12, PostIndex)))
-TEST_NEON(st3_32, st3(v0.S(), v1.S(), v2.S(), 1, MemOperand(x3, x4, PostIndex)))
+TEST_NEON(st3_21, st3(v0.B(), v1.B(), v2.B(), 1, MemOperand(x3)))
+TEST_NEON(st3_22, st3(v0.D(), v1.D(), v2.D(), 1, MemOperand(x3)))
+TEST_NEON(st3_23, st3(v0.H(), v1.H(), v2.H(), 7, MemOperand(x3)))
+TEST_NEON(st3_24, st3(v0.S(), v1.S(), v2.S(), 2, MemOperand(x3)))
+TEST_NEON(st3_25, st3(v0.B(), v1.B(), v2.B(), 6, MemOperand(x3, 3, PostIndex)))
+TEST_NEON(st3_26,
+          st3(v0.B(), v1.B(), v2.B(), 12, MemOperand(x3, x4, PostIndex)))
+TEST_NEON(st3_27, st3(v0.D(), v1.D(), v2.D(), 0, MemOperand(x3, 24, PostIndex)))
+TEST_NEON(st3_28, st3(v0.D(), v1.D(), v2.D(), 0, MemOperand(x3, x4, PostIndex)))
+TEST_NEON(st3_29, st3(v0.H(), v1.H(), v2.H(), 0, MemOperand(x3, 6, PostIndex)))
+TEST_NEON(st3_30, st3(v0.H(), v1.H(), v2.H(), 4, MemOperand(x3, x4, PostIndex)))
+TEST_NEON(st3_31, st3(v0.S(), v1.S(), v2.S(), 3, MemOperand(x3, 12, PostIndex)))
+TEST_NEON(st3_32, st3(v0.S(), v1.S(), v2.S(), 2, MemOperand(x3, x4, PostIndex)))
 TEST_NEON(st4_0, st4(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(), MemOperand(x4)))
 TEST_NEON(st4_1,
           st4(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), MemOperand(x4)))
@@ -2267,69 +2250,68 @@ TEST_NEON(
 TEST_NEON(
     st4_20,
     st4(v0.V2D(), v1.V2D(), v2.V2D(), v3.V2D(), MemOperand(x4, x5, PostIndex)))
-TEST_NEON(st4_21, st4(v0.B(), v1.B(), v2.B(), v3.B(), 6, MemOperand(x4)))
+TEST_NEON(st4_21, st4(v0.B(), v1.B(), v2.B(), v3.B(), 1, MemOperand(x4)))
 TEST_NEON(st4_22, st4(v0.D(), v1.D(), v2.D(), v3.D(), 0, MemOperand(x4)))
-TEST_NEON(st4_23, st4(v0.H(), v1.H(), v2.H(), v3.H(), 4, MemOperand(x4)))
-TEST_NEON(st4_24, st4(v0.S(), v1.S(), v2.S(), v3.S(), 1, MemOperand(x4)))
+TEST_NEON(st4_23, st4(v0.H(), v1.H(), v2.H(), v3.H(), 6, MemOperand(x4)))
+TEST_NEON(st4_24, st4(v0.S(), v1.S(), v2.S(), v3.S(), 0, MemOperand(x4)))
 TEST_NEON(st4_25,
           st4(v0.B(), v1.B(), v2.B(), v3.B(), 4, MemOperand(x4, 4, PostIndex)))
 TEST_NEON(st4_26,
-          st4(v0.B(), v1.B(), v2.B(), v3.B(), 0, MemOperand(x4, x5, PostIndex)))
+          st4(v0.B(), v1.B(), v2.B(), v3.B(), 4, MemOperand(x4, x5, PostIndex)))
 TEST_NEON(st4_27,
-          st4(v0.D(), v1.D(), v2.D(), v3.D(), 0, MemOperand(x4, 32, PostIndex)))
+          st4(v0.D(), v1.D(), v2.D(), v3.D(), 1, MemOperand(x4, 32, PostIndex)))
 TEST_NEON(st4_28,
-          st4(v0.D(), v1.D(), v2.D(), v3.D(), 1, MemOperand(x4, x5, PostIndex)))
+          st4(v0.D(), v1.D(), v2.D(), v3.D(), 0, MemOperand(x4, x5, PostIndex)))
 TEST_NEON(st4_29,
-          st4(v0.H(), v1.H(), v2.H(), v3.H(), 4, MemOperand(x4, 8, PostIndex)))
+          st4(v0.H(), v1.H(), v2.H(), v3.H(), 0, MemOperand(x4, 8, PostIndex)))
 TEST_NEON(st4_30,
-          st4(v0.H(), v1.H(), v2.H(), v3.H(), 5, MemOperand(x4, x5, PostIndex)))
+          st4(v0.H(), v1.H(), v2.H(), v3.H(), 7, MemOperand(x4, x5, PostIndex)))
 TEST_NEON(st4_31,
-          st4(v0.S(), v1.S(), v2.S(), v3.S(), 3, MemOperand(x4, 16, PostIndex)))
+          st4(v0.S(), v1.S(), v2.S(), v3.S(), 0, MemOperand(x4, 16, PostIndex)))
 TEST_NEON(st4_32,
-          st4(v0.S(), v1.S(), v2.S(), v3.S(), 1, MemOperand(x4, x5, PostIndex)))
-TEST_NEON(stnp_0, stnp(d0, d1, MemOperand(x2, -200)))
-TEST_NEON(stnp_1, stnp(q0, q1, MemOperand(x2, 672)))
-TEST_NEON(stnp_2, stnp(s0, s1, MemOperand(x2, -216)))
-TEST_NEON(stp_0, stp(d0, d1, MemOperand(x2, 504)))
-TEST_NEON(stp_1, stp(d0, d1, MemOperand(x2, 32, PostIndex)))
-TEST_NEON(stp_2, stp(d0, d1, MemOperand(x2, 480, PreIndex)))
-TEST_NEON(stp_3, stp(q0, q1, MemOperand(x2, -752)))
-TEST_NEON(stp_4, stp(q0, q1, MemOperand(x2, 688, PostIndex)))
-TEST_NEON(stp_5, stp(q0, q1, MemOperand(x2, 288, PreIndex)))
-TEST_NEON(stp_6, stp(s0, s1, MemOperand(x2, -60)))
-TEST_NEON(stp_7, stp(s0, s1, MemOperand(x2, -92, PostIndex)))
-TEST_NEON(stp_8, stp(s0, s1, MemOperand(x2, -180, PreIndex)))
-TEST_NEON(str_0, str(b0, MemOperand(x1, -216, PostIndex)))
-TEST_NEON(str_1, str(b0, MemOperand(x1, -27, PreIndex)))
-TEST_NEON(str_2, str(b0, MemOperand(x1, 1568)))
-TEST_NEON(str_3, str(d0, MemOperand(x1, 17, PostIndex)))
-TEST_NEON(str_4, str(d0, MemOperand(x1, 84, PreIndex)))
-TEST_NEON(str_5, str(d0, MemOperand(x1, 8632)))
-TEST_NEON(str_6, str(h0, MemOperand(x1, -212, PostIndex)))
-TEST_NEON(str_7, str(h0, MemOperand(x1, 61, PreIndex)))
-TEST_NEON(str_8, str(h0, MemOperand(x1, 6858)))
-TEST_NEON(str_9, str(q0, MemOperand(x1, 234, PostIndex)))
-TEST_NEON(str_10, str(q0, MemOperand(x1, 85, PreIndex)))
-TEST_NEON(str_11, str(q0, MemOperand(x1, 56576)))
-TEST_NEON(str_12, str(s0, MemOperand(x1, -40, PostIndex)))
-TEST_NEON(str_13, str(s0, MemOperand(x1, 191, PreIndex)))
-TEST_NEON(str_14, str(s0, MemOperand(x1, 3872)))
+          st4(v0.S(), v1.S(), v2.S(), v3.S(), 3, MemOperand(x4, x5, PostIndex)))
+TEST_NEON(stnp_0, stnp(d0, d1, MemOperand(x2, 304)))
+TEST_NEON(stnp_1, stnp(q0, q1, MemOperand(x2, 480)))
+TEST_NEON(stnp_2, stnp(s0, s1, MemOperand(x2, -12)))
+TEST_NEON(stp_0, stp(d0, d1, MemOperand(x2, 168)))
+TEST_NEON(stp_1, stp(d0, d1, MemOperand(x2, -376, PostIndex)))
+TEST_NEON(stp_2, stp(d0, d1, MemOperand(x2, 296, PreIndex)))
+TEST_NEON(stp_3, stp(q0, q1, MemOperand(x2, -80)))
+TEST_NEON(stp_4, stp(q0, q1, MemOperand(x2, -768, PostIndex)))
+TEST_NEON(stp_5, stp(q0, q1, MemOperand(x2, -288, PreIndex)))
+TEST_NEON(stp_6, stp(s0, s1, MemOperand(x2, -256)))
+TEST_NEON(stp_7, stp(s0, s1, MemOperand(x2, 208, PostIndex)))
+TEST_NEON(stp_8, stp(s0, s1, MemOperand(x2, -4, PreIndex)))
+TEST_NEON(str_0, str(b0, MemOperand(x1, -45, PostIndex)))
+TEST_NEON(str_1, str(b0, MemOperand(x1, -154, PreIndex)))
+TEST_NEON(str_2, str(b0, MemOperand(x1, 992)))
+TEST_NEON(str_3, str(d0, MemOperand(x1, -181, PostIndex)))
+TEST_NEON(str_4, str(d0, MemOperand(x1, 91, PreIndex)))
+TEST_NEON(str_5, str(d0, MemOperand(x1, 32672)))
+TEST_NEON(str_6, str(h0, MemOperand(x1, -5, PostIndex)))
+TEST_NEON(str_7, str(h0, MemOperand(x1, 213, PreIndex)))
+TEST_NEON(str_8, str(h0, MemOperand(x1, 6406)))
+TEST_NEON(str_9, str(q0, MemOperand(x1, -87, PostIndex)))
+TEST_NEON(str_10, str(q0, MemOperand(x1, 198, PreIndex)))
+TEST_NEON(str_11, str(q0, MemOperand(x1, 56032)))
+TEST_NEON(str_12, str(s0, MemOperand(x1, -81, PostIndex)))
+TEST_NEON(str_13, str(s0, MemOperand(x1, -126, PreIndex)))
+TEST_NEON(str_14, str(s0, MemOperand(x1, 15692)))
 TEST_NEON(str_15, str(b0, MemOperand(x1, x2, LSL, 0)))
-TEST_NEON(str_16, str(b0, MemOperand(x1, w2, UXTW, 0)))
-TEST_NEON(str_17, str(b0, MemOperand(x1, x2, SXTX, 0)))
-TEST_NEON(str_18, str(d0, MemOperand(x1, w2, UXTW, 3)))
-TEST_NEON(str_19, str(d0, MemOperand(x1, x2, LSL, 0)))
-TEST_NEON(str_20, str(h0, MemOperand(x1, w2, UXTW, 1)))
-TEST_NEON(str_21, str(h0, MemOperand(x1, x2, SXTX, 1)))
-TEST_NEON(str_22, str(q0, MemOperand(x1, w2, UXTW, 0)))
-TEST_NEON(str_23, str(q0, MemOperand(x1, x2, LSL, 0)))
-TEST_NEON(str_24, str(s0, MemOperand(x1, w2, UXTW, 0)))
-TEST_NEON(str_25, str(s0, MemOperand(x1, x2, SXTX, 0)))
-TEST_NEON(stur_0, stur(b0, MemOperand(x1, 166)))
-TEST_NEON(stur_1, stur(d0, MemOperand(x1, 154)))
-TEST_NEON(stur_2, stur(h0, MemOperand(x1, 123)))
-TEST_NEON(stur_3, stur(q0, MemOperand(x1, 172)))
-TEST_NEON(stur_4, stur(s0, MemOperand(x1, -71)))
+TEST_NEON(str_16, str(b0, MemOperand(x1, w2, SXTW, 0)))
+TEST_NEON(str_17, str(d0, MemOperand(x1, w2, SXTW, 0)))
+TEST_NEON(str_18, str(d0, MemOperand(x1, x2, LSL, 0)))
+TEST_NEON(str_19, str(h0, MemOperand(x1, w2, UXTW, 1)))
+TEST_NEON(str_20, str(h0, MemOperand(x1, x2, SXTX, 1)))
+TEST_NEON(str_21, str(q0, MemOperand(x1, w2, SXTW, 4)))
+TEST_NEON(str_22, str(q0, MemOperand(x1, x2, SXTX, 4)))
+TEST_NEON(str_23, str(s0, MemOperand(x1, w2, UXTW, 0)))
+TEST_NEON(str_24, str(s0, MemOperand(x1, x2, SXTX, 2)))
+TEST_NEON(stur_0, stur(b0, MemOperand(x1, 83)))
+TEST_NEON(stur_1, stur(d0, MemOperand(x1, 22)))
+TEST_NEON(stur_2, stur(h0, MemOperand(x1, -236)))
+TEST_NEON(stur_3, stur(q0, MemOperand(x1, 13)))
+TEST_NEON(stur_4, stur(s0, MemOperand(x1, 23)))
 TEST_NEON(subhn_0, subhn(v0.V8B(), v1.V8H(), v2.V8H()))
 TEST_NEON(subhn_1, subhn(v0.V4H(), v1.V4S(), v2.V4S()))
 TEST_NEON(subhn_2, subhn(v0.V2S(), v1.V2D(), v2.V2D()))
@@ -2363,24 +2345,24 @@ TEST_NEON(sxtl2_1, sxtl2(v0.V4S(), v1.V8H()))
 TEST_NEON(sxtl2_2, sxtl2(v0.V2D(), v1.V4S()))
 TEST_NEON(tbl_0, tbl(v0.V8B(), v1.V16B(), v2.V8B()))
 TEST_NEON(tbl_1, tbl(v0.V16B(), v1.V16B(), v2.V16B()))
-TEST_NEON(tbl_2, tbl(v0.V8B(), v1.V16B(), v2.V16B(), v2.V8B()))
-TEST_NEON(tbl_3, tbl(v0.V16B(), v1.V16B(), v2.V16B(), v2.V16B()))
-TEST_NEON(tbl_4, tbl(v0.V8B(), v1.V16B(), v2.V16B(), v3.V16B(), v2.V8B()))
-TEST_NEON(tbl_5, tbl(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), v2.V16B()))
+TEST_NEON(tbl_2, tbl(v0.V8B(), v1.V16B(), v2.V16B(), v3.V8B()))
+TEST_NEON(tbl_3, tbl(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B()))
+TEST_NEON(tbl_4, tbl(v0.V8B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V8B()))
+TEST_NEON(tbl_5, tbl(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B()))
 TEST_NEON(tbl_6,
-          tbl(v0.V8B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), v2.V8B()))
+          tbl(v0.V8B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), v5.V8B()))
 TEST_NEON(tbl_7,
-          tbl(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), v2.V16B()))
+          tbl(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), v5.V16B()))
 TEST_NEON(tbx_0, tbx(v0.V8B(), v1.V16B(), v2.V8B()))
 TEST_NEON(tbx_1, tbx(v0.V16B(), v1.V16B(), v2.V16B()))
-TEST_NEON(tbx_2, tbx(v0.V8B(), v1.V16B(), v2.V16B(), v2.V8B()))
-TEST_NEON(tbx_3, tbx(v0.V16B(), v1.V16B(), v2.V16B(), v2.V16B()))
-TEST_NEON(tbx_4, tbx(v0.V8B(), v1.V16B(), v2.V16B(), v3.V16B(), v2.V8B()))
-TEST_NEON(tbx_5, tbx(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), v2.V16B()))
+TEST_NEON(tbx_2, tbx(v0.V8B(), v1.V16B(), v2.V16B(), v3.V8B()))
+TEST_NEON(tbx_3, tbx(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B()))
+TEST_NEON(tbx_4, tbx(v0.V8B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V8B()))
+TEST_NEON(tbx_5, tbx(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B()))
 TEST_NEON(tbx_6,
-          tbx(v0.V8B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), v2.V8B()))
+          tbx(v0.V8B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), v5.V8B()))
 TEST_NEON(tbx_7,
-          tbx(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), v2.V16B()))
+          tbx(v0.V16B(), v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), v5.V16B()))
 TEST_NEON(trn1_0, trn1(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(trn1_1, trn1(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(trn1_2, trn1(v0.V4H(), v1.V4H(), v2.V4H()))
@@ -2495,33 +2477,33 @@ TEST_NEON(umin_3, umin(v0.V8H(), v1.V8H(), v2.V8H()))
 TEST_NEON(umin_4, umin(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(umin_5, umin(v0.V4S(), v1.V4S(), v2.V4S()))
 TEST_NEON(umlal_0, umlal(v0.V4S(), v1.V4H(), v2.H(), 1))
-TEST_NEON(umlal_1, umlal(v0.V2D(), v1.V2S(), v2.S(), 1))
-TEST_NEON(umlal2_0, umlal2(v0.V4S(), v1.V8H(), v2.H(), 2))
-TEST_NEON(umlal2_1, umlal2(v0.V2D(), v1.V4S(), v2.S(), 1))
+TEST_NEON(umlal_1, umlal(v0.V2D(), v1.V2S(), v2.S(), 2))
+TEST_NEON(umlal2_0, umlal2(v0.V4S(), v1.V8H(), v2.H(), 6))
+TEST_NEON(umlal2_1, umlal2(v0.V2D(), v1.V4S(), v2.S(), 0))
 TEST_NEON(umlal_2, umlal(v0.V8H(), v1.V8B(), v2.V8B()))
 TEST_NEON(umlal_3, umlal(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(umlal_4, umlal(v0.V2D(), v1.V2S(), v2.V2S()))
 TEST_NEON(umlal2_2, umlal2(v0.V8H(), v1.V16B(), v2.V16B()))
 TEST_NEON(umlal2_3, umlal2(v0.V4S(), v1.V8H(), v2.V8H()))
 TEST_NEON(umlal2_4, umlal2(v0.V2D(), v1.V4S(), v2.V4S()))
-TEST_NEON(umlsl_0, umlsl(v0.V4S(), v1.V4H(), v2.H(), 1))
-TEST_NEON(umlsl_1, umlsl(v0.V2D(), v1.V2S(), v2.S(), 0))
-TEST_NEON(umlsl2_0, umlsl2(v0.V4S(), v1.V8H(), v2.H(), 4))
-TEST_NEON(umlsl2_1, umlsl2(v0.V2D(), v1.V4S(), v2.S(), 3))
+TEST_NEON(umlsl_0, umlsl(v0.V4S(), v1.V4H(), v2.H(), 0))
+TEST_NEON(umlsl_1, umlsl(v0.V2D(), v1.V2S(), v2.S(), 3))
+TEST_NEON(umlsl2_0, umlsl2(v0.V4S(), v1.V8H(), v2.H(), 1))
+TEST_NEON(umlsl2_1, umlsl2(v0.V2D(), v1.V4S(), v2.S(), 1))
 TEST_NEON(umlsl_2, umlsl(v0.V8H(), v1.V8B(), v2.V8B()))
 TEST_NEON(umlsl_3, umlsl(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(umlsl_4, umlsl(v0.V2D(), v1.V2S(), v2.V2S()))
 TEST_NEON(umlsl2_2, umlsl2(v0.V8H(), v1.V16B(), v2.V16B()))
 TEST_NEON(umlsl2_3, umlsl2(v0.V4S(), v1.V8H(), v2.V8H()))
 TEST_NEON(umlsl2_4, umlsl2(v0.V2D(), v1.V4S(), v2.V4S()))
-TEST_NEON(umov_0, umov(w0, v1.B(), 14))
-TEST_NEON(umov_1, umov(w0, v1.H(), 7))
-TEST_NEON(umov_2, umov(w0, v1.S(), 2))
-TEST_NEON(umov_3, umov(x0, v1.D(), 0))
-TEST_NEON(umull_0, umull(v0.V4S(), v1.V4H(), v2.H(), 1))
+TEST_NEON(umov_0, umov(w0, v1.B(), 4))
+TEST_NEON(umov_1, umov(w0, v1.H(), 3))
+TEST_NEON(umov_2, umov(w0, v1.S(), 0))
+TEST_NEON(umov_3, umov(x0, v1.D(), 1))
+TEST_NEON(umull_0, umull(v0.V4S(), v1.V4H(), v2.H(), 0))
 TEST_NEON(umull_1, umull(v0.V2D(), v1.V2S(), v2.S(), 1))
-TEST_NEON(umull2_0, umull2(v0.V4S(), v1.V8H(), v2.H(), 0))
-TEST_NEON(umull2_1, umull2(v0.V2D(), v1.V4S(), v2.S(), 2))
+TEST_NEON(umull2_0, umull2(v0.V4S(), v1.V8H(), v2.H(), 6))
+TEST_NEON(umull2_1, umull2(v0.V2D(), v1.V4S(), v2.S(), 3))
 TEST_NEON(umull_2, umull(v0.V8H(), v1.V8B(), v2.V8B()))
 TEST_NEON(umull_3, umull(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(umull_4, umull(v0.V2D(), v1.V2S(), v2.V2S()))
@@ -2550,26 +2532,26 @@ TEST_NEON(uqrshl_7, uqrshl(b0, b1, b2))
 TEST_NEON(uqrshl_8, uqrshl(h0, h1, h2))
 TEST_NEON(uqrshl_9, uqrshl(s0, s1, s2))
 TEST_NEON(uqrshl_10, uqrshl(d0, d1, d2))
-TEST_NEON(uqrshrn_0, uqrshrn(v0.V8B(), v1.V8H(), 4))
-TEST_NEON(uqrshrn_1, uqrshrn(v0.V4H(), v1.V4S(), 6))
-TEST_NEON(uqrshrn_2, uqrshrn(v0.V2S(), v1.V2D(), 18))
-TEST_NEON(uqrshrn2_0, uqrshrn2(v0.V16B(), v1.V8H(), 3))
-TEST_NEON(uqrshrn2_1, uqrshrn2(v0.V8H(), v1.V4S(), 10))
-TEST_NEON(uqrshrn2_2, uqrshrn2(v0.V4S(), v1.V2D(), 23))
-TEST_NEON(uqrshrn_3, uqrshrn(b0, h1, 3))
-TEST_NEON(uqrshrn_4, uqrshrn(h0, s1, 1))
-TEST_NEON(uqrshrn_5, uqrshrn(s0, d1, 8))
-TEST_NEON(uqshl_0, uqshl(v0.V8B(), v1.V8B(), 3))
-TEST_NEON(uqshl_1, uqshl(v0.V16B(), v1.V16B(), 6))
-TEST_NEON(uqshl_2, uqshl(v0.V4H(), v1.V4H(), 3))
-TEST_NEON(uqshl_3, uqshl(v0.V8H(), v1.V8H(), 7))
+TEST_NEON(uqrshrn_0, uqrshrn(v0.V8B(), v1.V8H(), 5))
+TEST_NEON(uqrshrn_1, uqrshrn(v0.V4H(), v1.V4S(), 4))
+TEST_NEON(uqrshrn_2, uqrshrn(v0.V2S(), v1.V2D(), 23))
+TEST_NEON(uqrshrn2_0, uqrshrn2(v0.V16B(), v1.V8H(), 4))
+TEST_NEON(uqrshrn2_1, uqrshrn2(v0.V8H(), v1.V4S(), 5))
+TEST_NEON(uqrshrn2_2, uqrshrn2(v0.V4S(), v1.V2D(), 11))
+TEST_NEON(uqrshrn_3, uqrshrn(b0, h1, 4))
+TEST_NEON(uqrshrn_4, uqrshrn(h0, s1, 4))
+TEST_NEON(uqrshrn_5, uqrshrn(s0, d1, 7))
+TEST_NEON(uqshl_0, uqshl(v0.V8B(), v1.V8B(), 7))
+TEST_NEON(uqshl_1, uqshl(v0.V16B(), v1.V16B(), 2))
+TEST_NEON(uqshl_2, uqshl(v0.V4H(), v1.V4H(), 4))
+TEST_NEON(uqshl_3, uqshl(v0.V8H(), v1.V8H(), 4))
 TEST_NEON(uqshl_4, uqshl(v0.V2S(), v1.V2S(), 1))
-TEST_NEON(uqshl_5, uqshl(v0.V4S(), v1.V4S(), 23))
-TEST_NEON(uqshl_6, uqshl(v0.V2D(), v1.V2D(), 40))
+TEST_NEON(uqshl_5, uqshl(v0.V4S(), v1.V4S(), 2))
+TEST_NEON(uqshl_6, uqshl(v0.V2D(), v1.V2D(), 28))
 TEST_NEON(uqshl_7, uqshl(b0, b1, 6))
 TEST_NEON(uqshl_8, uqshl(h0, h1, 15))
-TEST_NEON(uqshl_9, uqshl(s0, s1, 18))
-TEST_NEON(uqshl_10, uqshl(d0, d1, 20))
+TEST_NEON(uqshl_9, uqshl(s0, s1, 21))
+TEST_NEON(uqshl_10, uqshl(d0, d1, 24))
 TEST_NEON(uqshl_11, uqshl(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(uqshl_12, uqshl(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(uqshl_13, uqshl(v0.V4H(), v1.V4H(), v2.V4H()))
@@ -2581,15 +2563,15 @@ TEST_NEON(uqshl_18, uqshl(b0, b1, b2))
 TEST_NEON(uqshl_19, uqshl(h0, h1, h2))
 TEST_NEON(uqshl_20, uqshl(s0, s1, s2))
 TEST_NEON(uqshl_21, uqshl(d0, d1, d2))
-TEST_NEON(uqshrn_0, uqshrn(v0.V8B(), v1.V8H(), 4))
-TEST_NEON(uqshrn_1, uqshrn(v0.V4H(), v1.V4S(), 12))
-TEST_NEON(uqshrn_2, uqshrn(v0.V2S(), v1.V2D(), 19))
-TEST_NEON(uqshrn2_0, uqshrn2(v0.V16B(), v1.V8H(), 1))
-TEST_NEON(uqshrn2_1, uqshrn2(v0.V8H(), v1.V4S(), 5))
-TEST_NEON(uqshrn2_2, uqshrn2(v0.V4S(), v1.V2D(), 12))
-TEST_NEON(uqshrn_3, uqshrn(b0, h1, 4))
-TEST_NEON(uqshrn_4, uqshrn(h0, s1, 15))
-TEST_NEON(uqshrn_5, uqshrn(s0, d1, 18))
+TEST_NEON(uqshrn_0, uqshrn(v0.V8B(), v1.V8H(), 6))
+TEST_NEON(uqshrn_1, uqshrn(v0.V4H(), v1.V4S(), 1))
+TEST_NEON(uqshrn_2, uqshrn(v0.V2S(), v1.V2D(), 7))
+TEST_NEON(uqshrn2_0, uqshrn2(v0.V16B(), v1.V8H(), 3))
+TEST_NEON(uqshrn2_1, uqshrn2(v0.V8H(), v1.V4S(), 9))
+TEST_NEON(uqshrn2_2, uqshrn2(v0.V4S(), v1.V2D(), 20))
+TEST_NEON(uqshrn_3, uqshrn(b0, h1, 7))
+TEST_NEON(uqshrn_4, uqshrn(h0, s1, 11))
+TEST_NEON(uqshrn_5, uqshrn(s0, d1, 17))
 TEST_NEON(uqsub_0, uqsub(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(uqsub_1, uqsub(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(uqsub_2, uqsub(v0.V4H(), v1.V4H(), v2.V4H()))
@@ -2626,30 +2608,30 @@ TEST_NEON(urshl_4, urshl(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(urshl_5, urshl(v0.V4S(), v1.V4S(), v2.V4S()))
 TEST_NEON(urshl_6, urshl(v0.V2D(), v1.V2D(), v2.V2D()))
 TEST_NEON(urshl_7, urshl(d0, d1, d2))
-TEST_NEON(urshr_0, urshr(v0.V8B(), v1.V8B(), 1))
-TEST_NEON(urshr_1, urshr(v0.V16B(), v1.V16B(), 3))
-TEST_NEON(urshr_2, urshr(v0.V4H(), v1.V4H(), 3))
-TEST_NEON(urshr_3, urshr(v0.V8H(), v1.V8H(), 11))
-TEST_NEON(urshr_4, urshr(v0.V2S(), v1.V2S(), 30))
-TEST_NEON(urshr_5, urshr(v0.V4S(), v1.V4S(), 1))
-TEST_NEON(urshr_6, urshr(v0.V2D(), v1.V2D(), 41))
-TEST_NEON(urshr_7, urshr(d0, d1, 21))
+TEST_NEON(urshr_0, urshr(v0.V8B(), v1.V8B(), 4))
+TEST_NEON(urshr_1, urshr(v0.V16B(), v1.V16B(), 5))
+TEST_NEON(urshr_2, urshr(v0.V4H(), v1.V4H(), 11))
+TEST_NEON(urshr_3, urshr(v0.V8H(), v1.V8H(), 4))
+TEST_NEON(urshr_4, urshr(v0.V2S(), v1.V2S(), 27))
+TEST_NEON(urshr_5, urshr(v0.V4S(), v1.V4S(), 21))
+TEST_NEON(urshr_6, urshr(v0.V2D(), v1.V2D(), 8))
+TEST_NEON(urshr_7, urshr(d0, d1, 11))
 TEST_NEON(ursqrte_0, ursqrte(v0.V2S(), v1.V2S()))
 TEST_NEON(ursqrte_1, ursqrte(v0.V4S(), v1.V4S()))
-TEST_NEON(ursra_0, ursra(v0.V8B(), v1.V8B(), 4))
+TEST_NEON(ursra_0, ursra(v0.V8B(), v1.V8B(), 3))
 TEST_NEON(ursra_1, ursra(v0.V16B(), v1.V16B(), 6))
-TEST_NEON(ursra_2, ursra(v0.V4H(), v1.V4H(), 14))
-TEST_NEON(ursra_3, ursra(v0.V8H(), v1.V8H(), 6))
-TEST_NEON(ursra_4, ursra(v0.V2S(), v1.V2S(), 12))
-TEST_NEON(ursra_5, ursra(v0.V4S(), v1.V4S(), 25))
-TEST_NEON(ursra_6, ursra(v0.V2D(), v1.V2D(), 4))
-TEST_NEON(ursra_7, ursra(d0, d1, 52))
-TEST_NEON(ushll_0, ushll(v0.V8H(), v1.V8B(), 2))
-TEST_NEON(ushll_1, ushll(v0.V4S(), v1.V4H(), 7))
-TEST_NEON(ushll_2, ushll(v0.V2D(), v1.V2S(), 5))
-TEST_NEON(ushll2_0, ushll2(v0.V8H(), v1.V16B(), 1))
-TEST_NEON(ushll2_1, ushll2(v0.V4S(), v1.V8H(), 3))
-TEST_NEON(ushll2_2, ushll2(v0.V2D(), v1.V4S(), 3))
+TEST_NEON(ursra_2, ursra(v0.V4H(), v1.V4H(), 12))
+TEST_NEON(ursra_3, ursra(v0.V8H(), v1.V8H(), 7))
+TEST_NEON(ursra_4, ursra(v0.V2S(), v1.V2S(), 6))
+TEST_NEON(ursra_5, ursra(v0.V4S(), v1.V4S(), 6))
+TEST_NEON(ursra_6, ursra(v0.V2D(), v1.V2D(), 26))
+TEST_NEON(ursra_7, ursra(d0, d1, 20))
+TEST_NEON(ushll_0, ushll(v0.V8H(), v1.V8B(), 6))
+TEST_NEON(ushll_1, ushll(v0.V4S(), v1.V4H(), 9))
+TEST_NEON(ushll_2, ushll(v0.V2D(), v1.V2S(), 21))
+TEST_NEON(ushll2_0, ushll2(v0.V8H(), v1.V16B(), 7))
+TEST_NEON(ushll2_1, ushll2(v0.V4S(), v1.V8H(), 15))
+TEST_NEON(ushll2_2, ushll2(v0.V2D(), v1.V4S(), 14))
 TEST_NEON(ushl_0, ushl(v0.V8B(), v1.V8B(), v2.V8B()))
 TEST_NEON(ushl_1, ushl(v0.V16B(), v1.V16B(), v2.V16B()))
 TEST_NEON(ushl_2, ushl(v0.V4H(), v1.V4H(), v2.V4H()))
@@ -2658,14 +2640,14 @@ TEST_NEON(ushl_4, ushl(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(ushl_5, ushl(v0.V4S(), v1.V4S(), v2.V4S()))
 TEST_NEON(ushl_6, ushl(v0.V2D(), v1.V2D(), v2.V2D()))
 TEST_NEON(ushl_7, ushl(d0, d1, d2))
-TEST_NEON(ushr_0, ushr(v0.V8B(), v1.V8B(), 5))
-TEST_NEON(ushr_1, ushr(v0.V16B(), v1.V16B(), 7))
-TEST_NEON(ushr_2, ushr(v0.V4H(), v1.V4H(), 2))
-TEST_NEON(ushr_3, ushr(v0.V8H(), v1.V8H(), 8))
-TEST_NEON(ushr_4, ushr(v0.V2S(), v1.V2S(), 2))
-TEST_NEON(ushr_5, ushr(v0.V4S(), v1.V4S(), 3))
-TEST_NEON(ushr_6, ushr(v0.V2D(), v1.V2D(), 28))
-TEST_NEON(ushr_7, ushr(d0, d1, 57))
+TEST_NEON(ushr_0, ushr(v0.V8B(), v1.V8B(), 1))
+TEST_NEON(ushr_1, ushr(v0.V16B(), v1.V16B(), 1))
+TEST_NEON(ushr_2, ushr(v0.V4H(), v1.V4H(), 5))
+TEST_NEON(ushr_3, ushr(v0.V8H(), v1.V8H(), 4))
+TEST_NEON(ushr_4, ushr(v0.V2S(), v1.V2S(), 1))
+TEST_NEON(ushr_5, ushr(v0.V4S(), v1.V4S(), 24))
+TEST_NEON(ushr_6, ushr(v0.V2D(), v1.V2D(), 50))
+TEST_NEON(ushr_7, ushr(d0, d1, 30))
 TEST_NEON(usqadd_0, usqadd(v0.V8B(), v1.V8B()))
 TEST_NEON(usqadd_1, usqadd(v0.V16B(), v1.V16B()))
 TEST_NEON(usqadd_2, usqadd(v0.V4H(), v1.V4H()))
@@ -2677,14 +2659,14 @@ TEST_NEON(usqadd_7, usqadd(b0, b1))
 TEST_NEON(usqadd_8, usqadd(h0, h1))
 TEST_NEON(usqadd_9, usqadd(s0, s1))
 TEST_NEON(usqadd_10, usqadd(d0, d1))
-TEST_NEON(usra_0, usra(v0.V8B(), v1.V8B(), 5))
+TEST_NEON(usra_0, usra(v0.V8B(), v1.V8B(), 6))
 TEST_NEON(usra_1, usra(v0.V16B(), v1.V16B(), 4))
-TEST_NEON(usra_2, usra(v0.V4H(), v1.V4H(), 7))
-TEST_NEON(usra_3, usra(v0.V8H(), v1.V8H(), 12))
-TEST_NEON(usra_4, usra(v0.V2S(), v1.V2S(), 2))
-TEST_NEON(usra_5, usra(v0.V4S(), v1.V4S(), 11))
-TEST_NEON(usra_6, usra(v0.V2D(), v1.V2D(), 15))
-TEST_NEON(usra_7, usra(d0, d1, 14))
+TEST_NEON(usra_2, usra(v0.V4H(), v1.V4H(), 9))
+TEST_NEON(usra_3, usra(v0.V8H(), v1.V8H(), 3))
+TEST_NEON(usra_4, usra(v0.V2S(), v1.V2S(), 12))
+TEST_NEON(usra_5, usra(v0.V4S(), v1.V4S(), 14))
+TEST_NEON(usra_6, usra(v0.V2D(), v1.V2D(), 27))
+TEST_NEON(usra_7, usra(d0, d1, 54))
 TEST_NEON(usubl_0, usubl(v0.V8H(), v1.V8B(), v2.V8B()))
 TEST_NEON(usubl_1, usubl(v0.V4S(), v1.V4H(), v2.V4H()))
 TEST_NEON(usubl_2, usubl(v0.V2D(), v1.V2S(), v2.V2S()))
@@ -2738,6 +2720,17 @@ TEST_NEON(zip2_4, zip2(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_NEON(zip2_5, zip2(v0.V4S(), v1.V4S(), v2.V4S()))
 TEST_NEON(zip2_6, zip2(v0.V2D(), v1.V2D(), v2.V2D()))
 
+#define TEST_CRC32(NAME, ASM) \
+  TEST_TEMPLATE(CPUFeatures(CPUFeatures::kCRC32), CRC32_##NAME, ASM)
+TEST_CRC32(crc32b_0, crc32b(w0, w1, w2))
+TEST_CRC32(crc32h_0, crc32h(w0, w1, w2))
+TEST_CRC32(crc32w_0, crc32w(w0, w1, w2))
+TEST_CRC32(crc32x_0, crc32x(w0, w1, x2))
+TEST_CRC32(crc32cb_0, crc32cb(w0, w1, w2))
+TEST_CRC32(crc32ch_0, crc32ch(w0, w1, w2))
+TEST_CRC32(crc32cw_0, crc32cw(w0, w1, w2))
+TEST_CRC32(crc32cx_0, crc32cx(w0, w1, x2))
+
 #define TEST_FP_NEON(NAME, ASM)                                    \
   TEST_TEMPLATE(CPUFeatures(CPUFeatures::kFP, CPUFeatures::kNEON), \
                 FP_NEON_##NAME,                                    \
@@ -2914,40 +2907,38 @@ TEST_FP_NEON(fminv_0, fminv(s0, v1.V4S()))
 TEST_FP_NEON(fmin_0, fmin(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_FP_NEON(fmin_1, fmin(v0.V4S(), v1.V4S(), v2.V4S()))
 TEST_FP_NEON(fmin_2, fmin(v0.V2D(), v1.V2D(), v2.V2D()))
-TEST_FP_NEON(fmla_0, fmla(v0.V2S(), v1.V2S(), v2.S(), 1))
+TEST_FP_NEON(fmla_0, fmla(v0.V2S(), v1.V2S(), v2.S(), 3))
 TEST_FP_NEON(fmla_1, fmla(v0.V4S(), v1.V4S(), v2.S(), 2))
 TEST_FP_NEON(fmla_2, fmla(v0.V2D(), v1.V2D(), v2.D(), 0))
 TEST_FP_NEON(fmla_3, fmla(s0, s1, v2.S(), 1))
 TEST_FP_NEON(fmla_4, fmla(d0, d1, v2.D(), 0))
 TEST_FP_NEON(fmla_5, fmla(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_FP_NEON(fmla_6, fmla(v0.V4S(), v1.V4S(), v2.V4S()))
-TEST_FP_NEON(fmls_0, fmls(v0.V2S(), v1.V2S(), v2.S(), 2))
-TEST_FP_NEON(fmls_1, fmls(v0.V4S(), v1.V4S(), v2.S(), 3))
+TEST_FP_NEON(fmls_0, fmls(v0.V2S(), v1.V2S(), v2.S(), 3))
+TEST_FP_NEON(fmls_1, fmls(v0.V4S(), v1.V4S(), v2.S(), 1))
 TEST_FP_NEON(fmls_2, fmls(v0.V2D(), v1.V2D(), v2.D(), 1))
-TEST_FP_NEON(fmls_3, fmls(s0, s1, v2.S(), 0))
-TEST_FP_NEON(fmls_4, fmls(d0, d1, v2.D(), 1))
+TEST_FP_NEON(fmls_3, fmls(s0, s1, v2.S(), 3))
+TEST_FP_NEON(fmls_4, fmls(d0, d1, v2.D(), 0))
 TEST_FP_NEON(fmls_5, fmls(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_FP_NEON(fmls_6, fmls(v0.V4S(), v1.V4S(), v2.V4S()))
-TEST_FP_NEON(fmov_0, fmov(v0.V2D(), 1.625))
-TEST_FP_NEON(fmov_1, fmov(v0.V2S(), 23.0f))
-TEST_FP_NEON(fmov_2, fmov(v0.V4S(), 0.203125f))
-TEST_FP_NEON(fmov_3, fmov(v0.V2S(), 6.25f))
-TEST_FP_NEON(fmov_4, fmov(v0.V4S(), 17.0f))
-TEST_FP_NEON(fmov_5, fmov(x0, v1.D(), 1))
-TEST_FP_NEON(fmov_6, fmov(v0.D(), 1, x1))
+TEST_FP_NEON(fmov_0, fmov(v0.V2D(), -0.96875))
+TEST_FP_NEON(fmov_1, fmov(v0.V2S(), 3.875f))
+TEST_FP_NEON(fmov_2, fmov(v0.V4S(), 0.1328125f))
+TEST_FP_NEON(fmov_3, fmov(x0, v1.D(), 1))
+TEST_FP_NEON(fmov_4, fmov(v0.D(), 1, x1))
 TEST_FP_NEON(fmulx_0, fmulx(v0.V2S(), v1.V2S(), v2.S(), 1))
-TEST_FP_NEON(fmulx_1, fmulx(v0.V4S(), v1.V4S(), v2.S(), 0))
-TEST_FP_NEON(fmulx_2, fmulx(v0.V2D(), v1.V2D(), v2.D(), 1))
-TEST_FP_NEON(fmulx_3, fmulx(s0, s1, v2.S(), 1))
+TEST_FP_NEON(fmulx_1, fmulx(v0.V4S(), v1.V4S(), v2.S(), 2))
+TEST_FP_NEON(fmulx_2, fmulx(v0.V2D(), v1.V2D(), v2.D(), 0))
+TEST_FP_NEON(fmulx_3, fmulx(s0, s1, v2.S(), 2))
 TEST_FP_NEON(fmulx_4, fmulx(d0, d1, v2.D(), 0))
 TEST_FP_NEON(fmulx_5, fmulx(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_FP_NEON(fmulx_6, fmulx(v0.V4S(), v1.V4S(), v2.V4S()))
 TEST_FP_NEON(fmulx_7, fmulx(s0, s1, s2))
 TEST_FP_NEON(fmulx_8, fmulx(d0, d1, d2))
-TEST_FP_NEON(fmul_0, fmul(v0.V2S(), v1.V2S(), v2.S(), 0))
-TEST_FP_NEON(fmul_1, fmul(v0.V4S(), v1.V4S(), v2.S(), 3))
+TEST_FP_NEON(fmul_0, fmul(v0.V2S(), v1.V2S(), v2.S(), 3))
+TEST_FP_NEON(fmul_1, fmul(v0.V4S(), v1.V4S(), v2.S(), 2))
 TEST_FP_NEON(fmul_2, fmul(v0.V2D(), v1.V2D(), v2.D(), 1))
-TEST_FP_NEON(fmul_3, fmul(s0, s1, v2.S(), 3))
+TEST_FP_NEON(fmul_3, fmul(s0, s1, v2.S(), 1))
 TEST_FP_NEON(fmul_4, fmul(d0, d1, v2.D(), 1))
 TEST_FP_NEON(fmul_5, fmul(v0.V2S(), v1.V2S(), v2.V2S()))
 TEST_FP_NEON(fmul_6, fmul(v0.V4S(), v1.V4S(), v2.V4S()))
@@ -3024,5 +3015,59 @@ TEST_FP_NEON(ucvtf_7, ucvtf(v0.V2D(), v1.V2D()))
 TEST_FP_NEON(ucvtf_8, ucvtf(s0, s1))
 TEST_FP_NEON(ucvtf_9, ucvtf(d0, d1))
 
+#define TEST_RDM_NEON(NAME, ASM)                                    \
+  TEST_TEMPLATE(CPUFeatures(CPUFeatures::kRDM, CPUFeatures::kNEON), \
+                RDM_NEON_##NAME,                                    \
+                ASM)
+TEST_RDM_NEON(sqrdmlah_0, sqrdmlah(v0.V4H(), v1.V4H(), v2.H(), 5))
+TEST_RDM_NEON(sqrdmlah_1, sqrdmlah(v0.V8H(), v1.V8H(), v2.H(), 4))
+TEST_RDM_NEON(sqrdmlah_2, sqrdmlah(v0.V2S(), v1.V2S(), v2.S(), 3))
+TEST_RDM_NEON(sqrdmlah_3, sqrdmlah(v0.V4S(), v1.V4S(), v2.S(), 0))
+TEST_RDM_NEON(sqrdmlah_4, sqrdmlah(h0, h1, v2.H(), 5))
+TEST_RDM_NEON(sqrdmlah_5, sqrdmlah(s0, s1, v2.S(), 1))
+TEST_RDM_NEON(sqrdmlah_6, sqrdmlah(v0.V4H(), v1.V4H(), v2.V4H()))
+TEST_RDM_NEON(sqrdmlah_7, sqrdmlah(v0.V8H(), v1.V8H(), v2.V8H()))
+TEST_RDM_NEON(sqrdmlah_8, sqrdmlah(v0.V2S(), v1.V2S(), v2.V2S()))
+TEST_RDM_NEON(sqrdmlah_9, sqrdmlah(v0.V4S(), v1.V4S(), v2.V4S()))
+TEST_RDM_NEON(sqrdmlah_10, sqrdmlah(h0, h1, h2))
+TEST_RDM_NEON(sqrdmlah_11, sqrdmlah(s0, s1, s2))
+TEST_RDM_NEON(sqrdmlsh_0, sqrdmlsh(v0.V4H(), v1.V4H(), v2.H(), 5))
+TEST_RDM_NEON(sqrdmlsh_1, sqrdmlsh(v0.V8H(), v1.V8H(), v2.H(), 5))
+TEST_RDM_NEON(sqrdmlsh_2, sqrdmlsh(v0.V2S(), v1.V2S(), v2.S(), 2))
+TEST_RDM_NEON(sqrdmlsh_3, sqrdmlsh(v0.V4S(), v1.V4S(), v2.S(), 1))
+TEST_RDM_NEON(sqrdmlsh_4, sqrdmlsh(h0, h1, v2.H(), 6))
+TEST_RDM_NEON(sqrdmlsh_5, sqrdmlsh(s0, s1, v2.S(), 1))
+TEST_RDM_NEON(sqrdmlsh_6, sqrdmlsh(v0.V4H(), v1.V4H(), v2.V4H()))
+TEST_RDM_NEON(sqrdmlsh_7, sqrdmlsh(v0.V8H(), v1.V8H(), v2.V8H()))
+TEST_RDM_NEON(sqrdmlsh_8, sqrdmlsh(v0.V2S(), v1.V2S(), v2.V2S()))
+TEST_RDM_NEON(sqrdmlsh_9, sqrdmlsh(v0.V4S(), v1.V4S(), v2.V4S()))
+TEST_RDM_NEON(sqrdmlsh_10, sqrdmlsh(h0, h1, h2))
+TEST_RDM_NEON(sqrdmlsh_11, sqrdmlsh(s0, s1, s2))
+
+#define TEST_LOREGIONS(NAME, ASM) \
+  TEST_TEMPLATE(CPUFeatures(CPUFeatures::kLORegions), LORegions_##NAME, ASM)
+TEST_LOREGIONS(ldlar_0, ldlar(w0, MemOperand(x1, 0)))
+TEST_LOREGIONS(ldlar_1, ldlar(x0, MemOperand(x1, 0)))
+TEST_LOREGIONS(ldlarb_0, ldlarb(w0, MemOperand(x1, 0)))
+TEST_LOREGIONS(ldlarh_0, ldlarh(w0, MemOperand(x1, 0)))
+TEST_LOREGIONS(stllr_0, stllr(w0, MemOperand(x1, 0)))
+TEST_LOREGIONS(stllr_1, stllr(x0, MemOperand(x1, 0)))
+TEST_LOREGIONS(stllrb_0, stllrb(w0, MemOperand(x1, 0)))
+TEST_LOREGIONS(stllrh_0, stllrh(w0, MemOperand(x1, 0)))
+
+#define TEST_FP_FCMA_NEON(NAME, ASM)             \
+  TEST_TEMPLATE(CPUFeatures(CPUFeatures::kFP,    \
+                            CPUFeatures::kFcma,  \
+                            CPUFeatures::kNEON), \
+                FP_Fcma_NEON_##NAME,             \
+                ASM)
+TEST_FP_FCMA_NEON(fcadd_0, fcadd(v0.V2S(), v1.V2S(), v2.V2S(), 270))
+TEST_FP_FCMA_NEON(fcadd_1, fcadd(v0.V4S(), v1.V4S(), v2.V4S(), 90))
+TEST_FP_FCMA_NEON(fcadd_2, fcadd(v0.V2D(), v1.V2D(), v2.V2D(), 270))
+TEST_FP_FCMA_NEON(fcmla_0, fcmla(v0.V4S(), v1.V4S(), v2.S(), 0, 180))
+TEST_FP_FCMA_NEON(fcmla_1, fcmla(v0.V2S(), v1.V2S(), v2.V2S(), 90))
+TEST_FP_FCMA_NEON(fcmla_2, fcmla(v0.V4S(), v1.V4S(), v2.V4S(), 90))
+TEST_FP_FCMA_NEON(fcmla_3, fcmla(v0.V2D(), v1.V2D(), v2.V2D(), 90))
+
 }  // namespace aarch64
 }  // namespace vixl
author	Jacob Bramley <jacob.bramley@arm.com>	2018-08-20 17:38:13 +0100
committer	Jacob Bramley <jacob.bramley@arm.com>	2018-08-28 14:16:48 +0100
commit	f658ca1813c32f483f20f75a4be0947ef66b442f (patch)
tree	47e32ebccc275d9d027ea841b39100381f918136 /test
parent	7175d2ed0e4b6473dfc5a73116ee1957d6b99efd (diff)