Lines Matching defs:movprfx
70 const Instruction* movprfx = pair;
79 can_take_movprfx != candidate->CanTakeSVEMovprfx(form.c_str(), movprfx);
85 printf("# ERROR: Expected %sCanTakeSVEMovprfx(movprfx):\n",
98 // Test that CanTakeSVEMovprfx() checks that the movprfx destination does not
103 // We have to use the Assembler directly to generate movprfx, so we need
108 __ movprfx(z0.VnB(), p0.Merging(), z9.VnB());
111 __ movprfx(z1, z17);
114 __ movprfx(z12, z13);
117 __ movprfx(z2, z4);
120 __ movprfx(z10, z18);
123 __ movprfx(z17.VnD(), p5.Zeroing(), z20.VnD());
126 __ movprfx(z22, z9);
129 __ movprfx(z0.VnS(), p6.Zeroing(), z6.VnS());
132 __ movprfx(z12, z16);
135 __ movprfx(z7, z15);
138 __ movprfx(z10, z29);
141 __ movprfx(z6, z13);
144 __ movprfx(z14.VnS(), p6.Zeroing(), z3.VnS());
147 __ movprfx(z5.VnD(), p6.Merging(), z4.VnD());
150 __ movprfx(z19.VnB(), p6.Zeroing(), z4.VnB());
153 __ movprfx(z27, z2);
156 __ movprfx(z4.VnS(), p1.Zeroing(), z22.VnS());
159 __ movprfx(z4, z5);
162 __ movprfx(z11.VnD(), p4.Merging(), z29.VnD());
165 __ movprfx(z12.VnD(), p6.Merging(), z3.VnD());
168 __ movprfx(z7, z2);
171 __ movprfx(z25.VnH(), p6.Merging(), z28.VnH());
174 __ movprfx(z14.VnD(), p6.Merging(), z6.VnD());
177 __ movprfx(z26.VnH(), p6.Zeroing(), z27.VnH());
180 __ movprfx(z17.VnS(), p4.Zeroing(), z29.VnS());
183 __ movprfx(z7, z17);
186 __ movprfx(z11, z7);
189 __ movprfx(z7, z5);
192 __ movprfx(z1.VnH(), p0.Merging(), z17.VnH());
195 __ movprfx(z22.VnB(), p3.Merging(), z18.VnB());
198 __ movprfx(z7.VnS(), p0.Merging(), z10.VnS());
201 __ movprfx(z12, z6);
204 __ movprfx(z8.VnB(), p4.Merging(), z3.VnB());
207 __ movprfx(z9, z26);
210 __ movprfx(z16, z8);
213 __ movprfx(z25.VnH(), p5.Zeroing(), z11.VnH());
216 __ movprfx(z17.VnH(), p1.Merging(), z22.VnH());
219 __ movprfx(z11, z25);
222 __ movprfx(z13, z27);
225 __ movprfx(z30.VnD(), p6.Merging(), z20.VnD());
228 __ movprfx(z2.VnD(), p2.Merging(), z21.VnD());
231 __ movprfx(z0, z7);
234 __ movprfx(z19, z28);
237 __ movprfx(z5, z18);
240 __ movprfx(z15, z11);
243 __ movprfx(z30, z13);
246 __ movprfx(z8, z9);
249 __ movprfx(z23, z14);
252 __ movprfx(z26, z5);
255 __ movprfx(z14, z15);
258 __ movprfx(z26.VnS(), p0.Merging(), z10.VnS());
261 __ movprfx(z22, z18);
264 __ movprfx(z8, z19);
267 __ movprfx(z23.VnH(), p6.Zeroing(), z2.VnH());
270 __ movprfx(z25.VnS(), p2.Merging(), z21.VnS());
273 __ movprfx(z28, z31);
276 __ movprfx(z14.VnD(), p6.Merging(), z17.VnD());
279 __ movprfx(z21.VnD(), p0.Zeroing(), z28.VnD());
282 __ movprfx(z25, z30);
285 __ movprfx(z13.VnD(), p2.Merging(), z30.VnD());
288 __ movprfx(z19.VnD(), p4.Zeroing(), z6.VnD());
291 __ movprfx(z1, z20);
294 __ movprfx(z8, z2);
297 __ movprfx(z28, z10);
300 __ movprfx(z21, z11);
303 __ movprfx(z1, z22);
306 __ movprfx(z8, z23);
309 __ movprfx(z10.VnB(), p5.Zeroing(), z0.VnB());
312 __ movprfx(z0.VnS(), p2.Zeroing(), z30.VnS());
315 __ movprfx(z26.VnD(), p6.Zeroing(), z29.VnD());
318 __ movprfx(z23, z25);
321 __ movprfx(z14.VnS(), p3.Zeroing(), z5.VnS());
324 __ movprfx(z14, z5);
327 __ movprfx(z22, z5);
330 __ movprfx(z1, z5);
333 __ movprfx(z30, z5);
336 __ movprfx(z4, z5);
339 __ movprfx(z10, z5);
342 __ movprfx(z1, z5);
351 // Test that CanTakeSVEMovprfx() checks that the movprfx destination does not
358 // We have to use the Assembler directly to generate movprfx, so we need
363 __ movprfx(z17.VnS(), p1.Zeroing(), z12.VnS());
366 __ movprfx(z13, z23);
369 __ movprfx(z24.VnS(), p5.Merging(), z15.VnS());
372 __ movprfx(z28.VnD(), p5.Zeroing(), z14.VnD());
375 __ movprfx(z5, z0);
378 __ movprfx(z10, z4);
381 __ movprfx(z12, z26);
384 __ movprfx(z8, z1);
387 __ movprfx(z16.VnD(), p0.Merging(), z13.VnD());
390 __ movprfx(z12.VnD(), p7.Zeroing(), z13.VnD());
393 __ movprfx(z14, z26);
396 __ movprfx(z26, z2);
399 __ movprfx(z25.VnD(), p2.Merging(), z13.VnD());
402 __ movprfx(z31, z2);
405 __ movprfx(z21.VnD(), p1.Merging(), z7.VnD());
408 __ movprfx(z5, z17);
411 __ movprfx(z19.VnD(), p1.Zeroing(), z16.VnD());
414 __ movprfx(z2.VnH(), p7.Zeroing(), z28.VnH());
417 __ movprfx(z21.VnD(), p7.Zeroing(), z27.VnD());
420 __ movprfx(z22.VnD(), p4.Zeroing(), z8.VnD());
423 __ movprfx(z0.VnS(), p5.Merging(), z5.VnS());
426 __ movprfx(z12, z24);
429 __ movprfx(z14.VnD(), p6.Zeroing(), z21.VnD());
432 __ movprfx(z2.VnS(), p5.Zeroing(), z10.VnS());
435 __ movprfx(z24, z5);
438 __ movprfx(z15.VnD(), p2.Merging(), z26.VnD());
441 __ movprfx(z20, z22);
444 __ movprfx(z24.VnS(), p6.Zeroing(), z30.VnS());
447 __ movprfx(z4, z24);
450 __ movprfx(z4, z7);
453 __ movprfx(z5, z28);
456 __ movprfx(z24, z2);
459 __ movprfx(z7, z21);
462 __ movprfx(z25.VnH(), p5.Zeroing(), z29.VnH());
465 __ movprfx(z31, z25);
468 __ movprfx(z15, z4);
471 __ movprfx(z7, z11);
474 __ movprfx(z3, z10);
477 __ movprfx(z5, z16);
480 __ movprfx(z31, z26);
483 __ movprfx(z5.VnH(), p3.Merging(), z2.VnH());
486 __ movprfx(z22.VnS(), p3.Zeroing(), z17.VnS());
489 __ movprfx(z17, z2);
492 __ movprfx(z28, z11);
495 __ movprfx(z15.VnD(), p1.Merging(), z31.VnD());
498 __ movprfx(z21.VnD(), p0.Zeroing(), z5.VnD());
501 __ movprfx(z0.VnH(), p3.Merging(), z31.VnH());
504 __ movprfx(z31.VnH(), p6.Merging(), z8.VnH());
507 __ movprfx(z17.VnH(), p1.Zeroing(), z10.VnH());
510 __ movprfx(z22, z31);
513 __ movprfx(z14.VnD(), p0.Zeroing(), z26.VnD());
516 __ movprfx(z13.VnH(), p6.Zeroing(), z29.VnH());
519 __ movprfx(z19.VnH(), p7.Zeroing(), z25.VnH());
522 __ movprfx(z27.VnH(), p5.Merging(), z24.VnH());
525 __ movprfx(z6.VnH(), p6.Zeroing(), z21.VnH());
528 __ movprfx(z7.VnS(), p3.Merging(), z23.VnS());
531 __ movprfx(z29.VnH(), p2.Zeroing(), z24.VnH());
534 __ movprfx(z7.VnH(), p6.Merging(), z23.VnH());
537 __ movprfx(z17.VnS(), p5.Zeroing(), z2.VnS());
540 __ movprfx(z0.VnS(), p2.Zeroing(), z7.VnS());
543 __ movprfx(z8.VnH(), p3.Merging(), z20.VnH());
546 __ movprfx(z3.VnD(), p2.Zeroing(), z20.VnD());
549 __ movprfx(z11, z3);
552 __ movprfx(z23, z29);
555 __ movprfx(z4.VnH(), p4.Zeroing(), z14.VnH());
558 __ movprfx(z18.VnH(), p3.Zeroing(), z0.VnH());
561 __ movprfx(z2.VnS(), p6.Zeroing(), z4.VnS());
564 __ movprfx(z14.VnD(), p4.Zeroing(), z31.VnD());
567 __ movprfx(z31.VnH(), p2.Merging(), z6.VnH());
570 __ movprfx(z4, z30);
573 __ movprfx(z25.VnD(), p6.Zeroing(), z2.VnD());
576 __ movprfx(z0.VnD(), p3.Merging(), z16.VnD());
579 __ movprfx(z19, z23);
582 __ movprfx(z19, z4);
585 __ movprfx(z13.VnD(), p4.Zeroing(), z6.VnD());
588 __ movprfx(z6.VnH(), p0.Zeroing(), z14.VnH());
591 __ movprfx(z19.VnS(), p4.Merging(), z12.VnS());
594 __ movprfx(z0.VnD(), p5.Zeroing(), z12.VnD());
597 __ movprfx(z30, z5);
600 __ movprfx(z31, z5);
612 // We have to use the Assembler directly to generate movprfx, so we need
617 __ movprfx(z26, z11);
620 // The merging form can take movprfx, but the zeroing form cannot.
621 __ movprfx(z29.VnB(), p3.Zeroing(), z7.VnB());
624 // Frecpx can take movprfx, but frecpe and frecps cannot.
625 __ movprfx(z13, z15);
628 __ movprfx(z19, z1);
631 __ movprfx(z6, z12);
634 __ movprfx(z29, z5);
637 // Ftmad can take movprfx, but ftsmul and ftssel cannot.
638 __ movprfx(z1, z31);
641 __ movprfx(z8, z27);
646 __ movprfx(z0, z18);
649 // The merging form can take movprfx, but the zeroing form cannot.
650 __ movprfx(z12.VnS(), p2.Merging(), z11.VnS());
653 __ movprfx(z13, z6);
654 __ movprfx(z13, z2);
657 __ movprfx(z3.VnD(), p5.Zeroing(), z8.VnD());
658 __ movprfx(z3.VnD(), p5.Merging(), z8.VnD());
660 __ movprfx(z1.VnD(), p3.Zeroing(), z14.VnD());
661 __ movprfx(z1.VnD(), p3.Zeroing(), z18.VnD());
669 // Test that CanTakeSVEMovprfx() checks that the (predicated) movprfx lane
674 // We have to use the Assembler directly to generate movprfx, so we need
679 __ movprfx(z0.VnH(), p2.Zeroing(), z17.VnH());
682 __ movprfx(z10.VnD(), p0.Zeroing(), z4.VnD());
685 __ movprfx(z25.VnS(), p4.Zeroing(), z26.VnS());
688 __ movprfx(z26.VnD(), p5.Merging(), z23.VnD());
691 __ movprfx(z25.VnS(), p7.Zeroing(), z14.VnS());
694 __ movprfx(z12.VnS(), p7.Zeroing(), z23.VnS());
697 __ movprfx(z3.VnH(), p4.Zeroing(), z18.VnH());
700 __ movprfx(z29.VnH(), p4.Merging(), z31.VnH());
703 __ movprfx(z31.VnH(), p5.Zeroing(), z14.VnH());
706 __ movprfx(z0.VnS(), p6.Zeroing(), z18.VnS());
709 __ movprfx(z19.VnH(), p2.Zeroing(), z24.VnH());
712 __ movprfx(z14.VnS(), p5.Zeroing(), z4.VnS());
715 __ movprfx(z0.VnD(), p5.Merging(), z2.VnD());
718 __ movprfx(z0.VnB(), p3.Zeroing(), z19.VnB());
721 __ movprfx(z29.VnS(), p0.Merging(), z7.VnS());
724 __ movprfx(z13.VnB(), p2.Merging(), z31.VnB());
727 __ movprfx(z0.VnS(), p3.Merging(), z15.VnS());
730 __ movprfx(z2.VnD(), p6.Zeroing(), z26.VnD());
733 __ movprfx(z7.VnS(), p7.Zeroing(), z30.VnS());
736 __ movprfx(z11.VnH(), p3.Merging(), z23.VnH());
739 __ movprfx(z31.VnS(), p7.Zeroing(), z21.VnS());
742 __ movprfx(z26.VnH(), p0.Merging(), z0.VnH());
745 __ movprfx(z1.VnS(), p2.Zeroing(), z6.VnS());
748 __ movprfx(z4.VnD(), p4.Zeroing(), z6.VnD());
751 __ movprfx(z27.VnH(), p0.Zeroing(), z29.VnH());
754 __ movprfx(z5.VnD(), p2.Zeroing(), z16.VnD());
757 __ movprfx(z27.VnB(), p4.Zeroing(), z5.VnB());
760 __ movprfx(z27.VnS(), p3.Merging(), z13.VnS());
763 __ movprfx(z30.VnS(), p2.Zeroing(), z14.VnS());
766 __ movprfx(z14.VnB(), p6.Merging(), z11.VnB());
769 __ movprfx(z28.VnH(), p2.Zeroing(), z22.VnH());
773 __ movprfx(z18.VnH(), p6.Zeroing(), z25.VnH());
776 __ movprfx(z22.VnD(), p2.Zeroing(), z6.VnD());
779 __ movprfx(z3.VnH(), p0.Zeroing(), z13.VnH());
782 __ movprfx(z31.VnS(), p7.Zeroing(), z12.VnS());
785 __ movprfx(z16.VnS(), p7.Zeroing(), z6.VnS());
788 __ movprfx(z17.VnD(), p7.Merging(), z1.VnD());
791 __ movprfx(z31.VnH(), p4.Zeroing(), z12.VnH());
794 __ movprfx(z9.VnH(), p3.Zeroing(), z23.VnH());
797 __ movprfx(z25.VnD(), p2.Zeroing(), z21.VnD());
800 __ movprfx(z26.VnH(), p3.Merging(), z13.VnH());
803 __ movprfx(z8.VnH(), p5.Merging(), z20.VnH());
806 __ movprfx(z22.VnH(), p6.Merging(), z15.VnH());
809 __ movprfx(z1.VnD(), p3.Merging(), z15.VnD());
812 __ movprfx(z25.VnD(), p1.Zeroing(), z30.VnD());
815 __ movprfx(z19.VnS(), p3.Zeroing(), z11.VnS());
818 __ movprfx(z12.VnH(), p2.Merging(), z2.VnH());
821 __ movprfx(z3.VnD(), p1.Merging(), z15.VnD());
824 __ movprfx(z13.VnS(), p5.Merging(), z22.VnS());
827 __ movprfx(z11.VnH(), p5.Zeroing(), z25.VnH());
830 __ movprfx(z3.VnB(), p6.Merging(), z13.VnB());
833 __ movprfx(z26.VnH(), p5.Merging(), z1.VnH());
836 __ movprfx(z11.VnB(), p7.Zeroing(), z26.VnB());
839 __ movprfx(z1.VnS(), p2.Merging(), z21.VnS());
842 __ movprfx(z4.VnS(), p6.Zeroing(), z6.VnS());
845 __ movprfx(z26.VnB(), p2.Zeroing(), z11.VnB());
848 __ movprfx(z19.VnB(), p5.Merging(), z6.VnB());
851 __ movprfx(z16.VnB(), p4.Merging(), z6.VnB());
854 __ movprfx(z1.VnD(), p0.Zeroing(), z4.VnD());
857 __ movprfx(z25.VnD(), p7.Merging(), z4.VnD());
860 __ movprfx(z29.VnB(), p4.Merging(), z2.VnB());
863 __ movprfx(z27.VnH(), p5.Merging(), z21.VnH());
866 __ movprfx(z29.VnB(), p2.Merging(), z7.VnB());
875 // Test that CanTakeSVEMovprfx() checks that the (predicated) movprfx lane
880 // We have to use the Assembler directly to generate movprfx, so we need
885 __ movprfx(z29.VnD(), p5.Zeroing(), z8.VnD());
888 __ movprfx(z9.VnB(), p0.Zeroing(), z1.VnB());
891 __ movprfx(z24.VnD(), p0.Zeroing(), z8.VnD());
894 __ movprfx(z24.VnB(), p1.Zeroing(), z27.VnB());
897 __ movprfx(z14.VnH(), p7.Merging(), z12.VnH());
900 __ movprfx(z10.VnB(), p6.Merging(), z11.VnB());
903 __ movprfx(z12.VnB(), p6.Merging(), z18.VnB());
906 __ movprfx(z18.VnH(), p7.Zeroing(), z2.VnH());
909 __ movprfx(z3.VnH(), p5.Merging(), z14.VnH());
912 __ movprfx(z15.VnH(), p1.Zeroing(), z12.VnH());
915 __ movprfx(z3.VnH(), p2.Merging(), z22.VnH());
918 __ movprfx(z17.VnS(), p3.Merging(), z14.VnS());
921 __ movprfx(z2.VnH(), p1.Zeroing(), z16.VnH());
924 __ movprfx(z13.VnB(), p2.Merging(), z9.VnB());
927 __ movprfx(z19.VnB(), p1.Merging(), z4.VnB());
930 __ movprfx(z29.VnS(), p2.Merging(), z19.VnS());
933 __ movprfx(z21.VnS(), p4.Zeroing(), z17.VnS());
936 __ movprfx(z19.VnH(), p4.Zeroing(), z30.VnH());
939 __ movprfx(z10.VnS(), p7.Zeroing(), z27.VnS());
942 __ movprfx(z7.VnD(), p7.Zeroing(), z17.VnD());
945 __ movprfx(z22.VnB(), p0.Merging(), z27.VnB());
948 __ movprfx(z14.VnD(), p1.Zeroing(), z11.VnD());
951 __ movprfx(z27.VnB(), p5.Merging(), z14.VnB());
954 __ movprfx(z31.VnH(), p7.Merging(), z24.VnH());
957 __ movprfx(z11.VnD(), p7.Zeroing(), z25.VnD());
960 __ movprfx(z31.VnD(), p6.Merging(), z19.VnD());
963 __ movprfx(z20.VnS(), p3.Zeroing(), z15.VnS());
966 __ movprfx(z6.VnS(), p0.Merging(), z30.VnS());
969 __ movprfx(z1.VnH(), p1.Zeroing(), z14.VnH());
972 __ movprfx(z13.VnB(), p3.Zeroing(), z21.VnB());
975 __ movprfx(z15.VnS(), p1.Zeroing(), z20.VnS());
978 __ movprfx(z19.VnD(), p3.Zeroing(), z31.VnD());
981 __ movprfx(z16.VnS(), p7.Merging(), z30.VnS());
984 __ movprfx(z21.VnB(), p1.Merging(), z28.VnB());
987 __ movprfx(z21.VnS(), p1.Zeroing(), z19.VnS());
990 __ movprfx(z28.VnB(), p7.Zeroing(), z8.VnB());
993 __ movprfx(z2.VnB(), p4.Merging(), z31.VnB());
996 __ movprfx(z6.VnB(), p2.Zeroing(), z0.VnB());
999 __ movprfx(z26.VnB(), p0.Zeroing(), z21.VnB());
1002 __ movprfx(z15.VnB(), p1.Zeroing(), z26.VnB());
1005 __ movprfx(z16.VnS(), p0.Merging(), z1.VnS());
1008 __ movprfx(z4.VnH(), p0.Zeroing(), z16.VnH());
1011 // Note that frecpe and frecps _cannot_ take movprfx.
1012 __ movprfx(z9.VnH(), p0.Zeroing(), z21.VnH());
1015 __ movprfx(z6.VnH(), p2.Zeroing(), z28.VnH());
1018 __ movprfx(z12.VnS(), p4.Zeroing(), z7.VnS());
1021 __ movprfx(z6.VnB(), p5.Merging(), z20.VnB());
1024 __ movprfx(z7.VnB(), p6.Merging(), z19.VnB());
1027 __ movprfx(z12.VnD(), p2.Merging(), z31.VnD());
1030 __ movprfx(z1.VnS(), p5.Merging(), z10.VnS());
1033 __ movprfx(z6.VnH(), p0.Merging(), z12.VnH());
1036 __ movprfx(z8.VnH(), p2.Merging(), z6.VnH());
1039 __ movprfx(z20.VnH(), p2.Zeroing(), z2.VnH());
1042 __ movprfx(z28.VnS(), p6.Zeroing(), z19.VnS());
1045 __ movprfx(z6.VnB(), p0.Zeroing(), z12.VnB());
1048 __ movprfx(z6.VnS(), p7.Zeroing(), z11.VnS());
1051 __ movprfx(z28.VnB(), p3.Merging(), z10.VnB());
1054 __ movprfx(z22.VnB(), p3.Zeroing(), z14.VnB());
1057 __ movprfx(z20.VnS(), p2.Merging(), z9.VnS());
1060 __ movprfx(z19.VnH(), p1.Merging(), z21.VnH());
1063 __ movprfx(z31.VnS(), p3.Merging(), z22.VnS());
1066 __ movprfx(z8.VnS(), p3.Merging(), z3.VnS());
1069 __ movprfx(z0.VnB(), p0.Merging(), z23.VnB());
1072 __ movprfx(z8.VnH(), p3.Zeroing(), z4.VnH());
1075 __ movprfx(z20.VnH(), p2.Zeroing(), z10.VnH());
1084 // Test that CanTakeSVEMovprfx() is false when a predicated movprfx appears
1089 // We have to use the Assembler directly to generate movprfx, so we need
1094 __ movprfx(z27.VnS(), p1.Zeroing(), z12.VnS());
1097 __ movprfx(z31.VnS(), p6.Zeroing(), z1.VnS());
1100 __ movprfx(z27.VnS(), p5.Merging(), z24.VnS());
1103 __ movprfx(z6.VnH(), p7.Merging(), z30.VnH());
1106 __ movprfx(z11.VnB(), p6.Merging(), z5.VnB());
1109 __ movprfx(z5.VnD(), p0.Merging(), z1.VnD());
1112 __ movprfx(z11.VnH(), p7.Zeroing(), z28.VnH());
1115 __ movprfx(z14.VnS(), p5.Zeroing(), z6.VnS());
1118 __ movprfx(z6.VnS(), p5.Merging(), z10.VnS());
1121 __ movprfx(z27.VnH(), p7.Zeroing(), z9.VnH());
1124 __ movprfx(z3.VnS(), p3.Zeroing(), z2.VnS());
1127 __ movprfx(z30.VnB(), p2.Zeroing(), z25.VnB());
1130 __ movprfx(z22.VnD(), p0.Merging(), z0.VnD());
1133 __ movprfx(z7.VnH(), p3.Merging(), z3.VnH());
1136 __ movprfx(z9.VnD(), p1.Zeroing(), z28.VnD());
1139 __ movprfx(z30.VnS(), p3.Merging(), z4.VnS());
1142 __ movprfx(z30.VnB(), p7.Zeroing(), z21.VnB());
1145 __ movprfx(z2.VnB(), p4.Zeroing(), z26.VnB());
1148 __ movprfx(z27.VnS(), p5.Zeroing(), z5.VnS());
1151 __ movprfx(z5.VnS(), p0.Merging(), z26.VnS());
1154 __ movprfx(z5.VnS(), p0.Merging(), z26.VnS());
1157 __ movprfx(z16.VnD(), p1.Merging(), z13.VnD());
1160 __ movprfx(z27.VnD(), p5.Merging(), z18.VnD());
1163 __ movprfx(z20.VnS(), p6.Merging(), z1.VnS());
1166 __ movprfx(z19.VnD(), p0.Zeroing(), z7.VnD());
1169 __ movprfx(z15.VnD(), p1.Zeroing(), z7.VnD());
1172 __ movprfx(z15.VnB(), p5.Merging(), z3.VnB());
1175 __ movprfx(z5.VnB(), p6.Zeroing(), z4.VnB());
1178 __ movprfx(z16.VnD(), p0.Zeroing(), z18.VnD());
1181 __ movprfx(z7.VnH(), p3.Merging(), z28.VnH());
1184 __ movprfx(z7.VnS(), p2.Merging(), z13.VnS());
1187 __ movprfx(z22.VnS(), p7.Zeroing(), z20.VnS());
1190 __ movprfx(z26.VnD(), p1.Zeroing(), z0.VnD());
1193 __ movprfx(z15.VnH(), p7.Zeroing(), z27.VnH());
1196 __ movprfx(z4.VnD(), p7.Merging(), z13.VnD());
1199 __ movprfx(z29.VnS(), p6.Merging(), z14.VnS());
1202 __ movprfx(z17.VnB(), p1.Merging(), z24.VnB());
1205 __ movprfx(z26.VnS(), p5.Zeroing(), z19.VnS());
1208 __ movprfx(z15.VnD(), p1.Merging(), z3.VnD());
1211 __ movprfx(z4.VnD(), p2.Zeroing(), z14.VnD());
1214 __ movprfx(z29.VnD(), p4.Zeroing(), z28.VnD());
1217 __ movprfx(z7.VnS(), p6.Merging(), z3.VnS());
1220 __ movprfx(z14.VnB(), p3.Merging(), z5.VnB());
1223 __ movprfx(z4.VnD(), p1.Zeroing(), z2.VnD());
1226 __ movprfx(z19.VnB(), p0.Zeroing(), z27.VnB());
1229 __ movprfx(z24.VnD(), p7.Zeroing(), z11.VnD());
1232 __ movprfx(z24.VnH(), p4.Zeroing(), z18.VnH());
1235 __ movprfx(z31.VnS(), p5.Zeroing(), z2.VnS());
1238 __ movprfx(z19.VnS(), p6.Merging(), z21.VnS());
1241 __ movprfx(z27.VnD(), p0.Merging(), z21.VnD());
1244 __ movprfx(z13.VnH(), p4.Zeroing(), z12.VnH());
1247 __ movprfx(z0.VnD(), p4.Zeroing(), z1.VnD());
1250 __ movprfx(z12.VnS(), p4.Merging(), z21.VnS());
1253 __ movprfx(z9.VnD(), p0.Zeroing(), z16.VnD());
1256 __ movprfx(z22.VnS(), p0.Zeroing(), z5.VnS());
1259 __ movprfx(z1.VnS(), p0.Zeroing(), z5.VnS());
1262 __ movprfx(z30.VnS(), p0.Zeroing(), z5.VnS());
1265 __ movprfx(z4.VnS(), p0.Zeroing(), z5.VnS());
1268 __ movprfx(z10.VnS(), p0.Zeroing(), z5.VnS());
1271 __ movprfx(z1.VnS(), p0.Zeroing(), z5.VnS());
1280 // Test that CanTakeSVEMovprfx() is false when a predicated movprfx appears
1287 // We have to use the Assembler directly to generate movprfx, so we need
1292 __ movprfx(z10.VnH(), p3.Zeroing(), z3.VnH());
1295 __ movprfx(z12.VnS(), p4.Merging(), z14.VnS());
1298 __ movprfx(z16.VnD(), p3.Zeroing(), z24.VnD());
1301 __ movprfx(z9.VnH(), p7.Zeroing(), z0.VnH());
1304 __ movprfx(z23.VnS(), p5.Merging(), z5.VnS());
1307 __ movprfx(z19.VnD(), p6.Zeroing(), z8.VnD());
1310 __ movprfx(z25.VnH(), p7.Merging(), z24.VnH());
1313 __ movprfx(z2.VnS(), p1.Zeroing(), z0.VnS());
1316 // Note that ftsmul and ftssel cannot take movprfx.
1317 __ movprfx(z22.VnD(), p6.Merging(), z16.VnD());
1320 __ movprfx(z30.VnS(), p0.Zeroing(), z5.VnS());
1323 __ movprfx(z31.VnD(), p1.Merging(), z5.VnD());
1335 // We have to use the Assembler directly to generate movprfx, so we need
1340 __ movprfx(z17, z28);
1343 __ movprfx(z9, z7);
1346 __ movprfx(z11, z0);
1349 __ movprfx(z8.VnS(), p3.Zeroing(), z28.VnS());
1352 __ movprfx(z20, z23);
1355 __ movprfx(z24.VnD(), p5.Merging(), z11.VnD());
1358 __ movprfx(z1, z13);
1361 __ movprfx(z0.VnB(), p7.Zeroing(), z28.VnB());
1364 __ movprfx(z15, z5);
1367 __ movprfx(z24.VnH(), p3.Merging(), z22.VnH());
1370 __ movprfx(z2.VnS(), p3.Zeroing(), z20.VnS());
1373 __ movprfx(z17.VnB(), p7.Merging(), z6.VnB());
1376 __ movprfx(z31, z6);
1379 __ movprfx(z20, z2);
1382 __ movprfx(z27, z11);
1385 __ movprfx(z3.VnS(), p7.Zeroing(), z17.VnS());
1388 __ movprfx(z29.VnB(), p0.Zeroing(), z24.VnB());
1391 __ movprfx(z2.VnH(), p7.Zeroing(), z29.VnH());
1394 __ movprfx(z23, z5);
1397 __ movprfx(z5, z3);
1400 __ movprfx(z0, z12);
1403 __ movprfx(z27, z8);
1406 __ movprfx(z20, z24);
1409 __ movprfx(z5, z28);
1412 __ movprfx(z7, z3);
1415 __ movprfx(z4, z7);
1418 __ movprfx(z3, z18);
1421 __ movprfx(z4.VnD(), p0.Merging(), z10.VnD());
1424 __ movprfx(z15, z18);
1427 __ movprfx(z17, z30);
1430 __ movprfx(z19, z28);
1433 __ movprfx(z13, z7);
1436 __ movprfx(z14, z21);
1439 __ movprfx(z26, z12);
1442 __ movprfx(z16, z2);
1445 __ movprfx(z20, z26);
1448 __ movprfx(z30.VnD(), p0.Merging(), z23.VnD());
1451 __ movprfx(z28.VnS(), p2.Zeroing(), z6.VnS());
1454 __ movprfx(z15.VnH(), p6.Zeroing(), z3.VnH());
1457 __ movprfx(z13.VnD(), p4.Zeroing(), z14.VnD());
1460 __ movprfx(z14, z5);
1463 __ movprfx(z21, z1);
1466 __ movprfx(z11.VnH(), p0.Zeroing(), z13.VnH());
1469 __ movprfx(z24, z29);
1472 __ movprfx(z1.VnD(), p6.Merging(), z9.VnD());
1475 __ movprfx(z22, z3);
1478 __ movprfx(z24.VnB(), p2.Zeroing(), z5.VnB());
1481 __ movprfx(z8, z4);
1484 __ movprfx(z10, z8);
1488 __ movprfx(z4.VnH(), p5.Zeroing(), z2.VnH());
1491 __ movprfx(z2.VnB(), p3.Zeroing(), z24.VnB());
1494 __ movprfx(z27, z13);
1497 __ movprfx(z18.VnB(), p5.Zeroing(), z11.VnB());
1500 __ movprfx(z29, z16);
1503 __ movprfx(z21, z23);
1506 __ movprfx(z7.VnS(), p4.Merging(), z14.VnS());
1509 __ movprfx(z8.VnD(), p4.Zeroing(), z5.VnD());
1512 __ movprfx(z14, z13);
1515 __ movprfx(z14, z13);
1518 __ movprfx(z27, z17);
1521 __ movprfx(z13.VnH(), p2.Zeroing(), z27.VnH());
1524 __ movprfx(z1, z29);
1527 __ movprfx(z18.VnD(), p2.Zeroing(), z10.VnD());
1530 __ movprfx(z2.VnD(), p1.Merging(), z10.VnD());
1533 __ movprfx(z28.VnS(), p7.Merging(), z11.VnS());
1536 __ movprfx(z22.VnS(), p0.Merging(), z20.VnS());
1539 __ movprfx(z13.VnS(), p7.Merging(), z0.VnS());
1542 __ movprfx(z0, z12);
1545 __ movprfx(z8, z15);
1548 __ movprfx(z13, z0);
1551 __ movprfx(z11, z13);
1554 __ movprfx(z3, z17);
1557 __ movprfx(z10, z29);
1560 __ movprfx(z13, z29);
1563 __ movprfx(z6, z17);
1566 __ movprfx(z19, z20);
1569 __ movprfx(z0, z3);
1572 __ movprfx(z29, z5);
1575 __ movprfx(z25, z11);
1578 __ movprfx(z16, z9);
1581 __ movprfx(z8, z17);
1584 __ movprfx(z4, z5);
1587 __ movprfx(z0, z17);
1590 __ movprfx(z7, z27);
1593 __ movprfx(z10, z9);
1596 __ movprfx(z31, z22);
1599 __ movprfx(z12.VnH(), p7.Zeroing(), z23.VnH());
1602 __ movprfx(z10, z1);
1605 __ movprfx(z15.VnB(), p0.Merging(), z0.VnB());
1608 __ movprfx(z17, z2);
1611 __ movprfx(z5, z3);
1614 __ movprfx(z11, z17);
1617 __ movprfx(z26, z4);
1620 __ movprfx(z15.VnD(), p0.Zeroing(), z8.VnD());
1623 __ movprfx(z21, z24);
1626 __ movprfx(z22, z10);
1629 __ movprfx(z27, z25);
1632 __ movprfx(z29, z10);
1635 __ movprfx(z18, z0);
1638 __ movprfx(z6, z30);
1641 __ movprfx(z31, z17);
1644 __ movprfx(z27.VnS(), p0.Merging(), z20.VnS());
1647 __ movprfx(z0, z11);
1650 __ movprfx(z21, z17);
1653 __ movprfx(z9, z24);
1656 __ movprfx(z18, z13);
1659 __ movprfx(z20, z23);
1662 __ movprfx(z12, z29);
1665 __ movprfx(z24, z25);
1668 __ movprfx(z13, z1);
1671 __ movprfx(z5, z19);
1674 __ movprfx(z6, z25);
1677 __ movprfx(z12, z14);
1680 __ movprfx(z13, z6);
1683 __ movprfx(z31, z3);
1686 __ movprfx(z18.VnD(), p4.Merging(), z25.VnD());
1689 __ movprfx(z18.VnD(), p7.Merging(), z25.VnD());
1692 __ movprfx(z22, z5);
1695 __ movprfx(z1, z5);
1698 __ movprfx(z30, z5);
1701 __ movprfx(z4, z5);
1704 __ movprfx(z10, z5);
1707 __ movprfx(z1, z5);
1721 // We have to use the Assembler directly to generate movprfx, so we need
1726 __ movprfx(z18.VnS(), p6.Zeroing(), z20.VnS());
1729 __ movprfx(z28.VnD(), p4.Zeroing(), z24.VnD());
1732 __ movprfx(z12, z8);
1735 __ movprfx(z0.VnS(), p1.Merging(), z9.VnS());
1738 __ movprfx(z10.VnH(), p2.Merging(), z2.VnH());
1741 __ movprfx(z21, z6);
1744 __ movprfx(z16, z6);
1747 __ movprfx(z15.VnH(), p6.Merging(), z16.VnH());
1750 __ movprfx(z1, z14);
1753 __ movprfx(z25.VnD(), p6.Merging(), z1.VnD());
1756 __ movprfx(z18.VnS(), p2.Merging(), z2.VnS());
1759 __ movprfx(z21.VnD(), p5.Zeroing(), z26.VnD());
1762 __ movprfx(z12.VnD(), p1.Merging(), z18.VnD());
1765 __ movprfx(z3.VnS(), p2.Merging(), z0.VnS());
1768 __ movprfx(z21.VnS(), p4.Merging(), z7.VnS());
1771 __ movprfx(z16.VnD(), p3.Zeroing(), z4.VnD());
1774 __ movprfx(z31.VnD(), p4.Merging(), z1.VnD());
1777 __ movprfx(z23.VnH(), p0.Zeroing(), z28.VnH());
1780 __ movprfx(z2, z12);
1783 __ movprfx(z4, z7);
1786 __ movprfx(z13.VnS(), p3.Zeroing(), z23.VnS());
1789 __ movprfx(z6.VnD(), p1.Zeroing(), z16.VnD());
1792 __ movprfx(z31, z23);
1795 __ movprfx(z14.VnH(), p7.Merging(), z21.VnH());
1798 __ movprfx(z17.VnS(), p4.Merging(), z9.VnS());
1801 __ movprfx(z1.VnS(), p3.Zeroing(), z30.VnS());
1804 __ movprfx(z10.VnD(), p1.Zeroing(), z17.VnD());
1807 __ movprfx(z3, z13);
1810 __ movprfx(z15, z21);
1813 __ movprfx(z30.VnH(), p7.Zeroing(), z25.VnH());
1816 __ movprfx(z31, z15);
1819 __ movprfx(z27, z28);
1822 __ movprfx(z26.VnH(), p6.Zeroing(), z13.VnH());
1825 __ movprfx(z26, z10);
1828 __ movprfx(z0, z1);
1831 __ movprfx(z7, z3);
1834 __ movprfx(z1, z24);
1837 __ movprfx(z19, z18);
1840 __ movprfx(z0, z26);
1843 __ movprfx(z19.VnS(), p7.Zeroing(), z6.VnS());
1846 __ movprfx(z21, z15);
1849 __ movprfx(z23, z18);
1852 __ movprfx(z8, z28);
1855 __ movprfx(z6.VnD(), p6.Merging(), z27.VnD());
1858 __ movprfx(z6.VnH(), p0.Merging(), z19.VnH());
1861 __ movprfx(z5.VnH(), p0.Merging(), z1.VnH());
1864 __ movprfx(z22.VnD(), p4.Zeroing(), z24.VnD());
1867 __ movprfx(z5.VnS(), p0.Merging(), z29.VnS());
1870 __ movprfx(z5, z3);
1873 __ movprfx(z9.VnD(), p2.Zeroing(), z7.VnD());
1876 // Note that frecpe and frecps _cannot_ take movprfx.
1877 __ movprfx(z12.VnH(), p1.Zeroing(), z17.VnH());
1880 __ movprfx(z28.VnS(), p4.Zeroing(), z27.VnS());
1883 __ movprfx(z7.VnD(), p7.Merging(), z25.VnD());
1886 __ movprfx(z10, z21);
1889 __ movprfx(z25, z21);
1892 __ movprfx(z25, z9);
1895 __ movprfx(z30, z16);
1898 __ movprfx(z0.VnD(), p5.Merging(), z9.VnD());
1901 __ movprfx(z11.VnD(), p7.Merging(), z2.VnD());
1904 __ movprfx(z23.VnS(), p4.Merging(), z17.VnS());
1907 __ movprfx(z0.VnD(), p2.Merging(), z26.VnD());
1910 __ movprfx(z28.VnD(), p1.Zeroing(), z16.VnD());
1913 __ movprfx(z22, z27);
1916 __ movprfx(z4.VnS(), p2.Merging(), z26.VnS());
1919 // Note that ftsmul and ftssel _cannot_ take movprfx.
1920 __ movprfx(z10, z4);
1923 __ movprfx(z2, z16);
1926 __ movprfx(z10, z20);
1929 __ movprfx(z29, z28);
1932 __ movprfx(z26.VnD(), p3.Merging(), z13.VnD());
1935 __ movprfx(z7.VnD(), p3.Zeroing(), z26.VnD());
1938 __ movprfx(z13, z17);
1941 __ movprfx(z24.VnD(), p1.Merging(), z31.VnD());
1944 __ movprfx(z17.VnD(), p4.Merging(), z22.VnD());
1947 __ movprfx(z30, z5);
1950 __ movprfx(z31, z5);
1962 // We have to use the Assembler directly to generate movprfx, so we need
1967 __ movprfx(z25, z26);
1970 __ movprfx(z0, z1);
1973 __ movprfx(z3, z4);
1976 __ movprfx(z6, z7);
1979 __ movprfx(z18, z19);
1982 __ movprfx(z7, z8);
1985 __ movprfx(z21, z22);
1988 __ movprfx(z5, z6);
1991 __ movprfx(z7, z8);
1994 __ movprfx(z7, z8);
1997 __ movprfx(z7, z8);
2000 __ movprfx(z19, z20);
2003 __ movprfx(z19, z20);
2006 __ movprfx(z19, z20);
2009 __ movprfx(z10, z11);
2012 __ movprfx(z3, z4);
2015 __ movprfx(z20, z22);
2018 __ movprfx(z14, z15);
2021 __ movprfx(z14.VnD(), p4.Merging(), z15.VnD());
2024 __ movprfx(z15.VnH(), p0.Merging(), z16.VnH());
2027 __ movprfx(z2, z3);
2030 __ movprfx(z22, z23);
2033 __ movprfx(z1, z2);
2036 __ movprfx(z16, z17);
2039 __ movprfx(z16, z17);
2042 __ movprfx(z16, z17);
2045 __ movprfx(z18, z19);
2048 __ movprfx(z18, z19);
2051 __ movprfx(z16, z17);
2054 __ movprfx(z16, z17);
2057 __ movprfx(z3, z4);
2060 __ movprfx(z3, z4);
2063 __ movprfx(z2, z3);
2066 __ movprfx(z2, z3);
2069 __ movprfx(z2, z3);
2072 __ movprfx(z2, z3);
2075 __ movprfx(z2, z3);
2078 __ movprfx(z2, z3);
2081 __ movprfx(z17, z18);
2084 __ movprfx(z13, z14);
2087 __ movprfx(z13, z14);
2090 __ movprfx(z14, z15);
2093 __ movprfx(z19.VnD(), p5.Merging(), z20.VnD());
2096 __ movprfx(z17, z18);
2099 __ movprfx(z20, z21);
2102 __ movprfx(z20.VnB(), p3.Merging(), z21.VnB());
2105 __ movprfx(z21.VnB(), p0.Merging(), z22.VnB());
2108 __ movprfx(z1.VnB(), p0.Merging(), z2.VnB());
2111 __ movprfx(z5, z6);
2114 __ movprfx(z27, z28);
2117 __ movprfx(z1, z2);
2120 __ movprfx(z1, z2);
2123 __ movprfx(z1, z2);
2126 __ movprfx(z1, z2);
2129 __ movprfx(z1, z2);
2132 __ movprfx(z1, z2);
2135 __ movprfx(z1, z2);
2138 __ movprfx(z1, z2);
2141 __ movprfx(z1, z2);
2144 __ movprfx(z1, z2);
2147 __ movprfx(z1, z2);
2150 __ movprfx(z1, z2);
2153 __ movprfx(z29.VnB(), p1.Merging(), z30.VnB());
2156 __ movprfx(z28.VnB(), p0.Merging(), z29.VnB());
2159 __ movprfx(z20, z21);
2162 __ movprfx(z6, z7);
2165 __ movprfx(z6, z7);
2168 __ movprfx(z6, z7);
2171 __ movprfx(z23, z24);
2174 __ movprfx(z11, z12);
2177 __ movprfx(z11, z12);
2180 __ movprfx(z11, z12);
2183 __ movprfx(z16, z17);
2186 __ movprfx(z16, z17);
2189 __ movprfx(z16, z17);
2192 __ movprfx(z26, z27);
2195 __ movprfx(z21, z22);
2198 __ movprfx(z21, z22);
2201 __ movprfx(z21, z22);
2204 __ movprfx(z21.VnB(), p0.Merging(), z22.VnB());
2207 __ movprfx(z31, z0);
2210 __ movprfx(z31, z0);
2213 __ movprfx(z31, z0);
2216 __ movprfx(z27, z28);
2219 __ movprfx(z27, z28);
2222 __ movprfx(z27, z28);
2225 __ movprfx(z27, z28);
2228 __ movprfx(z11, z12);
2231 __ movprfx(z11, z12);
2234 __ movprfx(z11, z12);
2237 __ movprfx(z11, z12);
2240 __ movprfx(z31.VnB(), p5.Merging(), z0.VnB());
2243 __ movprfx(z25.VnB(), p6.Merging(), z26.VnB());
2246 __ movprfx(z0.VnB(), p5.Merging(), z1.VnB());
2249 __ movprfx(z0.VnB(), p5.Merging(), z1.VnB());
2252 __ movprfx(z7.VnB(), p3.Merging(), z8.VnB());
2255 __ movprfx(z10.VnB(), p1.Merging(), z11.VnB());
2258 __ movprfx(z16.VnB(), p7.Merging(), z17.VnB());
2261 __ movprfx(z16.VnB(), p7.Merging(), z17.VnB());
2264 __ movprfx(z23.VnB(), p4.Merging(), z24.VnB());
2267 __ movprfx(z31.VnB(), p7.Merging(), z0.VnB());
2270 __ movprfx(z16.VnB(), p7.Merging(), z17.VnB());
2273 __ movprfx(z12.VnB(), p0.Merging(), z13.VnB());
2276 __ movprfx(z0, z1);
2279 __ movprfx(z0, z1);
2282 __ movprfx(z26.VnB(), p2.Merging(), z27.VnB());
2285 __ movprfx(z23, z24);
2288 __ movprfx(z11, z12);
2291 __ movprfx(z4, z5);
2294 __ movprfx(z20.VnD(), p4.Merging(), z21.VnD());
2297 __ movprfx(z21.VnB(), p2.Merging(), z22.VnB());
2300 __ movprfx(z1.VnB(), p4.Merging(), z2.VnB());
2303 __ movprfx(z18.VnB(), p0.Merging(), z19.VnB());
2306 __ movprfx(z7, z8);
2309 __ movprfx(z10, z11);
2312 __ movprfx(z31, z0);
2315 __ movprfx(z31, z0);
2318 __ movprfx(z31, z0);
2321 __ movprfx(z11, z12);
2324 __ movprfx(z11, z12);
2327 __ movprfx(z11, z12);
2330 __ movprfx(z28, z29);
2333 __ movprfx(z28, z29);
2336 __ movprfx(z28, z29);
2339 __ movprfx(z9, z10);
2342 __ movprfx(z9, z10);
2345 __ movprfx(z9, z10);
2348 __ movprfx(z24.VnB(), p7.Merging(), z25.VnB());
2351 __ movprfx(z20.VnB(), p1.Merging(), z21.VnB());
2354 __ movprfx(z8.VnB(), p5.Merging(), z9.VnB());
2357 __ movprfx(z29.VnB(), p7.Merging(), z30.VnB());
2360 __ movprfx(z29.VnB(), p7.Merging(), z30.VnB());
2363 __ movprfx(z12.VnB(), p1.Merging(), z13.VnB());
2366 __ movprfx(z20.VnB(), p0.Merging(), z21.VnB());
2369 __ movprfx(z20.VnB(), p0.Merging(), z21.VnB());
2372 __ movprfx(z25.VnS(), p7.Merging(), z26.VnS());
2375 __ movprfx(z29.VnB(), p4.Merging(), z30.VnB());
2378 __ movprfx(z15.VnB(), p2.Merging(), z16.VnB());
2381 __ movprfx(z27.VnB(), p1.Merging(), z28.VnB());
2384 __ movprfx(z31.VnB(), p2.Merging(), z0.VnB());
2387 __ movprfx(z4.VnS(), p3.Merging(), z5.VnS());
2390 __ movprfx(z0, z1);
2393 __ movprfx(z25.VnB(), p4.Merging(), z26.VnB());
2396 __ movprfx(z0, z1);
2399 __ movprfx(z16, z17);
2413 // We have to use the Assembler directly to generate movprfx, so we need
2418 __ movprfx(z29, z30);
2421 __ movprfx(z8, z9);
2424 __ movprfx(z18, z19);
2427 __ movprfx(z6, z7);
2430 __ movprfx(z24, z25);
2433 __ movprfx(z1, z2);
2436 __ movprfx(z1, z2);
2439 __ movprfx(z4, z5);
2442 __ movprfx(z4, z5);
2445 __ movprfx(z27, z28);
2448 __ movprfx(z24, z25);
2451 __ movprfx(z22, z23);
2454 __ movprfx(z21, z22);
2457 __ movprfx(z21, z22);
2460 __ movprfx(z10, z11);
2463 __ movprfx(z30, z31);
2466 __ movprfx(z30, z31);
2469 __ movprfx(z7, z8);
2472 __ movprfx(z7, z8);
2475 __ movprfx(z17, z18);
2478 __ movprfx(z17, z18);
2481 __ movprfx(z3, z4);
2484 __ movprfx(z0, z1);
2487 __ movprfx(z0, z1);
2490 __ movprfx(z18, z19);
2493 __ movprfx(z15, z16);
2496 __ movprfx(z15, z16);
2499 __ movprfx(z15, z16);
2502 __ movprfx(z15, z16);
2505 __ movprfx(z20, z21);
2508 __ movprfx(z0, z1);
2511 __ movprfx(z12, z13);
2514 __ movprfx(z31, z0);
2517 __ movprfx(z0, z1);
2520 __ movprfx(z23, z24);
2523 __ movprfx(z5, z6);
2526 __ movprfx(z5, z6);
2529 __ movprfx(z30, z31);
2532 __ movprfx(z25, z26);
2535 __ movprfx(z2, z3);
2538 __ movprfx(z25, z26);
2541 __ movprfx(z24, z25);
2544 __ movprfx(z15, z16);
2547 __ movprfx(z21, z22);
2550 __ movprfx(z12, z13);
2553 __ movprfx(z24, z25);
2556 __ movprfx(z7, z8);
2559 __ movprfx(z21, z22);
2562 __ movprfx(z29, z30);
2565 __ movprfx(z23, z24);
2568 __ movprfx(z10, z11);
2571 __ movprfx(z10, z11);
2574 __ movprfx(z10, z11);
2577 __ movprfx(z31, z0);
2580 __ movprfx(z31, z0);
2583 __ movprfx(z31, z0);
2586 __ movprfx(z4, z5);
2589 __ movprfx(z18, z19);
2592 __ movprfx(z18, z19);
2595 __ movprfx(z18, z19);
2598 __ movprfx(z18, z19);
2601 __ movprfx(z1, z2);
2604 __ movprfx(z1, z2);
2607 __ movprfx(z1, z2);
2610 __ movprfx(z2, z3);
2613 __ movprfx(z2, z3);
2616 __ movprfx(z2, z3);
2619 __ movprfx(z21, z22);
2622 __ movprfx(z21, z22);
2625 __ movprfx(z21, z22);
2628 __ movprfx(z21, z22);
2631 __ movprfx(z1, z2);
2634 __ movprfx(z24, z25);
2637 __ movprfx(z23, z24);
2640 __ movprfx(z9, z10);
2643 __ movprfx(z25, z26);
2646 __ movprfx(z0, z1);
2649 __ movprfx(z25, z26);
2652 __ movprfx(z20, z21);
2655 __ movprfx(z2, z3);
2658 __ movprfx(z31, z0);
2661 __ movprfx(z28, z29);
2664 __ movprfx(z14, z15);
2667 __ movprfx(z6, z7);
2670 __ movprfx(z2, z3);
2673 __ movprfx(z27, z28);
2676 __ movprfx(z4, z5);
2679 __ movprfx(z6, z7);
2682 __ movprfx(z12, z13);
2685 __ movprfx(z11, z12);
2688 __ movprfx(z7, z8);
2691 __ movprfx(z29, z30);
2694 __ movprfx(z21, z22);
2697 __ movprfx(z21, z22);
2700 __ movprfx(z10, z11);
2703 __ movprfx(z30, z31);
2706 __ movprfx(z30, z31);
2709 __ movprfx(z0, z1);
2712 __ movprfx(z0, z1);
2715 __ movprfx(z31, z0);
2718 __ movprfx(z31, z0);
2721 __ movprfx(z24, z25);
2724 __ movprfx(z22, z23);
2727 __ movprfx(z1, z2);
2730 __ movprfx(z25, z26);
2733 __ movprfx(z3, z4);
2736 __ movprfx(z15, z16);
2739 __ movprfx(z31, z0);
2742 __ movprfx(z17, z18);
2745 __ movprfx(z12, z13);
2748 __ movprfx(z12, z13);
2751 __ movprfx(z12, z13);
2754 __ movprfx(z12, z13);
2757 __ movprfx(z24, z25);
2760 __ movprfx(z24, z25);
2763 __ movprfx(z24, z25);
2766 __ movprfx(z30, z31);
2769 __ movprfx(z3, z4);
2772 __ movprfx(z17, z18);
2775 __ movprfx(z28, z29);
2778 __ movprfx(z28, z29);
2781 __ movprfx(z19, z20);
2784 __ movprfx(z8, z9);
2787 __ movprfx(z3, z4);
2790 __ movprfx(z25, z26);
2793 __ movprfx(z5, z6);
2796 __ movprfx(z10, z11);
2799 __ movprfx(z15, z16);
2802 __ movprfx(z20, z21);
2805 __ movprfx(z24, z25);
2808 __ movprfx(z20, z21);
2811 __ movprfx(z22, z23);
2814 __ movprfx(z25, z26);
2817 __ movprfx(z14, z15);
2829 // We have to use the Assembler directly to generate movprfx, so we need
2834 __ movprfx(z25.VnS(), p0.Zeroing(), z26.VnS());
2837 __ movprfx(z0.VnS(), p0.Zeroing(), z1.VnS());
2840 __ movprfx(z6.VnD(), p0.Zeroing(), z7.VnD());
2843 __ movprfx(z18.VnD(), p0.Zeroing(), z19.VnD());
2846 __ movprfx(z7.VnD(), p0.Zeroing(), z8.VnD());
2849 __ movprfx(z21.VnD(), p0.Zeroing(), z22.VnD());
2852 __ movprfx(z5.VnB(), p0.Zeroing(), z6.VnB());
2855 __ movprfx(z7.VnS(), p0.Zeroing(), z8.VnS());
2858 __ movprfx(z7.VnS(), p0.Zeroing(), z8.VnS());
2861 __ movprfx(z7.VnD(), p0.Zeroing(), z8.VnD());
2864 __ movprfx(z19.VnB(), p0.Zeroing(), z20.VnB());
2867 __ movprfx(z19.VnS(), p0.Zeroing(), z20.VnS());
2870 __ movprfx(z19.VnH(), p0.Zeroing(), z20.VnH());
2873 __ movprfx(z10.VnD(), p0.Zeroing(), z11.VnD());
2876 __ movprfx(z3.VnB(), p0.Zeroing(), z4.VnB());
2879 __ movprfx(z20.VnB(), p0.Zeroing(), z22.VnB());
2882 __ movprfx(z14.VnD(), p0.Zeroing(), z15.VnD());
2885 __ movprfx(z2.VnD(), p0.Zeroing(), z3.VnD());
2888 __ movprfx(z22.VnD(), p0.Zeroing(), z23.VnD());
2891 __ movprfx(z1.VnD(), p0.Zeroing(), z2.VnD());
2894 __ movprfx(z16.VnD(), p0.Zeroing(), z17.VnD());
2897 __ movprfx(z16.VnS(), p0.Zeroing(), z17.VnS());
2900 __ movprfx(z16.VnS(), p0.Zeroing(), z17.VnS());
2903 __ movprfx(z18.VnS(), p0.Zeroing(), z19.VnS());
2906 __ movprfx(z18.VnS(), p0.Zeroing(), z19.VnS());
2909 __ movprfx(z16.VnS(), p0.Zeroing(), z17.VnS());
2912 __ movprfx(z16.VnS(), p0.Zeroing(), z17.VnS());
2915 __ movprfx(z3.VnS(), p0.Zeroing(), z4.VnS());
2918 __ movprfx(z3.VnS(), p0.Zeroing(), z4.VnS());
2921 __ movprfx(z2.VnH(), p0.Zeroing(), z3.VnH());
2924 __ movprfx(z2.VnS(), p0.Zeroing(), z3.VnS());
2927 __ movprfx(z2.VnD(), p0.Zeroing(), z3.VnD());
2930 __ movprfx(z2.VnH(), p0.Zeroing(), z3.VnH());
2933 __ movprfx(z2.VnS(), p0.Zeroing(), z3.VnS());
2936 __ movprfx(z2.VnD(), p0.Zeroing(), z3.VnD());
2939 __ movprfx(z17.VnD(), p0.Zeroing(), z18.VnD());
2942 __ movprfx(z13.VnB(), p0.Zeroing(), z14.VnB());
2945 __ movprfx(z13.VnD(), p0.Zeroing(), z14.VnD());
2948 __ movprfx(z14.VnD(), p0.Zeroing(), z15.VnD());
2951 __ movprfx(z17.VnS(), p0.Zeroing(), z18.VnS());
2954 __ movprfx(z20.VnS(), p0.Zeroing(), z21.VnS());
2957 __ movprfx(z5.VnB(), p0.Zeroing(), z6.VnB());
2960 __ movprfx(z27.VnB(), p0.Zeroing(), z28.VnB());
2963 __ movprfx(z1.VnD(), p0.Zeroing(), z2.VnD());
2966 __ movprfx(z1.VnD(), p0.Zeroing(), z2.VnD());
2969 __ movprfx(z1.VnS(), p0.Zeroing(), z2.VnS());
2972 __ movprfx(z1.VnD(), p0.Zeroing(), z2.VnD());
2975 __ movprfx(z1.VnD(), p0.Zeroing(), z2.VnD());
2978 __ movprfx(z1.VnS(), p0.Zeroing(), z2.VnS());
2981 __ movprfx(z1.VnD(), p0.Zeroing(), z2.VnD());
2984 __ movprfx(z1.VnD(), p0.Zeroing(), z2.VnD());
2987 __ movprfx(z1.VnS(), p0.Zeroing(), z2.VnS());
2990 __ movprfx(z1.VnD(), p0.Zeroing(), z2.VnD());
2993 __ movprfx(z1.VnD(), p0.Zeroing(), z2.VnD());
2996 __ movprfx(z1.VnS(), p0.Zeroing(), z2.VnS());
2999 __ movprfx(z20.VnB(), p0.Zeroing(), z21.VnB());
3002 __ movprfx(z6.VnD(), p0.Zeroing(), z7.VnD());
3005 __ movprfx(z6.VnD(), p0.Zeroing(), z7.VnD());
3008 __ movprfx(z6.VnS(), p0.Zeroing(), z7.VnS());
3011 __ movprfx(z23.VnD(), p0.Zeroing(), z24.VnD());
3014 __ movprfx(z11.VnD(), p0.Zeroing(), z12.VnD());
3017 __ movprfx(z11.VnD(), p0.Zeroing(), z12.VnD());
3020 __ movprfx(z11.VnS(), p0.Zeroing(), z12.VnS());
3023 __ movprfx(z16.VnD(), p0.Zeroing(), z17.VnD());
3026 __ movprfx(z16.VnD(), p0.Zeroing(), z17.VnD());
3029 __ movprfx(z16.VnS(), p0.Zeroing(), z17.VnS());
3032 __ movprfx(z26.VnD(), p0.Zeroing(), z27.VnD());
3035 __ movprfx(z21.VnD(), p0.Zeroing(), z22.VnD());
3038 __ movprfx(z21.VnD(), p0.Zeroing(), z22.VnD());
3041 __ movprfx(z21.VnS(), p0.Zeroing(), z22.VnS());
3044 __ movprfx(z31.VnB(), p0.Zeroing(), z0.VnB());
3047 __ movprfx(z31.VnH(), p0.Zeroing(), z0.VnH());
3050 __ movprfx(z31.VnS(), p0.Zeroing(), z0.VnS());
3053 __ movprfx(z27.VnB(), p0.Zeroing(), z28.VnB());
3056 __ movprfx(z27.VnH(), p0.Zeroing(), z28.VnH());
3059 __ movprfx(z27.VnS(), p0.Zeroing(), z28.VnS());
3062 __ movprfx(z27.VnD(), p0.Zeroing(), z28.VnD());
3065 __ movprfx(z11.VnB(), p0.Zeroing(), z12.VnB());
3068 __ movprfx(z11.VnH(), p0.Zeroing(), z12.VnH());
3071 __ movprfx(z11.VnS(), p0.Zeroing(), z12.VnS());
3074 __ movprfx(z11.VnD(), p0.Zeroing(), z12.VnD());
3077 __ movprfx(z0.VnB(), p0.Zeroing(), z1.VnB());
3080 __ movprfx(z0.VnB(), p0.Zeroing(), z1.VnB());
3083 __ movprfx(z23.VnB(), p0.Zeroing(), z24.VnB());
3086 __ movprfx(z11.VnD(), p0.Zeroing(), z12.VnD());
3089 __ movprfx(z4.VnD(), p0.Zeroing(), z5.VnD());
3092 __ movprfx(z7.VnB(), p0.Zeroing(), z8.VnB());
3095 __ movprfx(z10.VnB(), p0.Zeroing(), z11.VnB());
3098 __ movprfx(z31.VnD(), p0.Zeroing(), z0.VnD());
3101 __ movprfx(z31.VnD(), p0.Zeroing(), z0.VnD());
3104 __ movprfx(z31.VnS(), p0.Zeroing(), z0.VnS());
3107 __ movprfx(z11.VnD(), p0.Zeroing(), z12.VnD());
3110 __ movprfx(z11.VnD(), p0.Zeroing(), z12.VnD());
3113 __ movprfx(z11.VnS(), p0.Zeroing(), z12.VnS());
3116 __ movprfx(z28.VnD(), p0.Zeroing(), z29.VnD());
3119 __ movprfx(z28.VnD(), p0.Zeroing(), z29.VnD());
3122 __ movprfx(z28.VnS(), p0.Zeroing(), z29.VnS());
3125 __ movprfx(z9.VnD(), p0.Zeroing(), z10.VnD());
3128 __ movprfx(z9.VnD(), p0.Zeroing(), z10.VnD());
3131 __ movprfx(z9.VnS(), p0.Zeroing(), z10.VnS());
3134 __ movprfx(z0.VnB(), p0.Zeroing(), z1.VnB());
3137 __ movprfx(z0.VnB(), p0.Zeroing(), z1.VnB());
3140 __ movprfx(z16.VnB(), p0.Zeroing(), z17.VnB());
3152 // We have to use the Assembler directly to generate movprfx, so we need
3157 __ movprfx(z25, z26);
3160 __ movprfx(z0, z1);
3163 __ movprfx(z3, z4);
3166 __ movprfx(z6, z7);
3169 __ movprfx(z18, z19);
3172 __ movprfx(z7, z8);
3175 __ movprfx(z21, z22);
3178 __ movprfx(z5, z6);
3181 __ movprfx(z7, z8);
3184 __ movprfx(z7, z8);
3187 __ movprfx(z7, z8);
3190 __ movprfx(z19, z20);
3193 __ movprfx(z19, z20);
3196 __ movprfx(z1, z20);
3199 __ movprfx(z10, z11);
3202 __ movprfx(z3, z4);
3205 __ movprfx(z20, z22);
3208 __ movprfx(z14, z15);
3211 __ movprfx(z14.VnD(), p4.Merging(), z15.VnD());
3214 __ movprfx(z15.VnH(), p0.Merging(), z16.VnH());
3217 __ movprfx(z2, z3);
3220 __ movprfx(z22, z23);
3223 __ movprfx(z1, z2);
3226 __ movprfx(z16, z17);
3229 __ movprfx(z16, z17);
3232 __ movprfx(z16, z17);
3235 __ movprfx(z18, z19);
3238 __ movprfx(z18, z19);
3241 __ movprfx(z16, z17);
3244 __ movprfx(z16, z17);
3247 __ movprfx(z3, z4);
3250 __ movprfx(z3, z4);
3253 __ movprfx(z2, z3);
3256 __ movprfx(z2, z3);
3259 __ movprfx(z2, z3);
3262 __ movprfx(z2, z3);
3265 __ movprfx(z2, z3);
3268 __ movprfx(z2, z3);
3271 __ movprfx(z17, z18);
3274 __ movprfx(z13, z14);
3277 __ movprfx(z13, z14);
3280 __ movprfx(z14, z15);
3283 __ movprfx(z19.VnD(), p5.Merging(), z20.VnD());
3286 __ movprfx(z17, z18);
3289 __ movprfx(z20, z21);
3292 __ movprfx(z20.VnB(), p3.Merging(), z21.VnB());
3295 __ movprfx(z21.VnB(), p0.Merging(), z22.VnB());
3298 __ movprfx(z1.VnB(), p0.Merging(), z2.VnB());
3301 __ movprfx(z5, z6);
3304 __ movprfx(z27, z28);
3307 __ movprfx(z1, z2);
3310 __ movprfx(z1, z2);
3313 __ movprfx(z1, z2);
3316 __ movprfx(z1, z2);
3319 __ movprfx(z1, z2);
3322 __ movprfx(z1, z2);
3325 __ movprfx(z1, z2);
3328 __ movprfx(z1, z2);
3331 __ movprfx(z1, z2);
3334 __ movprfx(z1, z2);
3337 __ movprfx(z1, z2);
3340 __ movprfx(z1, z2);
3343 __ movprfx(z29.VnB(), p1.Merging(), z30.VnB());
3346 __ movprfx(z28.VnB(), p0.Merging(), z29.VnB());
3349 __ movprfx(z20, z21);
3352 __ movprfx(z6, z7);
3355 __ movprfx(z6, z7);
3358 __ movprfx(z6, z7);
3361 __ movprfx(z23, z24);
3364 __ movprfx(z11, z12);
3367 __ movprfx(z11, z12);
3370 __ movprfx(z1, z12);
3373 __ movprfx(z16, z17);
3376 __ movprfx(z16, z17);
3379 __ movprfx(z16, z17);
3382 __ movprfx(z26, z27);
3385 __ movprfx(z21, z22);
3388 __ movprfx(z21, z22);
3391 __ movprfx(z1, z22);
3394 __ movprfx(z21.VnB(), p0.Merging(), z22.VnB());
3397 __ movprfx(z31, z0);
3400 __ movprfx(z31, z0);
3403 __ movprfx(z31, z0);
3406 __ movprfx(z27, z28);
3409 __ movprfx(z27, z28);
3412 __ movprfx(z27, z28);
3415 __ movprfx(z27, z28);
3418 __ movprfx(z11, z12);
3421 __ movprfx(z11, z12);
3424 __ movprfx(z11, z12);
3427 __ movprfx(z11, z12);
3430 __ movprfx(z31.VnB(), p5.Merging(), z0.VnB());
3433 __ movprfx(z25.VnB(), p6.Merging(), z26.VnB());
3436 __ movprfx(z0.VnB(), p5.Merging(), z1.VnB());
3439 __ movprfx(z7.VnB(), p3.Merging(), z8.VnB());
3442 __ movprfx(z16.VnB(), p7.Merging(), z17.VnB());
3445 __ movprfx(z16.VnB(), p7.Merging(), z17.VnB());
3448 __ movprfx(z23.VnB(), p4.Merging(), z24.VnB());
3451 __ movprfx(z31.VnB(), p7.Merging(), z0.VnB());
3454 __ movprfx(z16.VnB(), p7.Merging(), z17.VnB());
3457 __ movprfx(z0, z1);
3460 __ movprfx(z0, z1);
3463 __ movprfx(z26.VnB(), p2.Merging(), z27.VnB());
3466 __ movprfx(z23, z24);
3469 __ movprfx(z11, z12);
3472 __ movprfx(z4, z5);
3475 __ movprfx(z20.VnD(), p4.Merging(), z21.VnD());
3478 __ movprfx(z21.VnB(), p2.Merging(), z22.VnB());
3481 __ movprfx(z1.VnB(), p4.Merging(), z2.VnB());
3484 __ movprfx(z18.VnB(), p0.Merging(), z19.VnB());
3487 __ movprfx(z7, z8);
3490 __ movprfx(z10, z11);
3493 __ movprfx(z31, z0);
3496 __ movprfx(z31, z0);
3499 __ movprfx(z31, z0);
3502 __ movprfx(z11, z12);
3505 __ movprfx(z11, z12);
3508 __ movprfx(z1, z12);
3511 __ movprfx(z28, z29);
3514 __ movprfx(z28, z29);
3517 __ movprfx(z28, z29);
3520 __ movprfx(z9, z10);
3523 __ movprfx(z9, z10);
3526 __ movprfx(z9, z10);
3529 __ movprfx(z24.VnB(), p7.Merging(), z25.VnB());
3532 __ movprfx(z20.VnB(), p1.Merging(), z21.VnB());
3535 __ movprfx(z8.VnB(), p5.Merging(), z9.VnB());
3538 __ movprfx(z29.VnB(), p7.Merging(), z30.VnB());
3541 __ movprfx(z12.VnB(), p1.Merging(), z13.VnB());
3544 __ movprfx(z20.VnB(), p0.Merging(), z21.VnB());
3547 __ movprfx(z20.VnB(), p0.Merging(), z21.VnB());
3550 __ movprfx(z25.VnS(), p7.Merging(), z26.VnS());
3553 __ movprfx(z29.VnB(), p4.Merging(), z30.VnB());
3556 __ movprfx(z15.VnB(), p2.Merging(), z16.VnB());
3559 __ movprfx(z27.VnB(), p1.Merging(), z28.VnB());
3562 __ movprfx(z4.VnS(), p3.Merging(), z5.VnS());
3565 __ movprfx(z0, z1);
3568 __ movprfx(z25.VnB(), p4.Merging(), z26.VnB());
3571 __ movprfx(z0, z1);
3574 __ movprfx(z16, z17);
3586 // We have to use the Assembler directly to generate movprfx, so we need
3591 __ movprfx(z14.VnS(), p4.Merging(), z15.VnS());
3594 __ movprfx(z15.VnS(), p0.Merging(), z16.VnS());
3597 __ movprfx(z19.VnB(), p5.Merging(), z20.VnB());
3600 __ movprfx(z20.VnH(), p3.Merging(), z21.VnH());
3603 __ movprfx(z21.VnH(), p0.Merging(), z22.VnH());
3606 __ movprfx(z1.VnS(), p0.Merging(), z2.VnS());
3609 __ movprfx(z29.VnD(), p1.Merging(), z30.VnD());
3612 __ movprfx(z28.VnH(), p0.Merging(), z29.VnH());
3615 __ movprfx(z21.VnH(), p0.Merging(), z22.VnH());
3618 __ movprfx(z31.VnS(), p5.Merging(), z0.VnS());
3621 __ movprfx(z25.VnD(), p6.Merging(), z26.VnD());
3624 __ movprfx(z0.VnH(), p5.Merging(), z1.VnH());
3627 __ movprfx(z0.VnS(), p5.Merging(), z1.VnS());
3630 __ movprfx(z7.VnD(), p3.Merging(), z8.VnD());
3633 __ movprfx(z10.VnH(), p1.Merging(), z11.VnH());
3636 __ movprfx(z16.VnH(), p7.Merging(), z17.VnH());
3639 __ movprfx(z16.VnS(), p7.Merging(), z17.VnS());
3642 __ movprfx(z23.VnD(), p4.Merging(), z24.VnD());
3645 __ movprfx(z31.VnH(), p7.Merging(), z0.VnH());
3648 __ movprfx(z16.VnH(), p7.Merging(), z17.VnH());
3651 __ movprfx(z12.VnH(), p0.Merging(), z13.VnH());
3654 __ movprfx(z26.VnH(), p2.Merging(), z27.VnH());
3657 __ movprfx(z20.VnB(), p4.Merging(), z21.VnB());
3660 __ movprfx(z21.VnH(), p2.Merging(), z22.VnH());
3663 __ movprfx(z1.VnH(), p4.Merging(), z2.VnH());
3666 __ movprfx(z18.VnH(), p0.Merging(), z19.VnH());
3669 __ movprfx(z24.VnH(), p7.Merging(), z25.VnH());
3672 __ movprfx(z20.VnS(), p1.Merging(), z21.VnS());
3675 __ movprfx(z8.VnS(), p5.Merging(), z9.VnS());
3678 __ movprfx(z29.VnS(), p7.Merging(), z30.VnS());
3681 __ movprfx(z29.VnS(), p7.Merging(), z30.VnS());
3684 __ movprfx(z12.VnS(), p1.Merging(), z13.VnS());
3687 __ movprfx(z20.VnS(), p0.Merging(), z21.VnS());
3690 __ movprfx(z20.VnS(), p0.Merging(), z21.VnS());
3693 __ movprfx(z25.VnB(), p7.Merging(), z26.VnB());
3696 __ movprfx(z29.VnD(), p4.Merging(), z30.VnD());
3699 __ movprfx(z15.VnD(), p2.Merging(), z16.VnD());
3702 __ movprfx(z27.VnD(), p1.Merging(), z28.VnD());
3705 __ movprfx(z31.VnD(), p2.Merging(), z0.VnD());
3708 __ movprfx(z4.VnH(), p3.Merging(), z5.VnH());
3711 __ movprfx(z25.VnD(), p4.Merging(), z26.VnD());