Lines Matching refs:vform

841 void Simulator::ExtractFromSimVRegister(VectorFormat vform,
847 vform,
1203 VectorFormat vform) {
1204 switch (vform) {
1247 VectorFormat vform) {
1248 switch (vform) {
2141 VectorFormat vform = instr->GetSVEVectorFormat();
2149 match(vform, pd, zn, zm, /* negate_match = */ false);
2152 match(vform, pd, zn, zm, /* negate_match = */ true);
2158 PredTest(vform, pg, pd);
2162 VectorFormat vform = instr->GetSVEVectorFormat();
2168 absdiff >>= LaneSizeInBytesLog2FromFormat(vform);
2183 for (int i = 0; i < LaneCountFromFormat(vform); i++) {
2184 dst.SetActive(vform,
2189 PredTest(vform, GetPTrue(), pd);
2233 VectorFormat vform = instr->GetSVEVectorFormat();
2240 if (vform == kFormatVnB) vform = kFormatVnH;
2247 dup_elements_to_segments(vform, temp, instr->GetSVEMulZmAndIndex());
2248 mul(vform, zd, zn, temp);
2252 VectorFormat vform = instr->GetSVEVectorFormat();
2259 if (vform == kFormatVnB) vform = kFormatVnH;
2267 dup_elements_to_segments(vform, temp, instr->GetSVEMulZmAndIndex());
2269 mla(vform, zda, zda, zn, temp);
2271 mls(vform, zda, zda, zn, temp);
2276 VectorFormat vform = instr->GetSVEVectorFormat();
2283 if (vform == kFormatVnB) {
2284 vform = kFormatVnH;
2288 dup_elements_to_segments(vform, temp, instr->GetSVEMulZmAndIndex());
2293 sqdmulh(vform, zd, zn, temp);
2298 sqrdmulh(vform, zd, zn, temp);
2306 VectorFormat vform = instr->GetSVEVectorFormat();
2315 VectorFormat vform_half = VectorFormatHalfWidth(vform);
2325 smull(vform, zd, zn_b, zm_idx);
2329 smull(vform, zd, zn_t, zm_idx);
2332 sqdmull(vform, zd, zn_b, zm_idx);
2335 sqdmull(vform, zd, zn_t, zm_idx);
2339 umull(vform, zd, zn_b, zm_idx);
2343 umull(vform, zd, zn_t, zm_idx);
2346 sqdmull(vform, zd, zn_b, zm_idx);
2349 sqdmull(vform, zd, zn_t, zm_idx);
2353 smlal(vform, zd, zn_b, zm_idx);
2357 smlal(vform, zd, zn_t, zm_idx);
2361 smlsl(vform, zd, zn_b, zm_idx);
2365 smlsl(vform, zd, zn_t, zm_idx);
2369 umlal(vform, zd, zn_b, zm_idx);
2373 umlal(vform, zd, zn_t, zm_idx);
2377 umlsl(vform, zd, zn_b, zm_idx);
2381 umlsl(vform, zd, zn_t, zm_idx);
2458 VectorFormat vform = instr->GetSVEVectorFormat();
2464 if (vform != kFormatVnS) {
2470 urecpe(vform, result, zn);
2473 ursqrte(vform, result, zn);
2478 mov_merging(vform, zd, pg, result);
2482 VectorFormat vform = instr->GetSVEVectorFormat();
2490 vform = instr->GetSVEVectorFormat(17);
2491 flogb(vform, result, zn);
2494 abs(vform, result, zn).SignedSaturate(vform);
2497 neg(vform, result, zn).SignedSaturate(vform);
2502 mov_merging(vform, zd, pg, result);
2506 VectorFormat vform = instr->GetSVEVectorFormat();
2514 if ((vform == kFormatVnS) || (vform == kFormatVnD)) {
2515 histogram(vform, result, pg, zn, zm);
2516 mov_zeroing(vform, zd, pg, result);
2523 VectorFormat vform = instr->GetSVEVectorFormat();
2532 bdep(vform, zd, zn, zm);
2538 bgrp(vform, zd, zn, zm, do_bext);
2541 rotate_elements_right(vform, result, zm, 1);
2543 mov_alternating(vform, zd, result, 0);
2546 rotate_elements_right(vform, result, zm, -1);
2548 mov_alternating(vform, zd, result, 1);
2551 mul(vform, zd, zn, zm);
2554 smulh(vform, zd, zn, zm);
2557 sqdmulh(vform, zd, zn, zm);
2560 sqrdmulh(vform, zd, zn, zm);
2563 umulh(vform, zd, zn, zm);
2571 VectorFormat vform = instr->GetSVEVectorFormat();
2577 VectorFormat vform_half = VectorFormatHalfWidth(vform);
2583 saddw(vform, zd, zn, zm_b);
2586 saddw(vform, zd, zn, zm_t);
2589 ssubw(vform, zd, zn, zm_b);
2592 ssubw(vform, zd, zn, zm_t);
2595 uaddw(vform, zd, zn, zm_b);
2598 uaddw(vform, zd, zn, zm_t);
2601 usubw(vform, zd, zn, zm_b);
2604 usubw(vform, zd, zn, zm_t);
2620 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(lane_size);
2628 sli(vform, zd, zn, shift_dist);
2631 sri(vform, zd, zn, shift_dist);
2648 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(lane_size);
2657 sqxtn(vform, result, zn);
2663 sqxtun(vform, result, zn);
2669 uqxtn(vform, result, zn);
2675 rshrn(vform, result, zn, right_shift_dist);
2681 shrn(vform, result, zn, right_shift_dist);
2687 sqrshrn(vform, result, zn, right_shift_dist);
2693 sqrshrun(vform, result, zn, right_shift_dist);
2699 sqshrn(vform, result, zn, right_shift_dist);
2705 sqshrun(vform, result, zn, right_shift_dist);
2711 uqrshrn(vform, result, zn, right_shift_dist);
2717 uqshrn(vform, result, zn, right_shift_dist);
2725 xtn(vform, zd, zd);
2726 zip1(vform, zd, zd, result);
2731 zip1(vform, zd, result, zero);
2736 VectorFormat vform = instr->GetSVEVectorFormat();
2744 VectorFormat vform_half = VectorFormatHalfWidth(vform);
2752 sabdl(vform, zd, zn_b, zm_b);
2755 sabdl(vform, zd, zn_t, zm_t);
2758 saddl(vform, zd, zn_b, zm_b);
2761 saddl(vform, zd, zn_b, zm_t);
2764 saddl(vform, zd, zn_t, zm_t);
2767 ssubl(vform, zd, zn_b, zm_b);
2770 ssubl(vform, zd, zn_b, zm_t);
2773 ssubl(vform, zd, zn_t, zm_t);
2776 ssubl(vform, zd, zn_t, zm_b);
2779 uabdl(vform, zd, zn_b, zm_b);
2782 uabdl(vform, zd, zn_t, zm_t);
2785 uaddl(vform, zd, zn_b, zm_b);
2788 uaddl(vform, zd, zn_t, zm_t);
2791 usubl(vform, zd, zn_b, zm_b);
2794 usubl(vform, zd, zn_t, zm_t);
2797 sabal(vform, zd, zn_b, zm_b);
2800 sabal(vform, zd, zn_t, zm_t);
2803 uabal(vform, zd, zn_b, zm_b);
2806 uabal(vform, zd, zn_t, zm_t);
2814 VectorFormat vform = instr->GetSVEVectorFormat();
2819 VectorFormat vform_half = VectorFormatHalfWidth(vform);
2828 if (vform == kFormatVnB) {
2831 pmull(vform, zd, zn_b, zm_b);
2835 if (vform == kFormatVnB) {
2838 pmull(vform, zd, zn_t, zm_t);
2841 smull(vform, zd, zn_b, zm_b);
2844 smull(vform, zd, zn_t, zm_t);
2847 sqdmull(vform, zd, zn_b, zm_b);
2850 sqdmull(vform, zd, zn_t, zm_t);
2853 umull(vform, zd, zn_b, zm_b);
2856 umull(vform, zd, zn_t, zm_t);
2874 VectorFormat vform = VectorFormatHalfWidth(vform_src);
2881 addhn(vform, result, zn, zm);
2887 raddhn(vform, result, zn, zm);
2893 rsubhn(vform, result, zn, zm);
2899 subhn(vform, result, zn, zm);
2907 xtn(vform, zd, zd);
2908 zip1(vform, zd, zd, result);
2913 zip1(vform, zd, result, zero);
2927 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(lane_size + 1);
2933 VectorFormat vform_half = VectorFormatHalfWidth(vform);
2939 sshll(vform, zd, zn_b, left_shift_dist);
2942 sshll(vform, zd, zn_t, left_shift_dist);
2945 ushll(vform, zd, zn_b, left_shift_dist);
2948 ushll(vform, zd, zn_t, left_shift_dist);
2956 VectorFormat vform = instr->GetSVEVectorFormat();
2974 vform = kFormatVnH;
2982 vform = kFormatVnS;
2990 vform = kFormatVnD;
3001 dup_elements_to_segments(vform, zm_idx, zm, index);
3005 sqrdmlah(vform, zda, zn, (index >= 0) ? zm_idx : zm);
3007 sqrdmlsh(vform, zda, zn, (index >= 0) ? zm_idx : zm);
3113 VectorFormat vform = instr->GetSVEVectorFormat();
3121 sadalp(vform, result, zn);
3124 uadalp(vform, result, zn);
3129 mov_merging(vform, zda, pg, result);
3133 VectorFormat vform = (instr->ExtractBit(22) == 0) ? kFormatVnS : kFormatVnD;
3139 not_(vform, not_zn, zn);
3143 adcl(vform, zda, zn, zm, /* top = */ false);
3146 adcl(vform, zda, zn, zm, /* top = */ true);
3149 adcl(vform, zda, not_zn, zm, /* top = */ false);
3152 adcl(vform, zda, not_zn, zm, /* top = */ true);
3160 VectorFormat vform = instr->GetSVEVectorFormat();
3167 saba(vform, zda, zn, zm);
3170 uaba(vform, zda, zn, zm);
3181 // vform and zm are only valid for the vector form of instruction.
3182 VectorFormat vform = instr->GetSVEVectorFormat();
3193 cmla(vform, zda, zda, zn, zm, rot);
3202 sqrdcmlah(vform, zda, zda, zn, zm, rot);
3224 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(lane_size);
3229 srsra(vform, zd, zn, shift_dist);
3232 ssra(vform, zd, zn, shift_dist);
3235 ursra(vform, zd, zn, shift_dist);
3238 usra(vform, zd, zn, shift_dist);
3246 VectorFormat vform = instr->GetSVEVectorFormat();
3254 VectorFormat vform_half = VectorFormatHalfWidth(vform);
3262 smlal(vform, zda, zn_b, zm_b);
3265 smlal(vform, zda, zn_t, zm_t);
3268 smlsl(vform, zda, zn_b, zm_b);
3271 smlsl(vform, zda, zn_t, zm_t);
3274 sqdmlal(vform, zda, zn_b, zm_b);
3277 sqdmlal(vform, zda, zn_b, zm_t);
3280 sqdmlal(vform, zda, zn_t, zm_t);
3283 sqdmlsl(vform, zda, zn_b, zm_b);
3286 sqdmlsl(vform, zda, zn_b, zm_t);
3289 sqdmlsl(vform, zda, zn_t, zm_t);
3292 umlal(vform, zda, zn_b, zm_b);
3295 umlal(vform, zda, zn_t, zm_t);
3298 umlsl(vform, zda, zn_b, zm_b);
3301 umlsl(vform, zda, zn_t, zm_t);
3309 VectorFormat vform = instr->GetSVEVectorFormat();
3334 if (index >= 0) dup_elements_to_segments(vform, temp, zm, index);
3335 cdot(vform, zda, zda, zn, (index >= 0) ? temp : zm, rot);
3339 VectorFormat vform = kFormatVnD;
3347 bic(vform, temp, zm, zk);
3348 eor(vform, zdn, temp, zdn);
3351 not_(vform, temp, zdn);
3352 bsl(vform, zdn, zk, temp, zm);
3355 not_(vform, temp, zm);
3356 bsl(vform, zdn, zk, zdn, temp);
3359 bsl(vform, zdn, zk, zdn, zm);
3362 eor(vform, temp, zdn, zm);
3363 eor(vform, zdn, temp, zk);
3366 bsl(vform, zdn, zk, zdn, zm);
3367 not_(vform, zdn, zdn);
3375 VectorFormat vform = instr->GetSVEVectorFormat();
3383 add(vform, result, zdn, zm).Halve(vform);
3386 sub(vform, result, zdn, zm).Halve(vform);
3389 sub(vform, result, zm, zdn).Halve(vform);
3392 add(vform, result, zdn, zm).Halve(vform).Round(vform);
3395 add(vform, result, zdn, zm).Uhalve(vform);
3398 sub(vform, result, zdn, zm).Uhalve(vform);
3401 sub(vform, result, zm, zdn).Uhalve(vform);
3404 add(vform, result, zdn, zm).Uhalve(vform).Round(vform);
3410 mov_merging(vform, zdn, pg, result);
3414 VectorFormat vform = instr->GetSVEVectorFormat();
3422 add(vform, result, zdn, zm).SignedSaturate(vform);
3425 sub(vform, result, zdn, zm).SignedSaturate(vform);
3428 sub(vform, result, zm, zdn).SignedSaturate(vform);
3431 suqadd(vform, result, zdn, zm);
3434 add(vform, result, zdn, zm).UnsignedSaturate(vform);
3437 sub(vform, result, zdn, zm).UnsignedSaturate(vform);
3440 sub(vform, result, zm, zdn).UnsignedSaturate(vform);
3443 usqadd(vform, result, zdn, zm);
3449 mov_merging(vform, zdn, pg, result);
3453 VectorFormat vform = instr->GetSVEVectorFormat();
3461 addp(vform, result, zdn, zm);
3464 smaxp(vform, result, zdn, zm);
3467 sminp(vform, result, zdn, zm);
3470 umaxp(vform, result, zdn, zm);
3473 uminp(vform, result, zdn, zm);
3479 mov_merging(vform, zdn, pg, result);
3483 VectorFormat vform = instr->GetSVEVectorFormat();
3491 faddp(vform, result, zdn, zm);
3494 fmaxnmp(vform, result, zdn, zm);
3497 fmaxp(vform, result, zdn, zm);
3500 fminnmp(vform, result, zdn, zm);
3503 fminp(vform, result, zdn, zm);
3508 mov_merging(vform, zdn, pg, result);
3518 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(lane_size);
3525 sqshl(vform, result, zdn, left_shift_dist);
3528 sqshlu(vform, result, zdn, left_shift_dist);
3531 sshr(vform, result, zdn, right_shift_dist).Round(vform);
3534 uqshl(vform, result, zdn, left_shift_dist);
3537 ushr(vform, result, zdn, right_shift_dist).Round(vform);
3542 mov_merging(vform, zdn, pg, result);
3555 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(lane_size);
3557 eor(vform, zdn, zdn, zm);
3558 ror(vform, zdn, zdn, shift_dist);
3562 VectorFormat vform = instr->GetSVEVectorFormat();
3569 cadd(vform, zdn, zdn, zm, rot);
3572 cadd(vform, zdn, zdn, zm, rot, /* saturate = */ true);
6331 VectorFormat vform;
6336 vform = kFormatD;
6339 vform = kFormatS;
6342 vform = kFormatH;
6367 fabs_(vform, ReadVRegister(fd), ReadVRegister(fn));
6369 LogVRegister(fd, GetPrintRegisterFormatFP(vform));
6374 fneg(vform, ReadVRegister(fd), ReadVRegister(fn));
6376 LogVRegister(fd, GetPrintRegisterFormatFP(vform));
6403 fsqrt(vform, rd, rn);
6405 LogVRegister(fd, GetPrintRegisterFormatFP(vform));
6468 frint(vform, rd, rn, fpcr_rounding, inexact_exception, frint_mode);
6470 LogVRegister(fd, GetPrintRegisterFormatFP(vform));
6477 VectorFormat vform;
6482 vform = kFormatD;
6485 vform = kFormatS;
6488 vform = kFormatH;
6499 fadd(vform, rd, rn, rm);
6504 fsub(vform, rd, rn, rm);
6509 fmul(vform, rd, rn, rm);
6514 fnmul(vform, rd, rn, rm);
6519 fdiv(vform, rd, rn, rm);
6524 fmax(vform, rd, rn, rm);
6529 fmin(vform, rd, rn, rm);
6534 fmaxnm(vform, rd, rn, rm);
6539 fminnm(vform, rd, rn, rm);
6545 LogVRegister(instr->GetRd(), GetPrintRegisterFormatFP(vform));
8002 VectorFormat vform = instr->GetNEONQ() ? kFormat4S : kFormat2S;
8012 fmlal(vform, rd, rn, rm, index);
8015 fmlal2(vform, rd, rn, rm, index);
8018 fmlsl(vform, rd, rn, rm, index);
8021 fmlsl2(vform, rd, rn, rm, index);
8033 VectorFormat vform = nfd.GetVectorFormat(&map);
8042 if ((vform == kFormat4H) || (vform == kFormat8H)) {
8044 } else if ((vform == kFormat2S) || (vform == kFormat4S)) {
8047 VIXL_ASSERT(vform == kFormat2D);
8057 fmul(vform, rd, rn, rm, index);
8061 fmla(vform, rd, rn, rm, index);
8065 fmls(vform, rd, rn, rm, index);
8069 fmulx(vform, rd, rn, rm, index);
8077 VectorFormat vform = instr->GetNEONQ() ? kFormat8H : kFormat4H;
8085 vform = kFormat4S;
8089 fcmla(vform, rd, rn, rm, index, instr->GetImmRotFcmlaSca());
8097 VectorFormat vform = instr->GetNEONQ() ? kFormat4S : kFormat2S;
8107 dup_elements_to_segments(VectorFormatFillQ(vform), temp, rm, index);
8111 sdot(vform, rd, rn, temp);
8114 udot(vform, rd, rn, temp);
8117 usdot(vform, rd, temp, rn);
8120 usdot(vform, rd, rn, temp);
8127 VectorFormat vform = nfd.GetVectorFormat();
8135 if ((vform == kFormat4H) || (vform == kFormat8H)) {
8144 mul(vform, rd, rn, rm, index);
8147 mla(vform, rd, rn, rm, index);
8150 mls(vform, rd, rn, rm, index);
8153 sqdmulh(vform, rd, rn, rm, index);
8156 sqrdmulh(vform, rd, rn, rm, index);
8159 sqrdmlah(vform, rd, rn, rm, index);
8162 sqrdmlsh(vform, rd, rn, rm, index);
8647 VectorFormat vform = kFormatUndefined;
8653 vform = (q == 1) ? kFormat4S : kFormat2S;
8658 vform = (q == 1) ? kFormat8H : kFormat4H;
8662 vform = (q == 1) ? kFormat4S : kFormat2S;
8671 vform = q ? kFormat16B : kFormat8B;
8674 vform = q ? kFormat2D : kFormat1D;
8683 vform = q ? kFormat8H : kFormat4H;
8686 vform = q ? kFormat4S : kFormat2S;
8689 vform = kFormat2D;
8732 orr(vform, rd, rd, imm);
8734 bic(vform, rd, rd, imm);
8736 movi(vform, rd, imm);
8738 mvni(vform, rd, imm);
9641 VectorFormat vform = kFormatVnD;
9642 mov(vform, temp, zm);
9646 sxt(vform, temp, temp, kSRegSize);
9649 uxt(vform, temp, temp, kSRegSize);
9652 vform = kFormatVnS;
9663 shl(vform, temp, temp, shift_amount);
9664 add(vform, zd, zn, temp);
9698 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(lane_size);
9699 dup_immediate(vform, ReadVRegister(instr->GetRd()), imm);
9768 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(lane_size);
9772 asrd(vform, result, zdn, shift_dist);
9778 dup_immediate(vform, scratch, shift_dist);
9779 SVEBitwiseShiftHelper(shift_op, vform, result, zdn, scratch, false);
9781 mov_merging(vform, zdn, pg, result);
9786 VectorFormat vform = instr->GetSVEVectorFormat();
9797 sshr(vform, result, zm, zdn);
9800 sshr(vform, result, zdn, zm);
9803 sshl(vform, result, zm, zdn, shift_in_ls_byte);
9806 sshl(vform, result, zdn, zm, shift_in_ls_byte);
9809 ushr(vform, result, zm, zdn);
9812 ushr(vform, result, zdn, zm);
9815 sshl(vform, result, zdn, zm, shift_in_ls_byte)
9816 .Round(vform)
9817 .SignedSaturate(vform);
9820 sshl(vform, result, zm, zdn, shift_in_ls_byte)
9821 .Round(vform)
9822 .SignedSaturate(vform);
9825 sshl(vform, result, zdn, zm, shift_in_ls_byte).SignedSaturate(vform);
9828 sshl(vform, result, zm, zdn, shift_in_ls_byte).SignedSaturate(vform);
9831 sshl(vform, result, zdn, zm, shift_in_ls_byte).Round(vform);
9834 sshl(vform, result, zm, zdn, shift_in_ls_byte).Round(vform);
9837 ushl(vform, result, zdn, zm, shift_in_ls_byte)
9838 .Round(vform)
9839 .UnsignedSaturate(vform);
9842 ushl(vform, result, zm, zdn, shift_in_ls_byte)
9843 .Round(vform)
9844 .UnsignedSaturate(vform);
9847 ushl(vform, result, zdn, zm, shift_in_ls_byte).UnsignedSaturate(vform);
9850 ushl(vform, result, zm, zdn, shift_in_ls_byte).UnsignedSaturate(vform);
9853 ushl(vform, result, zdn, zm, shift_in_ls_byte).Round(vform);
9856 ushl(vform, result, zm, zdn, shift_in_ls_byte).Round(vform);
9862 mov_merging(vform, zdn, pg, result);
9867 VectorFormat vform = instr->GetSVEVectorFormat();
9889 vform,
9894 mov_merging(vform, zdn, pg, result);
9929 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(lane_size);
9935 dup_immediate(vform, scratch, shift_dist);
9936 SVEBitwiseShiftHelper(shift_op, vform, zd, zn, scratch, false);
9958 VectorFormat vform = instr->GetSVEVectorFormat();
9961 int count = GetPredicateConstraintLaneCount(vform, pattern);
9989 VectorFormat vform = instr->GetSVEVectorFormat();
9990 if (LaneSizeInBitsFromFormat(vform) == kBRegSize) {
9995 int count = GetPredicateConstraintLaneCount(vform, pattern);
10016 dup_immediate(vform,
10020 LaneSizeInBitsFromFormat(vform)));
10021 add(vform, zd, zd, scratch);
10028 VectorFormat vform = instr->GetSVEVectorFormat();
10031 int count = GetPredicateConstraintLaneCount(vform, pattern);
10102 VectorFormat vform = instr->GetSVEVectorFormat();
10103 if (LaneSizeInBitsFromFormat(vform) == kBRegSize) {
10108 int count = GetPredicateConstraintLaneCount(vform, pattern);
10113 dup_immediate(vform,
10117 LaneSizeInBitsFromFormat(vform)));
10123 sub(vform, zd, zd, scratch).SignedSaturate(vform);
10128 add(vform, zd, zd, scratch).SignedSaturate(vform);
10133 sub(vform, zd, zd, scratch).UnsignedSaturate(vform);
10138 add(vform, zd, zd, scratch).UnsignedSaturate(vform);
10161 VectorFormat vform = instr->GetSVEVectorFormat();
10164 int count = GetPredicateConstraintLaneCount(vform, pattern);
10170 VectorFormat vform = instr->GetSVEVectorFormat();
10175 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
10179 fadda(vform, vdn, pg, zm);
10188 VectorFormat vform = instr->GetSVEVectorFormat();
10193 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
10198 fabd(vform, result, zdn, zm);
10201 fadd(vform, result, zdn, zm);
10204 fdiv(vform, result, zm, zdn);
10207 fdiv(vform, result, zdn, zm);
10210 fmaxnm(vform, result, zdn, zm);
10213 fmax(vform, result, zdn, zm);
10216 fminnm(vform, result, zdn, zm);
10219 fmin(vform, result, zdn, zm);
10222 fmulx(vform, result, zdn, zm);
10225 fmul(vform, result, zdn, zm);
10228 fscale(vform, result, zdn, zm);
10231 fsub(vform, result, zm, zdn);
10234 fsub(vform, result, zdn, zm);
10240 mov_merging(vform, zdn, pg, result);
10245 VectorFormat vform = instr->GetSVEVectorFormat();
10246 if (LaneSizeInBitsFromFormat(vform) == kBRegSize) {
10256 uint64_t half = FPToRawbitsWithSize(LaneSizeInBitsFromFormat(vform), 0.5);
10257 uint64_t one = FPToRawbitsWithSize(LaneSizeInBitsFromFormat(vform), 1.0);
10258 uint64_t two = FPToRawbitsWithSize(LaneSizeInBitsFromFormat(vform), 2.0);
10259 dup_immediate(vform, add_sub_imm, i1 ? one : half);
10260 dup_immediate(vform, min_max_imm, i1 ? one : 0);
10261 dup_immediate(vform, mul_imm, i1 ? two : half);
10265 fadd(vform, result, zdn, add_sub_imm);
10268 fmaxnm(vform, result, zdn, min_max_imm);
10271 fmax(vform, result, zdn, min_max_imm);
10274 fminnm(vform, result, zdn, min_max_imm);
10277 fmin(vform, result, zdn, min_max_imm);
10280 fmul(vform, result, zdn, mul_imm);
10283 fsub(vform, result, add_sub_imm, zdn);
10286 fsub(vform, result, zdn, add_sub_imm);
10292 mov_merging(vform, zdn, pg, result);
10296 VectorFormat vform = instr->GetSVEVectorFormat();
10300 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
10304 ftmad(vform, zd, zd, zm, instr->ExtractBits(18, 16));
10313 VectorFormat vform = instr->GetSVEVectorFormat();
10318 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
10322 fadd(vform, zd, zn, zm);
10325 fmul(vform, zd, zn, zm);
10328 frecps(vform, zd, zn, zm);
10331 frsqrts(vform, zd, zn, zm);
10334 fsub(vform, zd, zn, zm);
10337 ftsmul(vform, zd, zn, zm);
10350 VectorFormat vform = instr->GetSVEVectorFormat();
10353 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
10357 fabscmp(vform, result, zn, zm, ge);
10360 fabscmp(vform, result, zn, zm, gt);
10363 fcmp(vform, result, zn, zm, eq);
10366 fcmp(vform, result, zn, zm, ge);
10369 fcmp(vform, result, zn, zm, gt);
10372 fcmp(vform, result, zn, zm, ne);
10375 fcmp(vform, result, zn, zm, uo);
10382 ExtractFromSimVRegister(vform, pd, result);
10390 VectorFormat vform = instr->GetSVEVectorFormat();
10392 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
10400 fcmp(vform, result, zn, zeros, eq);
10403 fcmp(vform, result, zn, zeros, ge);
10406 fcmp(vform, result, zn, zeros, gt);
10409 fcmp(vform, result, zn, zeros, le);
10412 fcmp(vform, result, zn, zeros, lt);
10415 fcmp(vform, result, zn, zeros, ne);
10422 ExtractFromSimVRegister(vform, pd, result);
10427 VectorFormat vform = instr->GetSVEVectorFormat();
10429 if (LaneSizeInBitsFromFormat(vform) == kBRegSize) {
10442 fcadd(vform, result, zdn, zm, rot);
10448 mov_merging(vform, zdn, pg, result);
10452 VectorFormat vform = instr->GetSVEVectorFormat();
10454 if (LaneSizeInBitsFromFormat(vform) == kBRegSize) {
10468 fcmla(vform, result, zn, zm, zda, rot);
10474 mov_merging(vform, zda, pg, result);
10483 VectorFormat vform, vform_dup;
10487 vform = kFormatVnH;
10493 vform = kFormatVnS;
10506 fcmla(vform, zda, zn, temp, zda, rot);
10510 typedef LogicVRegister (Simulator::*FastReduceFn)(VectorFormat vform,
10515 VectorFormat vform = instr->GetSVEVectorFormat();
10519 int lane_size = LaneSizeInBitsFromFormat(vform);
10524 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
10552 dup_immediate(vform, scratch, inactive_value);
10553 mov_merging(vform, scratch, pg, zn);
10554 if (fn != nullptr) (this->*fn)(vform, vd, scratch);
10558 VectorFormat vform = kFormatUndefined;
10562 vform = kFormatVnD;
10566 vform = kFormatVnH;
10569 vform = kFormatVnS;
10580 dup_elements_to_segments(vform, temp, instr->GetSVEMulZmAndIndex());
10581 fmul(vform, zd, zn, temp);
10585 VectorFormat vform = instr->GetSVEVectorFormat();
10590 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
10600 fmla(vform, result, zd, zn, zm);
10604 fneg(vform, result, zd);
10605 fmls(vform, result, result, zn, zm);
10609 fmls(vform, result, zd, zn, zm);
10613 fneg(vform, result, zd);
10614 fmla(vform, result, result, zn, zm);
10628 fmla(vform, result, za, zd, zm);
10632 fneg(vform, result, za);
10633 fmls(vform, result, result, zd, zm);
10637 fmls(vform, result, za, zd, zm);
10641 fneg(vform, result, za);
10642 fmla(vform, result, result, zd, zm);
10650 mov_merging(vform, zd, pg, result);
10654 VectorFormat vform = kFormatUndefined;
10659 vform = kFormatVnD;
10663 vform = kFormatVnS;
10669 vform = kFormatVnH;
10680 dup_elements_to_segments(vform, temp, instr->GetSVEMulZmAndIndex());
10682 fmls(vform, zd, zd, zn, temp);
10684 fmla(vform, zd, zd, zn, temp);
10738 VectorFormat vform =
10742 fcvts(vform, dst_data_size, src_data_size, zd, pg, zn, FPZero);
10744 fcvtu(vform, dst_data_size, src_data_size, zd, pg, zn, FPZero);
10792 VectorFormat vform = instr->GetSVEVectorFormat();
10797 frecpx(vform, result, zn);
10800 fsqrt(vform, result, zn);
10806 mov_merging(vform, zd, pg, result);
10813 VectorFormat vform = instr->GetSVEVectorFormat();
10817 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
10846 frint(vform, result, zn, fpcr_rounding, exact_exception, kFrintToInteger);
10847 mov_merging(vform, zd, pg, result);
10901 VectorFormat vform =
10905 scvtf(vform, dst_data_size, src_data_size, zd, pg, zn, fpcr_rounding);
10907 ucvtf(vform, dst_data_size, src_data_size, zd, pg, zn, fpcr_rounding);
10912 VectorFormat vform = instr->GetSVEVectorFormat();
10917 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
10921 frecpe(vform, zd, zn, fpcr_rounding);
10924 frsqrte(vform, zd, zn);
10933 VectorFormat vform = instr->GetSVEVectorFormat();
10936 int count = CountActiveLanes(vform, pg);
10942 sub_uint(vform, zdn, zdn, count);
10945 add_uint(vform, zdn, zdn, count);
10948 sub_uint(vform, zdn, zdn, count).SignedSaturate(vform);
10951 add_uint(vform, zdn, zdn, count).SignedSaturate(vform);
10954 sub_uint(vform, zdn, zdn, count).UnsignedSaturate(vform);
10957 add_uint(vform, zdn, zdn, count).UnsignedSaturate(vform);
11049 VectorFormat vform = instr->GetSVEVectorFormat();
11060 index(vform, zd, start, step);
11070 VectorFormat vform = instr->GetSVEVectorFormat();
11076 add(vform, zd, zn, zm);
11079 add(vform, zd, zn, zm).SignedSaturate(vform);
11082 sub(vform, zd, zn, zm).SignedSaturate(vform);
11085 sub(vform, zd, zn, zm);
11088 add(vform, zd, zn, zm).UnsignedSaturate(vform);
11091 sub(vform, zd, zn, zm).UnsignedSaturate(vform);
11101 VectorFormat vform = instr->GetSVEVectorFormat();
11109 add(vform, result, zdn, zm);
11112 sub(vform, result, zm, zdn);
11115 sub(vform, result, zdn, zm);
11121 mov_merging(vform, zdn, pg, result);
11125 VectorFormat vform = instr->GetSVEVectorFormat();
11133 SVEBitwiseLogicalUnpredicatedHelper(AND, vform, result, zdn, zm);
11136 SVEBitwiseLogicalUnpredicatedHelper(BIC, vform, result, zdn, zm);
11139 SVEBitwiseLogicalUnpredicatedHelper(EOR, vform, result, zdn, zm);
11142 SVEBitwiseLogicalUnpredicatedHelper(ORR, vform, result, zdn, zm);
11148 mov_merging(vform, zdn, pg, result);
11152 VectorFormat vform = instr->GetSVEVectorFormat();
11160 mul(vform, result, zdn, zm);
11163 smulh(vform, result, zdn, zm);
11166 umulh(vform, result, zdn, zm);
11172 mov_merging(vform, zdn, pg, result);
11177 VectorFormat vform = instr->GetSVEVectorFormat();
11185 absdiff(vform, result, zdn, zm, true);
11188 smax(vform, result, zdn, zm);
11191 smin(vform, result, zdn, zm);
11194 absdiff(vform, result, zdn, zm, false);
11197 umax(vform, result, zdn, zm);
11200 umin(vform, result, zdn, zm);
11206 mov_merging(vform, zdn, pg, result);
11210 VectorFormat vform = instr->GetSVEVectorFormat();
11216 dup_immediate(vform, scratch, instr->GetImmSVEIntWideSigned());
11217 mul(vform, zd, zd, scratch);
11226 VectorFormat vform = instr->GetSVEVectorFormat();
11232 VIXL_ASSERT((vform == kFormatVnS) || (vform == kFormatVnD));
11236 sdiv(vform, result, zm, zdn);
11239 sdiv(vform, result, zdn, zm);
11242 udiv(vform, result, zm, zdn);
11245 udiv(vform, result, zdn, zm);
11251 mov_merging(vform, zdn, pg, result);
11255 VectorFormat vform = instr->GetSVEVectorFormat();
11264 dup_immediate(vform, scratch, signed_imm);
11265 smax(vform, zd, zd, scratch);
11268 dup_immediate(vform, scratch, signed_imm);
11269 smin(vform, zd, zd, scratch);
11272 dup_immediate(vform, scratch, unsigned_imm);
11273 umax(vform, zd, zd, scratch);
11276 dup_immediate(vform, scratch, unsigned_imm);
11277 umin(vform, zd, zd, scratch);
11290 VectorFormat vform = instr->GetSVEVectorFormat();
11305 int lane_count = LaneCountFromFormat(vform);
11344 dst.SetActive(vform, lane, last);
11348 PredTest(vform, GetPTrue(), pd);
11405 VectorFormat vform = instr->GetSVEVectorFormat();
11407 dup_immediate(vform,
11411 vform,
11443 VectorFormat vform = instr->GetSVEVectorFormat();
11445 dup_immediate(vform, src2, instr->ExtractBits(20, 14));
11447 vform,
11528 VectorFormat vform = instr->GetSVEVectorFormat();
11532 VIXL_ASSERT((vform == kFormatVnH) || (vform == kFormatVnS) ||
11533 (vform == kFormatVnD));
11537 fexpa(vform, zd, zn);
11546 VectorFormat vform = instr->GetSVEVectorFormat();
11551 VIXL_ASSERT((vform == kFormatVnH) || (vform == kFormatVnS) ||
11552 (vform == kFormatVnD));
11556 ftssel(vform, zd, zn, zm);
11580 VectorFormat vform = instr->GetSVEVectorFormat();
11588 mla(vform, result, zd, ReadVRegister(instr->GetRn()), zm);
11591 mls(vform, result, zd, ReadVRegister(instr->GetRn()), zm);
11595 mla(vform, result, ReadVRegister(instr->GetRn()), zd, zm);
11599 mls(vform, result, ReadVRegister(instr->GetRn()), zd, zm);
11606 mov_merging(vform, zd, ReadPRegister(instr->GetPgLow8()), result);
11610 VectorFormat vform = instr->GetSVEVectorFormat();
11617 sdot(vform, zda, zn, zm);
11620 udot(vform, zda, zn, zm);
11623 usdot(vform, zda, zn, zm);
11632 VectorFormat vform = instr->GetSVEVectorFormat();
11640 mov_merging(vform, zd, pg, zn);
11642 mov_zeroing(vform, zd, pg, zn);
11652 VectorFormat vform = instr->GetSVEVectorFormat();
11660 andv(vform, vd, pg, zn);
11663 eorv(vform, vd, pg, zn);
11666 orv(vform, vd, pg, zn);
11675 saddv(vform, vd, pg, zn);
11678 smaxv(vform, vd, pg, zn);
11681 sminv(vform, vd, pg, zn);
11684 uaddv(vform, vd, pg, zn);
11687 umaxv(vform, vd, pg, zn);
11690 uminv(vform, vd, pg, zn);
11700 VectorFormat vform = instr->GetSVEVectorFormat();
11706 abs(vform, result, zn);
11709 cls(vform, result, zn);
11712 clz(vform, result, zn);
11715 cnot(vform, result, zn);
11718 cnt(vform, result, zn);
11721 fabs_(vform, result, zn);
11724 fneg(vform, result, zn);
11727 neg(vform, result, zn);
11730 not_(vform, result, zn);
11735 sxt(vform, result, zn, (kBitsPerByte << instr->ExtractBits(18, 17)));
11740 uxt(vform, result, zn, (kBitsPerByte << instr->ExtractBits(18, 17)));
11749 mov_merging(vform, zd, pg, result);
11756 VectorFormat vform = instr->GetSVEVectorFormat();
11760 if (vform == kFormatVnB) VIXL_UNIMPLEMENTED();
11766 uint64_t value = FPToRawbitsWithSize(LaneSizeInBitsFromFormat(vform),
11768 dup_immediate(vform, result, value);
11775 mov_merging(vform, zd, pg, result);
11780 VectorFormat vform = instr->GetSVEVectorFormat();
11789 add_uint(vform, zd, zd, imm);
11792 add_uint(vform, zd, zd, imm).SignedSaturate(vform);
11795 sub_uint(vform, zd, zd, imm).SignedSaturate(vform);
11798 dup_immediate(vform, scratch, imm);
11799 sub(vform, zd, scratch, zd);
11802 sub_uint(vform, zd, zd, imm);
11805 add_uint(vform, zd, zd, imm).UnsignedSaturate(vform);
11808 sub_uint(vform, zd, zd, imm).UnsignedSaturate(vform);
11839 VectorFormat vform = instr->GetSVEVectorFormat();
11844 switch (vform) {
11846 dup_immediate(vform, zd, Float16ToRawbits(instr->GetSVEImmFP16()));
11849 dup_immediate(vform, zd, FloatToRawbits(instr->GetSVEImmFP32()));
11852 dup_immediate(vform, zd, DoubleToRawbits(instr->GetSVEImmFP64()));
12057 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(esize_in_bytes_log2);
12063 ld1r(vform, unpack_vform, temp, base, is_signed);
12064 mov_zeroing(vform,
12336 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(esize_in_bytes_log2);
12342 SVEFaultTolerantLoadHelper(vform,
12380 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(esize_in_bytes_log2);
12388 SVEFaultTolerantLoadHelper(vform,
12399 VectorFormat vform = kFormatUndefined;
12403 vform = kFormatVnB;
12406 vform = kFormatVnD;
12409 vform = kFormatVnH;
12412 vform = kFormatVnS;
12418 int msize_in_bytes_log2 = LaneSizeInBytesLog2FromFormat(vform);
12424 SVEStructuredLoadHelper(vform,
12434 VectorFormat vform = kFormatUndefined;
12438 vform = kFormatVnB;
12441 vform = kFormatVnD;
12444 vform = kFormatVnH;
12447 vform = kFormatVnS;
12453 int msize_in_bytes_log2 = LaneSizeInBytesLog2FromFormat(vform);
12458 SVEStructuredLoadHelper(vform,
12484 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(msz);
12489 mov_zeroing(vform, zt, pg, zt);
12511 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(msz);
12516 mov_zeroing(vform, zt, pg, zt);
12572 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(msz);
12577 SVEStructuredLoadHelper(vform,
12824 VectorFormat vform = kFormatUndefined;
12828 vform = kFormatVnB;
12831 vform = kFormatVnD;
12834 vform = kFormatVnH;
12837 vform = kFormatVnS;
12843 int msize_in_bytes_log2 = LaneSizeInBytesLog2FromFormat(vform);
12849 SVEStructuredStoreHelper(vform, pg, instr->GetRt(), addr);
12855 VectorFormat vform = kFormatUndefined;
12859 vform = kFormatVnB;
12862 vform = kFormatVnD;
12865 vform = kFormatVnH;
12868 vform = kFormatVnS;
12874 int msize_in_bytes_log2 = LaneSizeInBytesLog2FromFormat(vform);
12879 SVEStructuredStoreHelper(vform, pg, instr->GetRt(), addr);
12897 VectorFormat vform =
12901 SVEStructuredStoreHelper(vform,
12923 VectorFormat vform =
12927 SVEStructuredStoreHelper(vform,
12941 VectorFormat vform = instr->GetSVEVectorFormat();
12947 dup_element(vform, z_result, ReadVRegister(instr->GetRn()), 0);
12948 mov_merging(vform, ReadVRegister(instr->GetRd()), pg, z_result);
13008 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(msz);
13013 SVEStructuredStoreHelper(vform,
13068 VectorFormat vform = instr->GetSVEVectorFormat();
13076 dup_elements_to_segments(vform, temp, zm, index);
13081 sdot(vform, zda, zn, temp);
13085 udot(vform, zda, zn, temp);
13088 usdot(vform, zda, temp, zn);
13091 usdot(vform, zda, zn, temp);
13100 VectorFormat vform = kFormatVnS;
13109 vform = kFormat4S;
13115 vform = kFormat4S;
13121 vform = kFormat4S;
13130 matmul(vform, dn, n, m, n_signed, m_signed);
13134 VectorFormat vform = instr->GetSVEVectorFormat();
13142 fmatmul(vform, zdn, zn, zm);
13228 VectorFormat vform = instr->GetSVEVectorFormat();
13238 trn1(vform, temp0, temp0, temp1);
13241 trn2(vform, temp0, temp0, temp1);
13244 uzp1(vform, temp0, temp0, temp1);
13247 uzp2(vform, temp0, temp0, temp1);
13250 zip1(vform, temp0, temp0, temp1);
13253 zip2(vform, temp0, temp0, temp1);
13265 VectorFormat vform = instr->GetSVEVectorFormat();
13269 rev(vform, temp, temp);
13299 VectorFormat vform = instr->GetSVEVectorFormat();
13306 trn1(vform, zd, zn, zm);
13309 trn2(vform, zd, zn, zm);
13312 uzp1(vform, zd, zn, zm);
13315 uzp2(vform, zd, zn, zm);
13318 zip1(vform, zd, zn, zm);
13321 zip2(vform, zd, zn, zm);
13331 VectorFormat vform = instr->GetSVEVectorFormat();
13350 std::pair<bool, uint64_t> value = clast(vform, pg, zm, active_offset);
13352 dup_immediate(vform, zdn, value.second);
13356 mov(vform, zdn, zdn);
13363 VectorFormat vform = instr->GetSVEVectorFormat();
13383 uint64_t src1_value = dst.Uint(vform, 0);
13384 std::pair<bool, uint64_t> src2_value = clast(vform, pg, zm, active_offset);
13385 dup_immediate(vform, vdn, 0);
13386 dst.SetUint(vform, 0, src2_value.first ? src2_value.second : src1_value);
13392 VectorFormat vform = instr->GetSVEVectorFormat();
13410 std::pair<bool, uint64_t> value = clast(vform, pg, zm, active_offset);
13412 GetUintMask(LaneSizeInBitsFromFormat(vform));
13419 VectorFormat vform = instr->GetSVEVectorFormat();
13439 std::pair<bool, uint64_t> value = clast(vform, pg, zm, active_offset);
13440 dup_immediate(vform, vdn, 0);
13441 dst.SetUint(vform, 0, value.second);
13447 VectorFormat vform = instr->GetSVEVectorFormat();
13465 std::pair<bool, uint64_t> value = clast(vform, pg, zm, active_offset);
13471 VectorFormat vform = instr->GetSVEVectorFormat();
13478 compact(vform, zd, pg, zn);
13488 VectorFormat vform = instr->GetSVEVectorFormat();
13494 dup_immediate(vform,
13497 mov_merging(vform, ReadVRegister(instr->GetRd()), pg, z_result);
13506 VectorFormat vform = instr->GetSVEVectorFormat();
13515 dup_immediate(vform, result, imm8 << (instr->ExtractBit(13) * 8));
13524 mov_merging(vform, zd, pg, result);
13526 mov_zeroing(vform, zd, pg, result);
13586 VectorFormat vform = instr->GetSVEVectorFormat();
13594 splice(vform, zd, pg, zd, zn);
13597 splice(vform, zd, pg, zn, zn2);
13621 VectorFormat vform = instr->GetSVEVectorFormat();
13624 insr(vform, zd, ReadDRegisterBits(instr->GetRn()));
13634 VectorFormat vform = instr->GetSVEVectorFormat();
13637 insr(vform, zd, ReadXRegister(instr->GetRn()));
13653 VectorFormat vform =
13655 if ((index < 0) || (index >= LaneCountFromFormat(vform))) {
13659 dup_element(vform, zd, ReadVRegister(instr->GetRn()), index);
13671 VectorFormat vform = instr->GetSVEVectorFormat();
13674 rev(vform, zd, ReadVRegister(instr->GetRn()));
13684 VectorFormat vform = instr->GetSVEVectorFormat();
13687 unpk(vform, zd, ReadVRegister(instr->GetRn()), kHiHalf, kSignedExtend);
13690 unpk(vform, zd, ReadVRegister(instr->GetRn()), kLoHalf, kSignedExtend);
13693 unpk(vform, zd, ReadVRegister(instr->GetRn()), kHiHalf, kUnsignedExtend);
13696 unpk(vform, zd, ReadVRegister(instr->GetRn()), kLoHalf, kUnsignedExtend);
13705 VectorFormat vform = instr->GetSVEVectorFormat();
13713 tbl(vform, zd, zn, zm);
13716 tbl(vform, zd, zn, zn2, zm);
13719 tbx(vform, zd, zn, zm);
13728 VectorFormat vform = instr->GetSVEVectorFormat();
13734 WriteXRegister(instr->GetRd(), CountActiveAndTrueLanes(vform, pg, pn));
13808 VectorFormat vform = instr->GetSVEVectorFormat();
13810 ptrue(vform, pdn, instr->GetImmSVEPredicateConstraint());
13811 if (instr->ExtractBit(16)) PredTest(vform, pdn, pdn);
13821 VectorFormat vform = instr->GetSVEVectorFormat();
13823 pnext(vform, pdn, pg, pdn);
13825 PredTest(vform, pg, pdn);
13957 VectorFormat vform = instr->GetSVEVectorFormat();
13963 sel(vform, zd, pg, zn, zm);
14039 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(esize_in_bytes_log2);
14042 SVEStructuredLoadHelper(vform,
14083 VectorFormat vform = SVEFormatFromLaneSizeInBytesLog2(esize_in_bytes_log2);
14089 SVEStructuredLoadHelper(vform,