Lines Matching refs:zn
381 ZRegister zn = z2.WithLaneSize(lane_size_in_bits);
387 InsrHelper(&masm, zn, zn_inputs);
408 __ Mla(mla_da_result, p0.Merging(), mla_da_result, zn, zm);
410 __ Mov(mla_dn_result, zn);
414 __ Mla(mla_dm_result, p2.Merging(), za, zn, mla_dm_result);
417 __ Mla(mla_d_result, p3.Merging(), za, zn, zm);
427 __ Mls(mls_da_result, p0.Merging(), mls_da_result, zn, zm);
429 __ Mov(mls_dn_result, zn);
433 __ Mls(mls_dm_result, p2.Merging(), za, zn, mls_dm_result);
436 __ Mls(mls_d_result, p3.Merging(), za, zn, zm);
4471 const ZRegister& zn,
4496 // `instr` zd(dst), zd(src_a), zn(src_b)
4507 // `instr` zd(dst), zm(src_a), zn(src_b)
4509 // and movprfx + `instr` based on whether zd and zn registers are aliased.
5033 const ZRegister& zn,
5046 ZRegister zn = z31.WithLaneSize(lane_size_in_bits);
5048 InsrHelper(&masm, zn, zn_inputs);
5052 (masm.*macro)(zd, zn, zm);
5890 // Make a copy so we can check that constructive operations preserve zn.
5998 // Make a copy so we can check that constructive operations preserve zn.
6086 // Make a copy so we can check that constructive operations preserve zn.
6168 // Make a copy so we can check that constructive operations preserve zn.
6254 // Make a copy so we can check that constructive operations preserve zn.
6339 // Make a copy so we can check that constructive operations preserve zn.
9853 ZRegister zn = z0.WithLaneSize(esize_in_bits);
9894 InsrHelper(&masm, zn, offsets);
9897 __ Lsr(zn, zn, shift);
9900 (masm.*ld1)(zt, pg, SVEMemOperand(x0, zn, mod, shift));
9908 (masm.*ldff1)(zt_ff, pg, SVEMemOperand(x0, zn, mod, shift));
9969 ZRegister zn = z0.WithLaneSize(esize_in_bits);
9987 // if any value won't fit in a lane of zn.
9988 InsrHelper(&masm, zn, addresses);
9989 (masm.*sve_ld1)(zt_addresses, pg, SVEMemOperand(zn));
9992 InsrHelper(&masm, zn, offsets);
9993 (masm.*sve_ld1)(zt_offsets, pg, SVEMemOperand(zn, data));
9995 InsrHelper(&masm, zn, maxed_offsets);
9996 (masm.*sve_ld1)(zt_maxed, pg, SVEMemOperand(zn, maxed_offsets_imm));
10777 const ZRegister& zn,
10793 // Also test with a different zn, to test the movprfx case.
10794 ZRegister zn = z1.WithLaneSize(lane_size_in_bits);
10795 InsrHelper(&masm, zn, zn_inputs);
10797 ZRegister zn_copy = z3.WithSameLaneSizeAs(zn);
10799 // Make a copy so we can check that constructive operations preserve zn.
10800 __ Mov(zn_copy, zn);
10809 (masm.*macro)(zd2, zn, imm);
10823 ASSERT_EQUAL_SVE(zn_copy, zn);
11322 // Make a copy so we can check that constructive operations preserve zn.
11410 // Make a copy so we can check that constructive operations preserve zn.
11479 // Make a copy so we can check that constructive operations preserve zn.
11551 // Make a copy so we can check that constructive operations preserve zn.
11626 const ZRegister& zn,
11632 __ Sdot(zd, za, zn, zm);
11634 __ Sdot(zd, za, zn, zm, index_fn);
11638 __ Udot(zd, za, zn, zm);
11640 __ Udot(zd, za, zn, zm, index_fn);
11647 ZRegister zn = z2.WithLaneSize(lane_size_in_bits / 4);
11652 InsrHelper(&masm, zn, zn_inputs);
11663 // zda = zda + (zn . zm)
11664 dot_fn(da_result, da_result, zn, zm, is_signed, index);
11666 __ Mov(dn_result, zn.WithSameLaneSizeAs(dn_result));
11668 dot_fn(dn_result, za, dn_result.WithSameLaneSizeAs(zn), zm, is_signed, index);
11671 // zdm = za + (zn . zdm)
11672 dot_fn(dm_result, za, zn, dm_result.WithSameLaneSizeAs(zm), is_signed, index);
11675 // zd = za + (zn . zm)
11676 dot_fn(d_result, za, zn, zm, is_signed, index);
11678 __ Mov(dnm_result, zn.WithSameLaneSizeAs(dnm_result));
11682 dnm_result.WithSameLaneSizeAs(zn),
12111 ZRegister zn = z30.WithLaneSize(lane_size_in_bits);
12120 InsrHelper(&masm, zn, zn_rawbits);
12123 (masm.*macro)(zd, zn, zm);
12269 const ZRegister& zn,
12276 const ZRegister& zn,
12297 ZRegister zn = z27.WithLaneSize(lane_size_in_bits);
12308 InsrHelper(&masm, zn, zn_inputs_rawbits);
12317 __ Mov(dn_result, zn);
12327 // `instr` zdm, pg, zn, zdm
12331 (masm.*macro)(dm_result, pg.Merging(), zn, dm_result, nan_option);
12333 (masm.*macro_nonan)(dm_result, pg.Merging(), zn, dm_result);
12337 // and movprfx + `instr` based on whether zd and zn registers are aliased.
12341 // `instr` zd, pg, zn, zm
12345 (masm.*macro)(d_result, pg.Merging(), zn, zm, nan_option);
12347 (masm.*macro_nonan)(d_result, pg.Merging(), zn, zm);
12694 ZRegister zn = z28.WithLaneSize(lane_size_in_bits);
12696 InsrHelper(&masm, zn, zn_inputs);
12698 __ Asr(zd_asr, zn, shift);
12699 __ Lsr(zd_lsr, zn, shift);
12700 __ Lsl(zd_lsl, zn, shift - 1); // Lsl supports 0 - lane_size-1.
12808 ZRegister zn = z27.WithLaneSize(lane_size_in_bits);
12811 InsrHelper(&masm, zn, zn_inputs);
12814 (masm.*macro)(zd, zn, zm);
12820 (masm.*macro)(zd_max_shift_amount, zn, zm_max_shift_amount);
12826 (masm.*macro)(zd_out_of_range, zn, zm_out_of_range);
15348 const ZRegister& zn);
15352 const ZRegister& zn);
15375 ZRegister zn = z27;
15379 InsrHelper(&masm, zn.WithLaneSize(lane_size_in_bits), zn_rawbits);
15387 zn.WithLaneSize(src_type_size_in_bits));
15394 // Use the same `zn` inputs to test floating-point conversions but partial
15398 zn.WithLaneSize(src_type_size_in_bits));
15408 zn.WithLaneSize(src_type_size_in_bits));
15932 ZRegister zn = z27;
15933 InsrHelper(&masm, zn.WithLaneSize(lane_size_in_bits), zn_inputs);
15941 zn.WithLaneSize(src_type_size_in_bits));
15944 zn.WithLaneSize(src_type_size_in_bits));
15967 // Use the same `zn` inputs to test integer conversions but some lanes are set
15971 zn.WithLaneSize(src_type_size_in_bits));
15974 zn.WithLaneSize(src_type_size_in_bits));
16635 const ZRegister& zn,
16658 ZRegister zn = z2.WithLaneSize(lane_size_in_bits);
16670 InsrHelper(&masm, zn, zn_rawbits);
16691 (masm.*macro)(da_result, p0.Merging(), da_result, zn, zm, nan_option);
16693 __ Mov(dn_result, zn);
16697 (masm.*macro)(dm_result, p0.Merging(), za, zn, dm_result, nan_option);
16700 (masm.*macro)(d_result, p0.Merging(), za, zn, zm, nan_option);
16708 ASSERT_EQUAL_SVE(zn_rawbits, zn);
16730 // fmla : zd = za + zn * zm
16781 // fmls : zd = za - zn * zm
16832 // fnmla : zd = -za - zn * zm
16883 // fnmls : zd = -za + zn * zm
16935 const ZRegister& zn,
16964 (masm.*macro_idx)(z4.VnH(), z2.VnH(), z4.VnH(), z0.VnH(), 1); // zd == zn
16974 (masm.*macro_idx)(z8.VnS(), z2.VnS(), z8.VnS(), z0.VnS(), 1); // zd == zn
16984 (masm.*macro_idx)(z12.VnD(), z2.VnD(), z12.VnD(), z0.VnD(), 1); // zd == zn
16988 // zd == zn == zm
17687 const ZRegister& zn,
17692 const ZRegister& zn,
17697 const ZRegister& zn,
17870 double zn[] = {0.0, inf_n, 1.0, inf_p, inf_p, nan, 0.0, nan};
17890 TestFpCompareHelper(config, lane_size, gt, zn, zm, pd_fcm_gt);
17891 TestFpCompareHelper(config, lane_size, lt, zn, zm, pd_fcm_lt);
17892 TestFpCompareHelper(config, lane_size, ge, zn, zm, pd_fcm_ge);
17893 TestFpCompareHelper(config, lane_size, le, zn, zm, pd_fcm_le);
17894 TestFpCompareHelper(config, lane_size, eq, zn, zm, pd_fcm_eq);
17895 TestFpCompareHelper(config, lane_size, ne, zn, zm, pd_fcm_ne);
17896 TestFpCompareHelper(config, lane_size, uo, zn, zm, pd_fcm_uo);
17899 TestFpCompareHelper(config, lane_size, gt, zn, zm, pd_fac_gt, true);
17900 TestFpCompareHelper(config, lane_size, lt, zn, zm, pd_fac_lt, true);
17901 TestFpCompareHelper(config, lane_size, ge, zn, zm, pd_fac_ge, true);
17902 TestFpCompareHelper(config, lane_size, le, zn, zm, pd_fac_le, true);
17915 ZRegister zn = z28.WithLaneSize(lane_size_in_bits);
17920 InsrHelper(&masm, zn, zn_rawbits);
17923 (masm.*GetFpCompareZeroFn(cond))(pd, p0.Zeroing(), zn, 0.0);
17997 const ZRegister& zn);
18001 const ZRegister& zn);
18035 // Make a copy so we can check that constructive operations preserve zn.
18095 // Check in-place operation where zd == zn.
18527 ZRegister zn = z0.WithLaneSize(esize_in_bits);
18541 (masm.*sve_ld1)(zn, pg, SVEMemOperand(x2, enablable_offset));
18582 ASSERT_EQUAL_SVE(zn_ref, zn);
18801 {8, // 2 * zn[11] * zm[8] = 2 * 4 * 1
18802 24, // 2 * zn[9] * zm[8] = 2 * 4 * 3
18803 80, // 2 * zn[7] * zm[4] = 2 * 8 * 5
18804 112, // 2 * zn[5] * zm[4] = 2 * 8 * 7
18805 0x7fffffffffffffff, // 2 * zn[3] * zm[0]
18806 0x8000000100000000}; // 2 * zn[1] * zm[0]
18858 {-11, // za.d[5] + 2 * zn.s[10] * zm.s[8] = 5 + 2 * -2 * 4
18859 -28, // za.d[4] + 2 * zn.s[8] * zm.s[8] = 4 + 2 * -4 * 4
18860 -93, // za.d[3] + 2 * zn.s[6] * zm.s[4] = 3 + 2 * -6 * 8
18861 -126, // za.d[2] + 2 * zn.s[4] * zm.s[4] = 2 + 2 * -8 * 8
18866 {1, // za.d[5] + 2 * zn.s[11] * zm.s[9] = -5 + 2 * 1 * 3
18867 14, // za.d[4] + 2 * zn.s[9] * zm.s[9] = -4 + 2 * 3 * 3
18868 67, // za.d[3] + 2 * zn.s[7] * zm.s[5] = -3 + 2 * 5 * 7
18869 96, // za.d[2] + 2 * zn.s[5] * zm.s[5] = -2 + 2 * 7 * 7