Lines Matching refs:__
57 __ Mov(x29, sp);
60 __ Mov(x0, 0x1000);
61 __ Mov(sp, 0x1004);
64 __ Add(x1, x0, 0x1f7de);
65 __ Add(w2, w0, 0xffffff1);
66 __ Adds(x3, x0, 0x18001);
67 __ Adds(w4, w0, 0xffffff1);
68 __ Sub(x5, x0, 0x1f7de);
69 __ Sub(w6, w0, 0xffffff1);
70 __ Subs(x7, x0, 0x18001);
71 __ Subs(w8, w0, 0xffffff1);
74 __ And(x9, x0, 0x1f7de);
75 __ Orr(w10, w0, 0xffffff1);
76 __ Eor(x11, x0, 0x18001);
79 __ Add(sp, sp, 0x18001);
80 __ Mov(x12, sp);
81 __ Mov(sp, 0x1004);
83 __ Add(sp, sp, 0x1f7de);
84 __ Mov(x13, sp);
85 __ Mov(sp, 0x1004);
87 __ Adds(x14, sp, 0x1f7de);
89 __ Orr(sp, x0, 0x1f7de);
90 __ Mov(x15, sp);
93 __ Mov(sp, x29);
124 __ Mov(x29, sp);
127 __ Mov(sp, 0x1004);
128 __ Mov(x0, sp);
131 __ Add(sp, sp, 0x50);
132 __ Mov(x1, sp);
135 __ Mov(x17, 0xfff);
136 __ Add(sp, sp, Operand(x17, SXTB));
137 __ Mov(x2, sp);
140 __ Orr(sp, xzr, 0x1fff);
141 __ Mov(x3, sp);
144 __ Orr(wsp, wzr, 0xfffffff8);
145 __ Mov(x4, sp);
148 __ Orr(sp, xzr, 0xfffffff8);
149 __ Mov(w5, wsp);
153 __ Orr(wsp, w5, 0x1234);
154 __ Mov(w6, wsp);
157 __ Mov(sp, x29);
178 __ Mvn(w0, 0xfff);
179 __ Mvn(x1, 0xfff);
180 __ Mvn(w2, Operand(w0, LSL, 1));
181 __ Mvn(x3, Operand(x1, LSL, 2));
182 __ Mvn(w4, Operand(w0, LSR, 3));
183 __ Mvn(x5, Operand(x1, LSR, 4));
184 __ Mvn(w6, Operand(w0, ASR, 11));
185 __ Mvn(x7, Operand(x1, ASR, 12));
186 __ Mvn(w8, Operand(w0, ROR, 13));
187 __ Mvn(x9, Operand(x1, ROR, 14));
188 __ Mvn(w10, Operand(w2, UXTB));
189 __ Mvn(x11, Operand(x2, SXTB, 1));
190 __ Mvn(w12, Operand(w2, UXTH, 2));
191 __ Mvn(x13, Operand(x2, SXTH, 3));
192 __ Mvn(x14, Operand(w2, UXTW, 4));
193 __ Mvn(x15, Operand(w2, SXTW, 4));
223 __ Mov(w0, 0xffffffff);
224 __ Mov(w1, 0xffff1234);
225 __ Mov(w2, 0x1234ffff);
226 __ Mov(w3, 0x00000000);
227 __ Mov(w4, 0x00001234);
228 __ Mov(w5, 0x12340000);
229 __ Mov(w6, 0x12345678);
230 __ Mov(w7, (int32_t)0x80000000);
231 __ Mov(w8, (int32_t)0xffff0000);
232 __ Mov(w9, kWMinInt);
256 __ Mov(x0, 0xffffffffffffffff);
257 __ Mov(x1, 0xffffffffffff1234);
258 __ Mov(x2, 0xffffffff12345678);
259 __ Mov(x3, 0xffff1234ffff5678);
260 __ Mov(x4, 0x1234ffffffff5678);
261 __ Mov(x5, 0x1234ffff5678ffff);
262 __ Mov(x6, 0x12345678ffffffff);
263 __ Mov(x7, 0x1234ffffffffffff);
264 __ Mov(x8, 0x123456789abcffff);
265 __ Mov(x9, 0x12345678ffff9abc);
266 __ Mov(x10, 0x1234ffff56789abc);
267 __ Mov(x11, 0xffff123456789abc);
268 __ Mov(x12, 0x0000000000000000);
269 __ Mov(x13, 0x0000000000001234);
270 __ Mov(x14, 0x0000000012345678);
271 __ Mov(x15, 0x0000123400005678);
272 __ Mov(x18, 0x1234000000005678);
273 __ Mov(x19, 0x1234000056780000);
274 __ Mov(x20, 0x1234567800000000);
275 __ Mov(x21, 0x1234000000000000);
276 __ Mov(x22, 0x123456789abc0000);
277 __ Mov(x23, 0x1234567800009abc);
278 __ Mov(x24, 0x1234000056789abc);
279 __ Mov(x25, 0x0000123456789abc);
280 __ Mov(x26, 0x123456789abcdef0);
281 __ Mov(x27, 0xffff000000000001);
282 __ Mov(x28, 0x8000ffff00000000);
322 __ Mov(x0, 0xffffffffffffffff);
323 __ Mov(x1, 0xffffffffffffffff);
324 __ Mov(x2, 0xffffffffffffffff);
325 __ Mov(x3, 0xffffffffffffffff);
327 __ Mov(x0, 0x0123456789abcdef);
331 __ movz(x1, UINT64_C(0xabcd) << 16);
332 __ movk(x2, UINT64_C(0xabcd) << 32);
333 __ movn(x3, UINT64_C(0xabcd) << 48);
336 __ Mov(x4, 0x0123456789abcdef);
337 __ Mov(x5, x4);
339 __ Mov(w6, -1);
343 __ Mov(x7, 0x0123456789abcdef);
344 __ Mov(x7, x7);
345 __ Mov(x8, 0x0123456789abcdef);
346 __ Mov(w8, w8);
347 __ Mov(x9, 0x0123456789abcdef);
348 __ Mov(x9, Operand(x9));
349 __ Mov(x10, 0x0123456789abcdef);
350 __ Mov(w10, Operand(w10));
352 __ Mov(w11, 0xfff);
353 __ Mov(x12, 0xfff);
354 __ Mov(w13, Operand(w11, LSL, 1));
355 __ Mov(x14, Operand(x12, LSL, 2));
356 __ Mov(w15, Operand(w11, LSR, 3));
357 __ Mov(x18, Operand(x12, LSR, 4));
358 __ Mov(w19, Operand(w11, ASR, 11));
359 __ Mov(x20, Operand(x12, ASR, 12));
360 __ Mov(w21, Operand(w11, ROR, 13));
361 __ Mov(x22, Operand(x12, ROR, 14));
362 __ Mov(w23, Operand(w13, UXTB));
363 __ Mov(x24, Operand(x13, SXTB, 1));
364 __ Mov(w25, Operand(w13, UXTH, 2));
365 __ Mov(x26, Operand(x13, SXTH, 3));
366 __ Mov(x27, Operand(w13, UXTW, 4));
368 __ Mov(x28, 0x0123456789abcdef);
369 __ Mov(w28, w28, kDiscardForSameWReg);
409 __ Mov(w11, 0xffffffff);
410 __ Mov(x12, 0xffffffffffffffff);
412 __ Mov(w13, Operand(w11, LSL, 1));
413 __ Mov(w14, Operand(w11, LSR, 1));
414 __ Mov(w15, Operand(w11, ASR, 1));
415 __ Mov(w18, Operand(w11, ROR, 1));
416 __ Mov(w19, Operand(w11, UXTB, 1));
417 __ Mov(w20, Operand(w11, SXTB, 1));
418 __ Mov(w21, Operand(w11, UXTH, 1));
419 __ Mov(w22, Operand(w11, SXTH, 1));
421 __ Mov(x23, Operand(x12, LSL, 1));
422 __ Mov(x24, Operand(x12, LSR, 1));
423 __ Mov(x25, Operand(x12, ASR, 1));
424 __ Mov(x26, Operand(x12, ROR, 1));
425 __ Mov(x27, Operand(x12, UXTH, 1));
426 __ Mov(x28, Operand(x12, SXTH, 1));
427 __ Mov(x29, Operand(x12, UXTW, 1));
428 __ Mov(x30, Operand(x12, SXTW, 1));
459 __ Mov(x0, 0xf0f0);
460 __ Mov(x1, 0xf00000ff);
462 __ Orr(x2, x0, Operand(x1));
463 __ Orr(w3, w0, Operand(w1, LSL, 28));
464 __ Orr(x4, x0, Operand(x1, LSL, 32));
465 __ Orr(x5, x0, Operand(x1, LSR, 4));
466 __ Orr(w6, w0, Operand(w1, ASR, 4));
467 __ Orr(x7, x0, Operand(x1, ASR, 4));
468 __ Orr(w8, w0, Operand(w1, ROR, 12));
469 __ Orr(x9, x0, Operand(x1, ROR, 12));
470 __ Orr(w10, w0, 0xf);
471 __ Orr(x11, x0, 0xf0000000f0000000);
495 __ Mov(x0, 1);
496 __ Mov(x1, 0x8000000080008080);
497 __ Orr(w6, w0, Operand(w1, UXTB));
498 __ Orr(x7, x0, Operand(x1, UXTH, 1));
499 __ Orr(w8, w0, Operand(w1, UXTW, 2));
500 __ Orr(x9, x0, Operand(x1, UXTX, 3));
501 __ Orr(w10, w0, Operand(w1, SXTB));
502 __ Orr(x11, x0, Operand(x1, SXTH, 1));
503 __ Orr(x12, x0, Operand(x1, SXTW, 2));
504 __ Orr(x13, x0, Operand(x1, SXTX, 3));
526 __ Mov(x0, 0);
527 __ Mov(x1, 0xf0f0f0f0f0f0f0f0);
529 __ Orr(x10, x0, 0x1234567890abcdef);
530 __ Orr(w11, w1, 0x90abcdef);
532 __ Orr(w12, w0, kWMinInt);
533 __ Eor(w13, w0, kWMinInt);
553 __ Mov(x0, 0xf0f0);
554 __ Mov(x1, 0xf00000ff);
556 __ Orn(x2, x0, Operand(x1));
557 __ Orn(w3, w0, Operand(w1, LSL, 4));
558 __ Orn(x4, x0, Operand(x1, LSL, 4));
559 __ Orn(x5, x0, Operand(x1, LSR, 1));
560 __ Orn(w6, w0, Operand(w1, ASR, 1));
561 __ Orn(x7, x0, Operand(x1, ASR, 1));
562 __ Orn(w8, w0, Operand(w1, ROR, 16));
563 __ Orn(x9, x0, Operand(x1, ROR, 16));
564 __ Orn(w10, w0, 0x0000ffff);
565 __ Orn(x11, x0, 0x0000ffff0000ffff);
589 __ Mov(x0, 1);
590 __ Mov(x1, 0x8000000080008081);
591 __ Orn(w6, w0, Operand(w1, UXTB));
592 __ Orn(x7, x0, Operand(x1, UXTH, 1));
593 __ Orn(w8, w0, Operand(w1, UXTW, 2));
594 __ Orn(x9, x0, Operand(x1, UXTX, 3));
595 __ Orn(w10, w0, Operand(w1, SXTB));
596 __ Orn(x11, x0, Operand(x1, SXTH, 1));
597 __ Orn(x12, x0, Operand(x1, SXTW, 2));
598 __ Orn(x13, x0, Operand(x1, SXTX, 3));
620 __ Mov(x0, 0xfff0);
621 __ Mov(x1, 0xf00000ff);
623 __ And(x2, x0, Operand(x1));
624 __ And(w3, w0, Operand(w1, LSL, 4));
625 __ And(x4, x0, Operand(x1, LSL, 4));
626 __ And(x5, x0, Operand(x1, LSR, 1));
627 __ And(w6, w0, Operand(w1, ASR, 20));
628 __ And(x7, x0, Operand(x1, ASR, 20));
629 __ And(w8, w0, Operand(w1, ROR, 28));
630 __ And(x9, x0, Operand(x1, ROR, 28));
631 __ And(w10, w0, Operand(0xff00));
632 __ And(x11, x0, Operand(0xff));
656 __ Mov(x0, 0xffffffffffffffff);
657 __ Mov(x1, 0x8000000080008081);
658 __ And(w6, w0, Operand(w1, UXTB));
659 __ And(x7, x0, Operand(x1, UXTH, 1));
660 __ And(w8, w0, Operand(w1, UXTW, 2));
661 __ And(x9, x0, Operand(x1, UXTX, 3));
662 __ And(w10, w0, Operand(w1, SXTB));
663 __ And(x11, x0, Operand(x1, SXTH, 1));
664 __ And(x12, x0, Operand(x1, SXTW, 2));
665 __ And(x13, x0, Operand(x1, SXTX, 3));
687 __ Mov(x1, 0xf00000ff);
688 __ Ands(w0, w1, Operand(w1));
699 __ Mov(x0, 0xfff0);
700 __ Mov(x1, 0xf00000ff);
701 __ Ands(w0, w0, Operand(w1, LSR, 4));
712 __ Mov(x0, 0x8000000000000000);
713 __ Mov(x1, 0x00000001);
714 __ Ands(x0, x0, Operand(x1, ROR, 1));
725 __ Mov(x0, 0xfff0);
726 __ Ands(w0, w0, Operand(0xf));
737 __ Mov(x0, 0xff000000);
738 __ Ands(w0, w0, Operand(0x80000000));
754 __ Mov(x0, 0xfff0);
755 __ Mov(x1, 0xf00000ff);
757 __ Bic(x2, x0, Operand(x1));
758 __ Bic(w3, w0, Operand(w1, LSL, 4));
759 __ Bic(x4, x0, Operand(x1, LSL, 4));
760 __ Bic(x5, x0, Operand(x1, LSR, 1));
761 __ Bic(w6, w0, Operand(w1, ASR, 20));
762 __ Bic(x7, x0, Operand(x1, ASR, 20));
763 __ Bic(w8, w0, Operand(w1, ROR, 28));
764 __ Bic(x9, x0, Operand(x1, ROR, 24));
765 __ Bic(x10, x0, Operand(0x1f));
766 __ Bic(x11, x0, Operand(0x100));
772 __ Mov(x20, sp);
773 __ Mov(x0, 0xffffff);
774 __ Bic(sp, x0, Operand(0xabcdef));
775 __ Mov(x21, sp);
776 __ Mov(sp, x20);
802 __ Mov(x0, 0xffffffffffffffff);
803 __ Mov(x1, 0x8000000080008081);
804 __ Bic(w6, w0, Operand(w1, UXTB));
805 __ Bic(x7, x0, Operand(x1, UXTH, 1));
806 __ Bic(w8, w0, Operand(w1, UXTW, 2));
807 __ Bic(x9, x0, Operand(x1, UXTX, 3));
808 __ Bic(w10, w0, Operand(w1, SXTB));
809 __ Bic(x11, x0, Operand(x1, SXTH, 1));
810 __ Bic(x12, x0, Operand(x1, SXTW, 2));
811 __ Bic(x13, x0, Operand(x1, SXTX, 3));
833 __ Mov(x1, 0xffff);
834 __ Bics(w0, w1, Operand(w1));
845 __ Mov(x0, 0xffffffff);
846 __ Bics(w0, w0, Operand(w0, LSR, 1));
857 __ Mov(x0, 0x8000000000000000);
858 __ Mov(x1, 0x00000001);
859 __ Bics(x0, x0, Operand(x1, ROR, 1));
870 __ Mov(x0, 0xffffffffffffffff);
871 __ Bics(x0, x0, 0x7fffffffffffffff);
882 __ Mov(w0, 0xffff0000);
883 __ Bics(w0, w0, 0xfffffff0);
899 __ Mov(x0, 0xfff0);
900 __ Mov(x1, 0xf00000ff);
902 __ Eor(x2, x0, Operand(x1));
903 __ Eor(w3, w0, Operand(w1, LSL, 4));
904 __ Eor(x4, x0, Operand(x1, LSL, 4));
905 __ Eor(x5, x0, Operand(x1, LSR, 1));
906 __ Eor(w6, w0, Operand(w1, ASR, 20));
907 __ Eor(x7, x0, Operand(x1, ASR, 20));
908 __ Eor(w8, w0, Operand(w1, ROR, 28));
909 __ Eor(x9, x0, Operand(x1, ROR, 28));
910 __ Eor(w10, w0, 0xff00ff00);
911 __ Eor(x11, x0, 0xff00ff00ff00ff00);
934 __ Mov(x0, 0x1111111111111111);
935 __ Mov(x1, 0x8000000080008081);
936 __ Eor(w6, w0, Operand(w1, UXTB));
937 __ Eor(x7, x0, Operand(x1, UXTH, 1));
938 __ Eor(w8, w0, Operand(w1, UXTW, 2));
939 __ Eor(x9, x0, Operand(x1, UXTX, 3));
940 __ Eor(w10, w0, Operand(w1, SXTB));
941 __ Eor(x11, x0, Operand(x1, SXTH, 1));
942 __ Eor(x12, x0, Operand(x1, SXTW, 2));
943 __ Eor(x13, x0, Operand(x1, SXTX, 3));
965 __ Mov(x0, 0xfff0);
966 __ Mov(x1, 0xf00000ff);
968 __ Eon(x2, x0, Operand(x1));
969 __ Eon(w3, w0, Operand(w1, LSL, 4));
970 __ Eon(x4, x0, Operand(x1, LSL, 4));
971 __ Eon(x5, x0, Operand(x1, LSR, 1));
972 __ Eon(w6, w0, Operand(w1, ASR, 20));
973 __ Eon(x7, x0, Operand(x1, ASR, 20));
974 __ Eon(w8, w0, Operand(w1, ROR, 28));
975 __ Eon(x9, x0, Operand(x1, ROR, 28));
976 __ Eon(w10, w0, 0x03c003c0);
977 __ Eon(x11, x0, 0x0000100000001000);
1001 __ Mov(x0, 0x1111111111111111);
1002 __ Mov(x1, 0x8000000080008081);
1003 __ Eon(w6, w0, Operand(w1, UXTB));
1004 __ Eon(x7, x0, Operand(x1, UXTH, 1));
1005 __ Eon(w8, w0, Operand(w1, UXTW, 2));
1006 __ Eon(x9, x0, Operand(x1, UXTX, 3));
1007 __ Eon(w10, w0, Operand(w1, SXTB));
1008 __ Eon(x11, x0, Operand(x1, SXTH, 1));
1009 __ Eon(x12, x0, Operand(x1, SXTW, 2));
1010 __ Eon(x13, x0, Operand(x1, SXTX, 3));
1032 __ Mov(x25, 0);
1033 __ Mov(x26, 1);
1034 __ Mov(x18, 0xffffffff);
1035 __ Mov(x19, 0xffffffffffffffff);
1037 __ Mul(w0, w25, w25);
1038 __ Mul(w1, w25, w26);
1039 __ Mul(w2, w26, w18);
1040 __ Mul(w3, w18, w19);
1041 __ Mul(x4, x25, x25);
1042 __ Mul(x5, x26, x18);
1043 __ Mul(x6, x18, x19);
1044 __ Mul(x7, x19, x19);
1045 __ Smull(x8, w26, w18);
1046 __ Smull(x9, w18, w18);
1047 __ Smull(x10, w19, w19);
1048 __ Mneg(w11, w25, w25);
1049 __ Mneg(w12, w25, w26);
1050 __ Mneg(w13, w26, w18);
1051 __ Mneg(w14, w18, w19);
1052 __ Mneg(x20, x25, x25);
1053 __ Mneg(x21, x26, x18);
1054 __ Mneg(x22, x18, x19);
1055 __ Mneg(x23, x19, x19);
1087 __ Mov(w0, a);
1088 __ Mov(w1, b);
1089 __ Smull(x2, w0, w1);
1112 __ Mov(x16, 0);
1113 __ Mov(x17, 1);
1114 __ Mov(x18, 0xffffffff);
1115 __ Mov(x19, 0xffffffffffffffff);
1117 __ Madd(w0, w16, w16, w16);
1118 __ Madd(w1, w16, w16, w17);
1119 __ Madd(w2, w16, w16, w18);
1120 __ Madd(w3, w16, w16, w19);
1121 __ Madd(w4, w16, w17, w17);
1122 __ Madd(w5, w17, w17, w18);
1123 __ Madd(w6, w17, w17, w19);
1124 __ Madd(w7, w17, w18, w16);
1125 __ Madd(w8, w17, w18, w18);
1126 __ Madd(w9, w18, w18, w17);
1127 __ Madd(w10, w18, w19, w18);
1128 __ Madd(w11, w19, w19, w19);
1130 __ Madd(x12, x16, x16, x16);
1131 __ Madd(x13, x16, x16, x17);
1132 __ Madd(x14, x16, x16, x18);
1133 __ Madd(x15, x16, x16, x19);
1134 __ Madd(x20, x16, x17, x17);
1135 __ Madd(x21, x17, x17, x18);
1136 __ Madd(x22, x17, x17, x19);
1137 __ Madd(x23, x17, x18, x16);
1138 __ Madd(x24, x17, x18, x18);
1139 __ Madd(x25, x18, x18, x17);
1140 __ Madd(x26, x18, x19, x18);
1141 __ Madd(x27, x19, x19, x19);
1181 __ Mov(x16, 0);
1182 __ Mov(x17, 1);
1183 __ Mov(x18, 0xffffffff);
1184 __ Mov(x19, 0xffffffffffffffff);
1186 __ Msub(w0, w16, w16, w16);
1187 __ Msub(w1, w16, w16, w17);
1188 __ Msub(w2, w16, w16, w18);
1189 __ Msub(w3, w16, w16, w19);
1190 __ Msub(w4, w16, w17, w17);
1191 __ Msub(w5, w17, w17, w18);
1192 __ Msub(w6, w17, w17, w19);
1193 __ Msub(w7, w17, w18, w16);
1194 __ Msub(w8, w17, w18, w18);
1195 __ Msub(w9, w18, w18, w17);
1196 __ Msub(w10, w18, w19, w18);
1197 __ Msub(w11, w19, w19, w19);
1199 __ Msub(x12, x16, x16, x16);
1200 __ Msub(x13, x16, x16, x17);
1201 __ Msub(x14, x16, x16, x18);
1202 __ Msub(x15, x16, x16, x19);
1203 __ Msub(x20, x16, x17, x17);
1204 __ Msub(x21, x17, x17, x18);
1205 __ Msub(x22, x17, x17, x19);
1206 __ Msub(x23, x17, x18, x16);
1207 __ Msub(x24, x17, x18, x18);
1208 __ Msub(x25, x18, x18, x17);
1209 __ Msub(x26, x18, x19, x18);
1210 __ Msub(x27, x19, x19, x19);
1250 __ Mov(x20, 0);
1251 __ Mov(x21, 1);
1252 __ Mov(x22, 0x0000000100000000);
1253 __ Mov(x23, 0x0000000012345678);
1254 __ Mov(x24, 0x0123456789abcdef);
1255 __ Mov(x25, 0x0000000200000000);
1256 __ Mov(x26, 0x8000000000000000);
1257 __ Mov(x27, 0xffffffffffffffff);
1258 __ Mov(x28, 0x5555555555555555);
1259 __ Mov(x29, 0xaaaaaaaaaaaaaaaa);
1261 __ Smulh(x0, x20, x24);
1262 __ Smulh(x1, x21, x24);
1263 __ Smulh(x2, x22, x23);
1264 __ Smulh(x3, x22, x24);
1265 __ Smulh(x4, x24, x25);
1266 __ Smulh(x5, x23, x27);
1267 __ Smulh(x6, x26, x26);
1268 __ Smulh(x7, x26, x27);
1269 __ Smulh(x8, x27, x27);
1270 __ Smulh(x9, x28, x28);
1271 __ Smulh(x10, x28, x29);
1272 __ Smulh(x11, x29, x29);
1298 __ Mov(x20, 0);
1299 __ Mov(x21, 1);
1300 __ Mov(x22, 0x0000000100000000);
1301 __ Mov(x23, 0x0000000012345678);
1302 __ Mov(x24, 0x0123456789abcdef);
1303 __ Mov(x25, 0x0000000200000000);
1304 __ Mov(x26, 0x8000000000000000);
1305 __ Mov(x27, 0xffffffffffffffff);
1306 __ Mov(x28, 0x5555555555555555);
1307 __ Mov(x29, 0xaaaaaaaaaaaaaaaa);
1309 __ Umulh(x0, x20, x24);
1310 __ Umulh(x1, x21, x24);
1311 __ Umulh(x2, x22, x23);
1312 __ Umulh(x3, x22, x24);
1313 __ Umulh(x4, x24, x25);
1314 __ Umulh(x5, x23, x27);
1315 __ Umulh(x6, x26, x26);
1316 __ Umulh(x7, x26, x27);
1317 __ Umulh(x8, x27, x27);
1318 __ Umulh(x9, x28, x28);
1319 __ Umulh(x10, x28, x29);
1320 __ Umulh(x11, x29, x29);
1346 __ Mov(x17, 1);
1347 __ Mov(x18, 0x00000000ffffffff);
1348 __ Mov(x19, 0xffffffffffffffff);
1349 __ Mov(x20, 4);
1350 __ Mov(x21, 0x0000000200000000);
1352 __ Smaddl(x9, w17, w18, x20);
1353 __ Smaddl(x10, w18, w18, x20);
1354 __ Smaddl(x11, w19, w19, x20);
1355 __ Smaddl(x12, w19, w19, x21);
1356 __ Umaddl(x13, w17, w18, x20);
1357 __ Umaddl(x14, w18, w18, x20);
1358 __ Umaddl(x15, w19, w19, x20);
1359 __ Umaddl(x22, w19, w19, x21);
1360 __ Umull(x24, w19, w19);
1361 __ Umull(x25, w17, w18);
1385 __ Mov(x17, 1);
1386 __ Mov(x18, 0x00000000ffffffff);
1387 __ Mov(x19, 0xffffffffffffffff);
1388 __ Mov(x20, 4);
1389 __ Mov(x21, 0x0000000200000000);
1391 __ Smsubl(x9, w17, w18, x20);
1392 __ Smsubl(x10, w18, w18, x20);
1393 __ Smsubl(x11, w19, w19, x20);
1394 __ Smsubl(x12, w19, w19, x21);
1395 __ Umsubl(x13, w17, w18, x20);
1396 __ Umsubl(x14, w18, w18, x20);
1397 __ Umsubl(x15, w19, w19, x20);
1398 __ Umsubl(x22, w19, w19, x21);
1420 __ Mov(x16, 1);
1421 __ Mov(x17, 0xffffffff);
1422 __ Mov(x18, 0xffffffffffffffff);
1423 __ Mov(x19, 0x80000000);
1424 __ Mov(x20, 0x8000000000000000);
1425 __ Mov(x21, 2);
1427 __ Udiv(w0, w16, w16);
1428 __ Udiv(w1, w17, w16);
1429 __ Sdiv(w2, w16, w16);
1430 __ Sdiv(w3, w16, w17);
1431 __ Sdiv(w4, w17, w18);
1433 __ Udiv(x5, x16, x16);
1434 __ Udiv(x6, x17, x18);
1435 __ Sdiv(x7, x16, x16);
1436 __ Sdiv(x8, x16, x17);
1437 __ Sdiv(x9, x17, x18);
1439 __ Udiv(w10, w19, w21);
1440 __ Sdiv(w11, w19, w21);
1441 __ Udiv(x12, x19, x21);
1442 __ Sdiv(x13, x19, x21);
1443 __ Udiv(x14, x20, x21);
1444 __ Sdiv(x15, x20, x21);
1446 __ Udiv(w22, w19, w17);
1447 __ Sdiv(w23, w19, w17);
1448 __ Udiv(x24, x20, x18);
1449 __ Sdiv(x25, x20, x18);
1451 __ Udiv(x26, x16, x21);
1452 __ Sdiv(x27, x16, x21);
1453 __ Udiv(x28, x18, x21);
1454 __ Sdiv(x29, x18, x21);
1456 __ Mov(x17, 0);
1457 __ Udiv(w18, w16, w17);
1458 __ Sdiv(w19, w16, w17);
1459 __ Udiv(x20, x16, x17);
1460 __ Sdiv(x21, x16, x17);
1502 __ Mov(x24, 0xfedcba9876543210);
1503 __ Rbit(w0, w24);
1504 __ Rbit(x1, x24);
1505 __ Rev16(w2, w24);
1506 __ Rev16(x3, x24);
1507 __ Rev(w4, w24);
1508 __ Rev32(x5, x24);
1509 __ Rev64(x6, x24);
1510 __ Rev(x7, x24);
1544 __ Ldr(w0, 0x12345678);
1553 __ Nop();
1568 while (masm.GetCursorOffset() < end) __ nop();
1572 __ Bind(&label);
1595 __ Mov(x24, 0x0008000000800000);
1596 __ Mov(x25, 0xff800000fff80000);
1597 __ Mov(x26, 0);
1598 __ Clz(w0, w24);
1599 __ Clz(x1, x24);
1600 __ Clz(w2, w25);
1601 __ Clz(x3, x25);
1602 __ Clz(w4, w26);
1603 __ Clz(x5, x26);
1604 __ Cls(w6, w24);
1605 __ Cls(x7, x24);
1606 __ Cls(w8, w25);
1607 __ Cls(x9, x25);
1608 __ Cls(w10, w26);
1609 __ Cls(x11, x26);
1639 __ Mov(pointer, 0x0000000012345678);
1640 __ Mov(modifier, 0x477d469dec0b8760);
1643 __ Mov(x0, pointer);
1644 __ Pacia(x0, modifier);
1646 __ Mov(x1, pointer);
1647 __ Pacib(x1, modifier);
1650 __ Mov(x2, x0);
1651 __ Autia(x2, modifier);
1653 __ Mov(x3, x1);
1654 __ Autib(x3, modifier);
1657 __ Mov(x4, x1);
1658 __ Autia(x4, modifier);
1660 __ Mov(x5, x0);
1661 __ Autib(x5, modifier);
1665 __ And(x0, x0, 0x007f000000000000);
1666 __ And(x1, x1, 0x007f000000000000);
1698 __ Mov(pointer, 0x0000000012345678);
1701 __ Mov(x0, pointer);
1702 __ Paciza(x0);
1704 __ Mov(x1, pointer);
1705 __ Pacizb(x1);
1708 __ Mov(x2, x0);
1709 __ Autiza(x2);
1711 __ Mov(x3, x1);
1712 __ Autizb(x3);
1715 __ Mov(x4, x1);
1716 __ Autiza(x4);
1718 __ Mov(x5, x0);
1719 __ Autizb(x5);
1723 __ And(x0, x0, 0x007f000000000000);
1724 __ And(x1, x1, 0x007f000000000000);
1757 __ Mov(pointer, 0x0000000012345678);
1758 __ Mov(modifier, 0x477d469dec0b8760);
1761 __ Mov(x0, pointer);
1762 __ Pacda(x0, modifier);
1764 __ Mov(x1, pointer);
1765 __ Pacdb(x1, modifier);
1768 __ Mov(x2, x0);
1769 __ Autda(x2, modifier);
1771 __ Mov(x3, x1);
1772 __ Autdb(x3, modifier);
1775 __ Mov(x4, x1);
1776 __ Autda(x4, modifier);
1778 __ Mov(x5, x0);
1779 __ Autdb(x5, modifier);
1783 __ And(x0, x0, 0x007f000000000000);
1784 __ And(x1, x1, 0x007f000000000000);
1816 __ Mov(pointer, 0x0000000012345678);
1819 __ Mov(x0, pointer);
1820 __ Pacdza(x0);
1822 __ Mov(x1, pointer);
1823 __ Pacdzb(x1);
1826 __ Mov(x2, x0);
1827 __ Autdza(x2);
1829 __ Mov(x3, x1);
1830 __ Autdzb(x3);
1833 __ Mov(x4, x1);
1834 __ Autdza(x4);
1836 __ Mov(x5, x0);
1837 __ Autdzb(x5);
1841 __ And(x0, x0, 0x007f000000000000);
1842 __ And(x1, x1, 0x007f000000000000);
1875 __ Mov(pointer, 0x0000000012345678);
1876 __ Mov(modifier, 0x477d469dec0b8760);
1879 __ Pacga(x0, pointer, modifier);
1882 __ Mov(x1, pointer);
1883 __ Mov(x2, pointer);
1884 __ Pacia(x1, modifier);
1885 __ Pacda(x2, modifier);
1888 __ Mov(x3, x1);
1889 __ Mov(x4, x2);
1890 __ Xpaci(x3);
1891 __ Xpacd(x4);
1895 __ And(x0, x0, 0xffffffff00000000);
1896 __ And(x1, x1, 0x007f000000000000);
1897 __ And(x2, x2, 0x007f000000000000);
1924 __ Mov(x0, 0x0000000012345678);
1925 __ Mov(x1, x0);
1926 __ Mov(x10, sp);
1929 __ Pacia(x0, x10);
1930 __ Pacia(x1, sp);
1933 __ Mov(x2, x0);
1934 __ Mov(x3, x1);
1935 __ Autia(x2, sp);
1936 __ Autia(x3, x10);
1954 __ Mov(x0, 0x1);
1955 __ Mov(x1, 0x0);
1956 __ Mov(x22, lr); // Save lr.
1958 __ B(&label_1);
1959 __ B(&label_1);
1960 __ B(&label_1); // Multiple branches to the same label.
1961 __ Mov(x0, 0x0);
1962 __ Bind(&label_2);
1963 __ B(&label_3); // Forward branch.
1964 __ Mov(x0, 0x0);
1965 __ Bind(&label_1);
1966 __ B(&label_2); // Backward branch.
1967 __ Mov(x0, 0x0);
1968 __ Bind(&label_3);
1969 __ Bl(&label_4);
1972 __ Bind(&label_4);
1973 __ Mov(x1, 0x1);
1974 __ Mov(lr, x22);
1993 __ Mov(x0, 0x0);
1995 __ B(&label_1);
1997 __ Orr(x0, x0, 1 << 1);
1998 __ B(&label_3);
2000 __ Orr(x0, x0, 1 << 0);
2001 __ B(&label_2);
2003 __ Tbz(x0, 2, &first_jump_to_3);
2004 __ Orr(x0, x0, 1 << 3);
2005 __ Bind(&first_jump_to_3);
2006 __ Orr(x0, x0, 1 << 2);
2007 __ Tbz(x0, 3, &label_3);
2032 __ Mov(x0, 0x0); // Set to non-zero to indicate failure.
2033 __ Adr(x1, &label_3); // Set to zero to indicate success.
2035 __ Adr(x2, &label_1); // Multiple forward references to the same label.
2036 __ Adr(x3, &label_1);
2037 __ Adr(x4, &label_1);
2039 __ Bind(&label_2);
2040 __ Eor(x5, x2, Operand(x3)); // Ensure that x2,x3 and x4 are identical.
2041 __ Eor(x6, x2, Operand(x4));
2042 __ Orr(x0, x0, Operand(x5));
2043 __ Orr(x0, x0, Operand(x6));
2044 __ Br(x2); // label_1, label_3
2046 __ Bind(&label_3);
2047 __ Adr(x2, &label_3); // Self-reference (offset 0).
2048 __ Eor(x1, x1, Operand(x2));
2049 __ Adr(x2, &label_4); // Simple forward reference.
2050 __ Br(x2); // label_4
2052 __ Bind(&label_1);
2053 __ Adr(x2, &label_3); // Multiple reverse references to the same label.
2054 __ Adr(x3, &label_3);
2055 __ Adr(x4, &label_3);
2056 __ Adr(x5, &label_2); // Simple reverse reference.
2057 __ Br(x5); // label_2
2059 __ Bind(&label_4);
2088 __ b(&start);
2090 __ bind(&start);
2094 __ Adrp(x0, &label_2);
2096 __ Bind(&label_1);
2099 __ Adrp(x1, &label_3);
2100 __ Adrp(x2, &label_3);
2101 __ Adrp(x3, &label_3);
2103 __ Bind(&label_2);
2106 __ Adrp(x4, &label_2);
2108 __ Bind(&label_3);
2111 __ Adrp(x5, &label_1);
2114 __ Adrp(x6, &label_2);
2115 __ Adrp(x7, &label_2);
2116 __ Adrp(x8, &label_2);
2161 __ cmp(wzr, wzr);
2164 __ b(&start);
2171 __ bind(&start);
2172 __ adrp(x0, &test);
2173 __ adrp(x1, &test);
2175 __ ccmp(x0, x1, NoFlag, eq);
2176 __ adrp(x1, &test);
2186 if (i++ == (offset_into_page / kInstructionSize)) __ bind(&test);
2187 __ ccmp(x0, x1, NoFlag, eq);
2188 if (i++ == (offset_into_page / kInstructionSize)) __ bind(&test);
2189 __ adrp(x1, &test);
2193 __ ccmp(x0, x1, NoFlag, eq);
2194 __ adrp(x1, &test);
2241 __ cmp(wzr, wzr);
2244 __ b(&page);
2246 __ bind(&page);
2251 __ adrp(x0, offset);
2252 __ adrp(x1, offset);
2254 __ ccmp(x0, x1, NoFlag, eq);
2255 __ adrp(x1, offset);
2292 __ Mov(x0, 0x1);
2293 __ Mov(x1, 0x1);
2294 __ Mov(x2, 0x8000000000000000);
2299 __ Cmp(x1, 0);
2300 __ B(&wrong, eq);
2301 __ B(&wrong, lo);
2302 __ B(&wrong, mi);
2303 __ B(&wrong, vs);
2304 __ B(&wrong, ls);
2305 __ B(&wrong, lt);
2306 __ B(&wrong, le);
2308 __ B(&ok_1, ne);
2309 __ Mov(x0, 0x0);
2310 __ Bind(&ok_1);
2312 __ Cmp(x1, 1);
2313 __ B(&wrong, ne);
2314 __ B(&wrong, lo);
2315 __ B(&wrong, mi);
2316 __ B(&wrong, vs);
2317 __ B(&wrong, hi);
2318 __ B(&wrong, lt);
2319 __ B(&wrong, gt);
2321 __ B(&ok_2, pl);
2322 __ Mov(x0, 0x0);
2323 __ Bind(&ok_2);
2325 __ Cmp(x1, 2);
2326 __ B(&wrong, eq);
2327 __ B(&wrong, hs);
2328 __ B(&wrong, pl);
2329 __ B(&wrong, vs);
2330 __ B(&wrong, hi);
2331 __ B(&wrong, ge);
2332 __ B(&wrong, gt);
2334 __ B(&ok_3, vc);
2335 __ Mov(x0, 0x0);
2336 __ Bind(&ok_3);
2338 __ Cmp(x2, 1);
2339 __ B(&wrong, eq);
2340 __ B(&wrong, lo);
2341 __ B(&wrong, mi);
2342 __ B(&wrong, vc);
2343 __ B(&wrong, ls);
2344 __ B(&wrong, ge);
2345 __ B(&wrong, gt);
2347 __ B(&ok_4, le);
2348 __ Mov(x0, 0x0);
2349 __ Bind(&ok_4);
2355 __ b(&ok_5, al);
2357 __ Mov(x0, 0x0);
2358 __ Bind(&ok_5);
2364 __ b(&ok_6, nv);
2366 __ Mov(x0, 0x0);
2367 __ Bind(&ok_6);
2369 __ B(&done);
2371 __ Bind(&wrong);
2372 __ Mov(x0, 0x0);
2374 __ Bind(&done);
2392 __ Mov(x29, lr);
2394 __ Mov(x1, 0);
2395 __ B(&after_fn1);
2397 __ Bind(&fn1);
2398 __ Mov(x0, lr);
2399 __ Mov(x1, 42);
2400 __ Br(x0);
2402 __ Bind(&after_fn1);
2403 __ Bl(&fn1);
2408 __ Mov(x2, 0);
2409 __ B(&after_fn2);
2411 __ Bind(&fn2);
2412 __ Mov(x0, lr);
2413 __ Mov(x2, 84);
2414 __ Blr(x0);
2416 __ Bind(&after_fn2);
2417 __ Bl(&fn2);
2418 __ Bind(&after_bl2);
2419 __ Mov(x3, lr);
2420 __ Adr(x4, &after_bl2);
2421 __ Adr(x5, &after_fn2);
2423 __ Mov(lr, x29);
2443 __ Mov(x28, 0x477d469dec0b8760);
2444 __ Mov(x29, lr);
2446 __ Mov(x1, 0);
2447 __ B(&after_fn1);
2449 __ Bind(&fn1);
2450 __ Mov(x0, lr);
2451 __ Mov(x1, 42);
2452 __ Pacia(x0, x28);
2453 __ Braa(x0, x28);
2455 __ Bind(&after_fn1);
2456 __ Bl(&fn1);
2460 __ Mov(x2, 0);
2461 __ B(&after_fn2);
2463 __ Bind(&fn2);
2464 __ Mov(x0, lr);
2465 __ Mov(x2, 84);
2466 __ Pacia(x0, x28);
2467 __ Blraa(x0, x28);
2469 __ Bind(&after_fn2);
2470 __ Bl(&fn2);
2471 __ Bind(&after_bl2);
2472 __ Mov(x3, lr);
2473 __ Adr(x4, &after_bl2);
2474 __ Adr(x5, &after_fn2);
2476 __ Xpaci(x0);
2477 __ Mov(lr, x29);
2497 __ Mov(x28, sp);
2498 __ Mov(x29, lr);
2499 __ Mov(sp, 0x477d469dec0b8760);
2501 __ Mov(x0, 0);
2502 __ B(&after_fn1);
2504 __ Bind(&fn1);
2505 __ Mov(x0, 42);
2506 __ Paciasp();
2507 __ Retaa();
2509 __ Bind(&after_fn1);
2510 __ Bl(&fn1);
2514 __ Mov(x1, 0);
2515 __ B(&after_fn2);
2517 __ Bind(&fn2);
2518 __ Mov(x1, 84);
2519 __ Pacibsp();
2520 __ Retab();
2522 __ Bind(&after_fn2);
2523 __ Bl(&fn2);
2525 __ Mov(sp, x28);
2526 __ Mov(lr, x29);
2544 __ Mov(x28, sp);
2545 __ Mov(x29, lr);
2546 __ Mov(sp, 0x477d469dec0b8760);
2548 __ Mov(x0, 0);
2549 __ B(&after_fn1);
2551 __ Bind(&fn1, EmitPACIASP);
2552 __ Mov(x0, 42);
2553 __ Retaa();
2555 __ Bind(&after_fn1);
2556 __ Adr(x2, &fn1);
2557 __ Blr(x2);
2561 __ Mov(x1, 0);
2562 __ B(&after_fn2);
2564 __ Bind(&fn2, EmitPACIBSP);
2565 __ Mov(x1, 84);
2566 __ Retab();
2568 __ Bind(&after_fn2);
2569 __ Adr(x2, &fn2);
2570 __ Blr(x2);
2572 __ Mov(sp, x28);
2573 __ Mov(lr, x29);
2597 __ Mov(x29, lr);
2599 __ B(&after_fn1);
2601 __ Bind(&fn1);
2602 __ Mov(x0, lr);
2603 __ Pacizb(x0);
2604 __ Blraaz(x0);
2606 __ Bind(&after_fn1);
2611 __ Bl(&fn1);
2614 __ Mov(lr, x29);
2631 __ Mov(x28, sp);
2632 __ Mov(x29, lr);
2633 __ Mov(sp, 0x477d469dec0b8760);
2635 __ B(&after_fn1);
2637 __ Bind(&fn1);
2638 __ Paciasp();
2639 __ Retab();
2641 __ Bind(&after_fn1);
2646 __ Bl(&fn1);
2649 __ Mov(sp, x28);
2650 __ Mov(lr, x29);
2666 __ Mov(x29, lr);
2668 __ Mov(x1, 0);
2669 __ B(&after_fn1);
2671 __ Bind(&fn1);
2672 __ Mov(x0, lr);
2673 __ Mov(x1, 42);
2674 __ Paciza(x0);
2675 __ Braaz(x0);
2677 __ Bind(&after_fn1);
2678 __ Bl(&fn1);
2682 __ Mov(x2, 0);
2683 __ B(&after_fn2);
2685 __ Bind(&fn2);
2686 __ Mov(x0, lr);
2687 __ Mov(x2, 84);
2688 __ Paciza(x0);
2689 __ Blraaz(x0);
2691 __ Bind(&after_fn2);
2692 __ Bl(&fn2);
2693 __ Bind(&after_bl2);
2694 __ Mov(x3, lr);
2695 __ Adr(x4, &after_bl2);
2696 __ Adr(x5, &after_fn2);
2698 __ Xpaci(x0);
2699 __ Mov(lr, x29);
2717 __ Mov(x0, 0);
2718 __ Mov(x1, 0);
2719 __ Mov(x2, 0);
2720 __ Mov(x3, 0);
2721 __ Mov(x4, 0);
2722 __ Mov(x5, 0);
2723 __ Mov(x16, 0);
2724 __ Mov(x17, 42);
2727 __ Cbz(w16, &zt);
2728 __ B(&zt_end);
2729 __ Bind(&zt);
2730 __ Mov(x0, 1);
2731 __ Bind(&zt_end);
2734 __ Cbz(x17, &zf);
2735 __ B(&zf_end);
2736 __ Bind(&zf);
2737 __ Mov(x1, 1);
2738 __ Bind(&zf_end);
2741 __ Cbnz(w17, &nzt);
2742 __ B(&nzt_end);
2743 __ Bind(&nzt);
2744 __ Mov(x2, 1);
2745 __ Bind(&nzt_end);
2748 __ Cbnz(x16, &nzf);
2749 __ B(&nzf_end);
2750 __ Bind(&nzf);
2751 __ Mov(x3, 1);
2752 __ Bind(&nzf_end);
2754 __ Mov(x18, 0xffffffff00000000);
2757 __ Cbz(w18, &a);
2758 __ B(&a_end);
2759 __ Bind(&a);
2760 __ Mov(x4, 1);
2761 __ Bind(&a_end);
2764 __ Cbnz(w18, &b);
2765 __ B(&b_end);
2766 __ Bind(&b);
2767 __ Mov(x5, 1);
2768 __ Bind(&b_end);
2789 __ Mov(x0, 0);
2790 __ Mov(x1, 0);
2791 __ Mov(x2, 0);
2792 __ Mov(x3, 0);
2793 __ Mov(x16, 0xaaaaaaaaaaaaaaaa);
2796 __ Tbz(w16, 0, &bz);
2797 __ B(&bz_end);
2798 __ Bind(&bz);
2799 __ Mov(x0, 1);
2800 __ Bind(&bz_end);
2803 __ Tbz(x16, 63, &bo);
2804 __ B(&bo_end);
2805 __ Bind(&bo);
2806 __ Mov(x1, 1);
2807 __ Bind(&bo_end);
2810 __ Tbnz(x16, 61, &nbz);
2811 __ B(&nbz_end);
2812 __ Bind(&nbz);
2813 __ Mov(x2, 1);
2814 __ Bind(&nbz_end);
2817 __ Tbnz(w16, 2, &nbo);
2818 __ B(&nbo_end);
2819 __ Bind(&nbo);
2820 __ Mov(x3, 1);
2821 __ Bind(&nbo_end);
2841 __ Mov(x0, 0x0);
2842 __ Mov(x10, 0x7);
2843 __ Mov(x11, 0x0);
2846 __ Cmp(x10, 0x7);
2847 __ B(&fail, ne);
2848 __ B(&fail, never);
2849 __ B(&fail, reg_zero, x10);
2850 __ B(&fail, reg_not_zero, x11);
2851 __ B(&fail, reg_bit_clear, x10, 0);
2852 __ B(&fail, reg_bit_set, x10, 3);
2856 __ Cmp(x10, 0x7);
2857 __ B(&l1, eq);
2858 __ B(&fail);
2859 __ Bind(&l1);
2860 __ B(&l2, always);
2861 __ B(&fail);
2862 __ Bind(&l2);
2863 __ B(&l3, reg_not_zero, x10);
2864 __ B(&fail);
2865 __ Bind(&l3);
2866 __ B(&l4, reg_bit_clear, x10, 15);
2867 __ B(&fail);
2868 __ Bind(&l4);
2869 __ B(&l5, reg_bit_set, x10, 1);
2870 __ B(&fail);
2871 __ Bind(&l5);
2873 __ B(&done);
2875 __ Bind(&fail);
2876 __ Mov(x0, 0x1);
2878 __ Bind(&done);
2908 __ Ldr(x9, MemOperand(reg, off));
2909 __ Add(x10, x9, x10);
2916 __ Mov(XRegister(i), 0);
2940 __ Mov(base, reinterpret_cast<uint64_t>(&data_ptr[data_size / 2]));
2951 __ Mov(XRegister(i), tag);
2956 __ Bic(base_tag, base, 0x0f00000000000000);
2957 __ Orr(base_tag, base_tag, XRegister(i));
2961 __ Ldg(XRegister(i + 10), MemOperand(base_tag, offset));
2964 __ Ldg(XRegister(i + 20), MemOperand(base_tag, offset + tag_granule));
2970 __ Ldg(XRegister(i + 10), MemOperand(base_tag));
2973 __ Ldg(XRegister(i + 20), MemOperand(base_tag, tag_granule));
2979 __ Ldg(XRegister(i + 10), MemOperand(base_tag, -offset));
2982 __ Ldg(XRegister(i + 20),
3001 __ Mov(x7, sp);
3002 __ Mov(base_tag, base);
3005 __ Mov(x8, 11UL << tag_lsb);
3006 __ Mov(sp, x8);
3010 __ Add(sp, base_tag, 32);
3015 __ Ldg(x17, MemOperand(base, neg_offset));
3016 __ Ldg(x19, MemOperand(sp, pos_offset));
3018 __ Ldg(x18, MemOperand(base, neg_offset + tag_granule));
3019 __ Ldg(x20, MemOperand(sp, pos_offset + tag_granule));
3023 __ Ldg(x17, MemOperand(base));
3024 __ Ldg(x19, MemOperand(sp));
3026 __ Ldg(x18, MemOperand(base, tag_granule));
3027 __ Ldg(x20, MemOperand(sp, tag_granule));
3031 __ Ldg(x17, MemOperand(base, -neg_offset));
3032 __ Ldg(x19, MemOperand(sp, -pos_offset));
3034 __ Ldg(x18, MemOperand(base, -neg_offset + tag_granule));
3035 __ Ldg(x20, MemOperand(sp, -pos_offset + tag_granule));
3044 __ Mov(sp, x7);
3114 __ Mov(XRegister(i), 0);
3119 __ Ldr(x14, MemOperand(reg, off));
3120 __ Add(x15, x14, x15);
3121 __ Ldr(x14, MemOperand(reg, off + static_cast<int>(kXRegSizeInBytes)));
3122 __ Add(x15, x14, x15);
3147 __ Mov(base, reinterpret_cast<uint64_t>(&data_ptr[data_size / 2]));
3154 __ Mov(XRegister(i), i | (static_cast<uint64_t>(i) << tag_lsb));
3158 __ Mov(x0, sp);
3161 __ Addg(base, base, 0, 1);
3162 __ Stgp(x1, x2, MemOperand(base, offset, Offset));
3164 __ Add(x29, base, 8);
3165 __ Ldg(x18, MemOperand(x29, offset));
3169 __ Addg(base, base, 0, 1);
3170 __ Stgp(x2, x3, MemOperand(base, offset, Offset));
3171 __ Add(x29, base, 4);
3172 __ Ldg(x19, MemOperand(x29, offset));
3176 __ Addg(base, base, 0, 1);
3177 __ Stgp(x3, x4, MemOperand(base, offset, Offset));
3178 __ Mov(sp, base);
3179 __ Ldg(x20, MemOperand(sp, offset));
3183 __ Addg(base, base, 0, 1);
3184 __ Stgp(x4, x5, MemOperand(base, offset, PreIndex));
3185 __ Add(x29, base, 8);
3186 __ Ldg(x21, MemOperand(x29));
3190 __ Addg(base, base, 0, 1);
3191 __ Stgp(x5, x6, MemOperand(base, offset, PreIndex));
3192 __ Add(x29, base, 4);
3193 __ Ldg(x22, MemOperand(x29));
3197 __ Addg(base, base, 0, 1);
3198 __ Stgp(x6, x7, MemOperand(base, offset, PreIndex));
3199 __ Mov(sp, base);
3200 __ Ldg(x23, MemOperand(sp));
3204 __ Addg(base, base, 0, 1);
3205 __ Stgp(x7, x8, MemOperand(base, offset, PostIndex));
3206 __ Add(x29, base, 8);
3207 __ Ldg(x24, MemOperand(x29, -offset));
3211 __ Addg(base, base, 0, 1);
3212 __ Stgp(x8, x9, MemOperand(base, offset, PostIndex));
3213 __ Add(x29, base, 4);
3214 __ Ldg(x25, MemOperand(x29, -offset));
3218 __ Addg(base, base, 0, 1);
3219 __ Stgp(x9, x10, MemOperand(base, offset, PostIndex));
3220 __ Mov(sp, base);
3221 __ Ldg(x26, MemOperand(sp, -offset));
3224 __ Mov(sp, x0);
3265 __ Mov(x17, src_base);
3266 __ Mov(x18, dst_base);
3267 __ Ldr(w0, MemOperand(x17));
3268 __ Str(w0, MemOperand(x18));
3269 __ Ldr(w1, MemOperand(x17, 4));
3270 __ Str(w1, MemOperand(x18, 12));
3271 __ Ldr(x2, MemOperand(x17, 8));
3272 __ Str(x2, MemOperand(x18, 16));
3273 __ Ldrb(w3, MemOperand(x17, 1));
3274 __ Strb(w3, MemOperand(x18, 25));
3275 __ Ldrh(w4, MemOperand(x17, 2));
3276 __ Strh(w4, MemOperand(x18, 33));
3312 __ Mov(x22, src_base);
3313 __ Mov(x23, dst_base);
3314 __ Mov(x24, src_base);
3315 __ Mov(x25, dst_base);
3316 __ Mov(x26, src_base);
3317 __ Mov(x27, dst_base);
3319 __ Ldr(w0, MemOperand(x22, 8191 * sizeof(src[0])));
3320 __ Str(w0, MemOperand(x23, 8191 * sizeof(dst[0])));
3321 __ Ldr(w1, MemOperand(x24, 4096 * sizeof(src[0]), PostIndex));
3322 __ Str(w1, MemOperand(x25, 4096 * sizeof(dst[0]), PostIndex));
3323 __ Ldr(w2, MemOperand(x26, 6144 * sizeof(src[0]), PreIndex));
3324 __ Str(w2, MemOperand(x27, 6144 * sizeof(dst[0]), PreIndex));
3355 __ Mov(x17, src_base);
3356 __ Mov(x18, dst_base);
3357 __ Mov(x19, src_base);
3358 __ Mov(x20, dst_base);
3359 __ Mov(x21, src_base + 16);
3360 __ Mov(x22, dst_base + 40);
3361 __ Mov(x23, src_base);
3362 __ Mov(x24, dst_base);
3363 __ Mov(x25, src_base);
3364 __ Mov(x26, dst_base);
3365 __ Ldr(w0, MemOperand(x17, 4, PreIndex));
3366 __ Str(w0, MemOperand(x18, 12, PreIndex));
3367 __ Ldr(x1, MemOperand(x19, 8, PreIndex));
3368 __ Str(x1, MemOperand(x20, 16, PreIndex));
3369 __ Ldr(w2, MemOperand(x21, -4, PreIndex));
3370 __ Str(w2, MemOperand(x22, -4, PreIndex));
3371 __ Ldrb(w3, MemOperand(x23, 1, PreIndex));
3372 __ Strb(w3, MemOperand(x24, 25, PreIndex));
3373 __ Ldrh(w4, MemOperand(x25, 3, PreIndex));
3374 __ Strh(w4, MemOperand(x26, 41, PreIndex));
3413 __ Mov(x17, src_base + 4);
3414 __ Mov(x18, dst_base + 12);
3415 __ Mov(x19, src_base + 8);
3416 __ Mov(x20, dst_base + 16);
3417 __ Mov(x21, src_base + 8);
3418 __ Mov(x22, dst_base + 32);
3419 __ Mov(x23, src_base + 1);
3420 __ Mov(x24, dst_base + 25);
3421 __ Mov(x25, src_base + 3);
3422 __ Mov(x26, dst_base + 41);
3423 __ Ldr(w0, MemOperand(x17, 4, PostIndex));
3424 __ Str(w0, MemOperand(x18, 12, PostIndex));
3425 __ Ldr(x1, MemOperand(x19, 8, PostIndex));
3426 __ Str(x1, MemOperand(x20, 16, PostIndex));
3427 __ Ldr(x2, MemOperand(x21, -8, PostIndex));
3428 __ Str(x2, MemOperand(x22, -32, PostIndex));
3429 __ Ldrb(w3, MemOperand(x23, 1, PostIndex));
3430 __ Strb(w3, MemOperand(x24, 5, PostIndex));
3431 __ Ldrh(w4, MemOperand(x25, -3, PostIndex));
3432 __ Strh(w4, MemOperand(x26, -41, PostIndex));
3477 __ Mov(x19, drifted_addr);
3478 __ Ldr(x0, MemOperand(x19, largeoffset, PreIndex));
3480 __ Mov(x20, base_addr);
3481 __ Ldr(x1, MemOperand(x20, largeoffset, PostIndex));
3483 __ Mov(x21, drifted_addr);
3484 __ Str(x0, MemOperand(x21, largeoffset + 8, PreIndex));
3486 __ Mov(x22, base_addr + 16);
3487 __ Str(x0, MemOperand(x22, largeoffset, PostIndex));
3514 __ Mov(x24, src_base);
3515 __ Ldrsb(w0, MemOperand(x24));
3516 __ Ldrsb(w1, MemOperand(x24, 4));
3517 __ Ldrsh(w2, MemOperand(x24));
3518 __ Ldrsh(w3, MemOperand(x24, 4));
3519 __ Ldrsb(x4, MemOperand(x24));
3520 __ Ldrsb(x5, MemOperand(x24, 4));
3521 __ Ldrsh(x6, MemOperand(x24));
3522 __ Ldrsh(x7, MemOperand(x24, 4));
3523 __ Ldrsw(x8, MemOperand(x24));
3524 __ Ldrsw(x9, MemOperand(x24, 4));
3553 __ Mov(x16, src_base);
3554 __ Mov(x17, dst_base);
3555 __ Mov(x18, src_base + 3 * sizeof(src[0]));
3556 __ Mov(x19, dst_base + 3 * sizeof(dst[0]));
3557 __ Mov(x20, dst_base + 4 * sizeof(dst[0]));
3558 __ Mov(x24, 0);
3559 __ Mov(x25, 4);
3560 __ Mov(x26, -4);
3561 __ Mov(x27, 0xfffffffc); // 32-bit -4.
3562 __ Mov(x28, 0xfffffffe); // 32-bit -2.
3563 __ Mov(x29, 0xffffffff); // 32-bit -1.
3565 __ Ldr(w0, MemOperand(x16, x24));
3566 __ Ldr(x1, MemOperand(x16, x25));
3567 __ Ldr(w2, MemOperand(x18, x26));
3568 __ Ldr(w3, MemOperand(x18, x27, SXTW));
3569 __ Ldr(w4, MemOperand(x18, x28, SXTW, 2));
3570 __ Str(w0, MemOperand(x17, x24));
3571 __ Str(x1, MemOperand(x17, x25));
3572 __ Str(w2, MemOperand(x20, x29, SXTW, 2));
3598 __ Mov(x16, src_base);
3599 __ Mov(x17, src_base);
3600 __ Mov(x18, src_base + 4 * sizeof(src[0]));
3601 __ Mov(x19, src_base + 4 * sizeof(src[0]));
3604 __ Pacdza(x16);
3605 __ Pacdzb(x17);
3606 __ Pacdza(x18);
3607 __ Pacdzb(x19);
3609 __ Ldraa(x0, MemOperand(x16));
3610 __ Ldraa(x1, MemOperand(x16, sizeof(src[0])));
3611 __ Ldraa(x2, MemOperand(x16, 2 * sizeof(src[0]), PreIndex));
3612 __ Ldraa(x3, MemOperand(x18, -sizeof(src[0])));
3613 __ Ldrab(x4, MemOperand(x17));
3614 __ Ldrab(x5, MemOperand(x17, sizeof(src[0])));
3615 __ Ldrab(x6, MemOperand(x17, 2 * sizeof(src[0]), PreIndex));
3616 __ Ldrab(x7, MemOperand(x19, -sizeof(src[0])));
3644 __ Mov(x16, src_base);
3650 __ Add(x17, x16, i);
3651 __ Pacdza(x17);
3652 __ Ldrab(x0, MemOperand(x17));
3674 __ Mov(x16, src_base);
3675 __ Mov(x17, dst_base);
3676 __ Mov(x18, src_base + 24);
3677 __ Mov(x19, dst_base + 56);
3678 __ Ldp(w0, w1, MemOperand(x16));
3679 __ Ldp(w2, w3, MemOperand(x16, 4));
3680 __ Ldp(x4, x5, MemOperand(x16, 8));
3681 __ Ldp(w6, w7, MemOperand(x18, -12));
3682 __ Ldp(x8, x9, MemOperand(x18, -16));
3683 __ Stp(w0, w1, MemOperand(x17));
3684 __ Stp(w2, w3, MemOperand(x17, 8));
3685 __ Stp(x4, x5, MemOperand(x17, 16));
3686 __ Stp(w6, w7, MemOperand(x19, -24));
3687 __ Stp(x8, x9, MemOperand(x19, -16));
3732 __ Mov(x20, src_base - base_offset);
3733 __ Mov(x21, dst_base - base_offset);
3734 __ Mov(x18, src_base + base_offset + 24);
3735 __ Mov(x19, dst_base + base_offset + 56);
3736 __ Ldp(w0, w1, MemOperand(x20, base_offset));
3737 __ Ldp(w2, w3, MemOperand(x20, base_offset + 4));
3738 __ Ldp(x4, x5, MemOperand(x20, base_offset + 8));
3739 __ Ldp(w6, w7, MemOperand(x18, -12 - base_offset));
3740 __ Ldp(x8, x9, MemOperand(x18, -16 - base_offset));
3741 __ Stp(w0, w1, MemOperand(x21, base_offset));
3742 __ Stp(w2, w3, MemOperand(x21, base_offset + 8));
3743 __ Stp(x4, x5, MemOperand(x21, base_offset + 16));
3744 __ Stp(w6, w7, MemOperand(x19, -24 - base_offset));
3745 __ Stp(x8, x9, MemOperand(x19, -16 - base_offset));
3788 __ Mov(x16, src_base);
3789 __ Mov(x17, dst_base);
3790 __ Mov(x18, src_base + 24);
3791 __ Mov(x19, dst_base + 64);
3792 __ Mov(x20, src_base + 32);
3795 __ Dmb(InnerShareable, BarrierAll);
3797 __ Ldnp(w0, w1, MemOperand(x16));
3798 __ Ldnp(w2, w3, MemOperand(x16, 4));
3799 __ Ldnp(x4, x5, MemOperand(x16, 8));
3800 __ Ldnp(w6, w7, MemOperand(x18, -12));
3801 __ Ldnp(x8, x9, MemOperand(x18, -16));
3802 __ Ldnp(q16, q17, MemOperand(x16));
3803 __ Ldnp(q19, q18, MemOperand(x20, -32));
3804 __ Stnp(w0, w1, MemOperand(x17));
3805 __ Stnp(w2, w3, MemOperand(x17, 8));
3806 __ Stnp(x4, x5, MemOperand(x17, 16));
3807 __ Stnp(w6, w7, MemOperand(x19, -32));
3808 __ Stnp(x8, x9, MemOperand(x19, -24));
3809 __ Stnp(q17, q16, MemOperand(x19));
3810 __ Stnp(q18, q19, MemOperand(x19, 32));
3864 __ Mov(x16, src_base);
3865 __ Mov(x17, dst_base);
3866 __ Mov(x18, dst_base + 16);
3867 __ Ldp(w0, w1, MemOperand(x16, 4, PreIndex));
3868 __ Mov(x19, x16);
3869 __ Ldp(w2, w3, MemOperand(x16, -4, PreIndex));
3870 __ Stp(w2, w3, MemOperand(x17, 4, PreIndex));
3871 __ Mov(x20, x17);
3872 __ Stp(w0, w1, MemOperand(x17, -4, PreIndex));
3873 __ Ldp(x4, x5, MemOperand(x16, 8, PreIndex));
3874 __ Mov(x21, x16);
3875 __ Ldp(x6, x7, MemOperand(x16, -8, PreIndex));
3876 __ Stp(x7, x6, MemOperand(x18, 8, PreIndex));
3877 __ Mov(x22, x18);
3878 __ Stp(x5, x4, MemOperand(x18, -8, PreIndex));
3922 __ Mov(x24, src_base - base_offset);
3923 __ Mov(x25, dst_base + base_offset);
3924 __ Mov(x18, dst_base + base_offset + 16);
3925 __ Ldp(w0, w1, MemOperand(x24, base_offset + 4, PreIndex));
3926 __ Mov(x19, x24);
3927 __ Mov(x24, src_base - base_offset + 4);
3928 __ Ldp(w2, w3, MemOperand(x24, base_offset - 4, PreIndex));
3929 __ Stp(w2, w3, MemOperand(x25, 4 - base_offset, PreIndex));
3930 __ Mov(x20, x25);
3931 __ Mov(x25, dst_base + base_offset + 4);
3932 __ Mov(x24, src_base - base_offset);
3933 __ Stp(w0, w1, MemOperand(x25, -4 - base_offset, PreIndex));
3934 __ Ldp(x4, x5, MemOperand(x24, base_offset + 8, PreIndex));
3935 __ Mov(x21, x24);
3936 __ Mov(x24, src_base - base_offset + 8);
3937 __ Ldp(x6, x7, MemOperand(x24, base_offset - 8, PreIndex));
3938 __ Stp(x7, x6, MemOperand(x18, 8 - base_offset, PreIndex));
3939 __ Mov(x22, x18);
3940 __ Mov(x18, dst_base + base_offset + 16 + 8);
3941 __ Stp(x5, x4, MemOperand(x18, -8 - base_offset, PreIndex));
3983 __ Mov(x16, src_base);
3984 __ Mov(x17, dst_base);
3985 __ Mov(x18, dst_base + 16);
3986 __ Ldp(w0, w1, MemOperand(x16, 4, PostIndex));
3987 __ Mov(x19, x16);
3988 __ Ldp(w2, w3, MemOperand(x16, -4, PostIndex));
3989 __ Stp(w2, w3, MemOperand(x17, 4, PostIndex));
3990 __ Mov(x20, x17);
3991 __ Stp(w0, w1, MemOperand(x17, -4, PostIndex));
3992 __ Ldp(x4, x5, MemOperand(x16, 8, PostIndex));
3993 __ Mov(x21, x16);
3994 __ Ldp(x6, x7, MemOperand(x16, -8, PostIndex));
3995 __ Stp(x7, x6, MemOperand(x18, 8, PostIndex));
3996 __ Mov(x22, x18);
3997 __ Stp(x5, x4, MemOperand(x18, -8, PostIndex));
4042 __ Mov(x24, src_base);
4043 __ Mov(x25, dst_base);
4044 __ Mov(x18, dst_base + 16);
4045 __ Ldp(w0, w1, MemOperand(x24, base_offset + 4, PostIndex));
4046 __ Mov(x19, x24);
4047 __ Sub(x24, x24, base_offset);
4048 __ Ldp(w2, w3, MemOperand(x24, base_offset - 4, PostIndex));
4049 __ Stp(w2, w3, MemOperand(x25, 4 - base_offset, PostIndex));
4050 __ Mov(x20, x25);
4051 __ Sub(x24, x24, base_offset);
4052 __ Add(x25, x25, base_offset);
4053 __ Stp(w0, w1, MemOperand(x25, -4 - base_offset, PostIndex));
4054 __ Ldp(x4, x5, MemOperand(x24, base_offset + 8, PostIndex));
4055 __ Mov(x21, x24);
4056 __ Sub(x24, x24, base_offset);
4057 __ Ldp(x6, x7, MemOperand(x24, base_offset - 8, PostIndex));
4058 __ Stp(x7, x6, MemOperand(x18, 8 - base_offset, PostIndex));
4059 __ Mov(x22, x18);
4060 __ Add(x18, x18, base_offset);
4061 __ Stp(x5, x4, MemOperand(x18, -8 - base_offset, PostIndex));
4098 __ Mov(x24, src_base);
4099 __ Ldpsw(x0, x1, MemOperand(x24));
4120 __ Mov(x17, src_base);
4121 __ Mov(x18, dst_base);
4122 __ Mov(x19, src_base + 16);
4123 __ Mov(x20, dst_base + 32);
4124 __ Mov(x21, dst_base + 40);
4125 __ Ldr(w0, MemOperand(x17, 1));
4126 __ Str(w0, MemOperand(x18, 2));
4127 __ Ldr(x1, MemOperand(x17, 3));
4128 __ Str(x1, MemOperand(x18, 9));
4129 __ Ldr(w2, MemOperand(x19, -9));
4130 __ Str(w2, MemOperand(x20, -5));
4131 __ Ldrb(w3, MemOperand(x19, -1));
4132 __ Strb(w3, MemOperand(x21, -1));
4164 __ Mov(x17, src_base);
4165 __ Mov(x18, dst_base);
4166 __ Ldr(b0, MemOperand(x17));
4167 __ Str(b0, MemOperand(x18));
4168 __ Ldr(h1, MemOperand(x17, 1));
4169 __ Str(h1, MemOperand(x18, 1));
4170 __ Ldr(s2, MemOperand(x17, 2));
4171 __ Str(s2, MemOperand(x18, 3));
4172 __ Ldr(d3, MemOperand(x17, 3));
4173 __ Str(d3, MemOperand(x18, 7));
4174 __ Ldr(q4, MemOperand(x17, 4));
4175 __ Str(q4, MemOperand(x18, 15));
4198 __ Ldr(x2, 0x1234567890abcdef);
4199 __ Ldr(w3, 0xfedcba09);
4200 __ Ldrsw(x4, 0x7fffffff);
4201 __ Ldrsw(x5, 0x80000000);
4202 __ Ldr(q11, 0x1234000056780000, 0xabcd0000ef000000);
4203 __ Ldr(d13, 1.234);
4204 __ Ldr(s25, 2.5);
4230 __ Ldr(x0, 0x1234567890abcdef);
4231 __ Ldr(w1, 0xfedcba09);
4232 __ Ldrsw(x2, 0x7fffffff);
4233 __ Ldrsw(x3, 0x80000000);
4234 __ Ldr(q2, 0x1234000056780000, 0xabcd0000ef000000);
4235 __ Ldr(d0, 1.234);
4236 __ Ldr(s1, 2.5);
4243 __ Nop();
4250 __ Ldr(x4, 0x34567890abcdef12);
4251 __ Ldr(w5, 0xdcba09fe);
4252 __ Ldrsw(x6, 0x7fffffff);
4253 __ Ldrsw(x7, 0x80000000);
4254 __ Ldr(q6, 0x1234000056780000, 0xabcd0000ef000000);
4255 __ Ldr(d4, 123.4);
4256 __ Ldr(s5, 250.0);
4291 __ Mov(x0, 0);
4295 __ Mov(tgt1, values[i]);
4296 __ Ldr(tgt2, values[i]);
4297 __ Cmp(tgt1, tgt2);
4298 __ Cset(x0, ne);
4361 __ B(&end_of_pool_before);
4364 __ place(&before_x);
4365 __ place(&before_w);
4366 __ place(&before_sx);
4367 __ place(&before_q);
4368 __ place(&before_d);
4369 __ place(&before_s);
4371 __ Bind(&end_of_pool_before);
4375 __ ldr(x2, &before_x);
4376 __ ldr(w3, &before_w);
4377 __ ldrsw(x5, &before_sx);
4378 __ ldr(q11, &before_q);
4379 __ ldr(d13, &before_d);
4380 __ ldr(s25, &before_s);
4382 __ ldr(x6, &after_x);
4383 __ ldr(w7, &after_w);
4384 __ ldrsw(x8, &after_sx);
4385 __ ldr(q18, &after_q);
4386 __ ldr(d14, &after_d);
4387 __ ldr(s26, &after_s);
4391 __ B(&end_of_pool_after);
4394 __ place(&after_x);
4395 __ place(&after_w);
4396 __ place(&after_sx);
4397 __ place(&after_q);
4398 __ place(&after_d);
4399 __ place(&after_s);
4401 __ Bind(&end_of_pool_after);
4448 __ B(&end_of_pool_before);
4451 __ place(&before_x);
4452 __ place(&before_w);
4453 __ place(&before_q);
4454 __ place(&before_d);
4455 __ place(&before_s);
4457 __ Bind(&end_of_pool_before);
4462 __ ldr(x2, &before_x);
4463 __ ldr(w3, &before_w);
4464 __ ldrsw(x5, &before_w); // Re-use before_w.
4465 __ ldr(q11, &before_q);
4466 __ ldr(d13, &before_d);
4467 __ ldr(s25, &before_s);
4469 __ ldr(x6, &after_x);
4470 __ ldr(w7, &after_w);
4471 __ ldrsw(x8, &after_w); // Re-use after_w.
4472 __ ldr(q18, &after_q);
4473 __ ldr(d14, &after_d);
4474 __ ldr(s26, &after_s);
4478 __ B(&end_of_pool_after);
4481 __ place(&after_x);
4482 __ place(&after_w);
4483 __ place(&after_q);
4484 __ place(&after_d);
4485 __ place(&after_s);
4487 __ Bind(&end_of_pool_after);
4536 __ Mov(x0, 0x0123456789abcdef);
4542 __ prfm(op, MemOperand(x0));
4543 __ prfm(op, MemOperand(x0, 8));
4544 __ prfm(op, MemOperand(x0, 32760));
4549 __ Prfm(op, MemOperand(x0, 32768));
4550 __ Prfm(op, MemOperand(x0, 1));
4551 __ Prfm(op, MemOperand(x0, 9));
4552 __ Prfm(op, MemOperand(x0, 255));
4553 __ Prfm(op, MemOperand(x0, 257));
4554 __ Prfm(op, MemOperand(x0, -1));
4555 __ Prfm(op, MemOperand(x0, -9));
4556 __ Prfm(op, MemOperand(x0, -255));
4557 __ Prfm(op, MemOperand(x0, -257));
4559 __ Prfm(op, MemOperand(x0, 0xfedcba9876543210));
4574 __ Mov(x0, 0x0123456789abcdef);
4577 __ Mov(x10, 0);
4578 __ Mov(x11, 1);
4579 __ Mov(x12, 8);
4580 __ Mov(x13, 255);
4581 __ Mov(x14, -0);
4582 __ Mov(x15, -1);
4583 __ Mov(x16, -8);
4584 __ Mov(x17, -255);
4585 __ Mov(x18, 0xfedcba9876543210);
4598 __ prfm(op, MemOperand(x0, Register(loop.PopLowestIndex())));
4607 __ Prfm(op, MemOperand(x0, input, UXTW));
4608 __ Prfm(op, MemOperand(x0, input, UXTW, 3));
4609 __ Prfm(op, MemOperand(x0, input, LSL));
4610 __ Prfm(op, MemOperand(x0, input, LSL, 3));
4611 __ Prfm(op, MemOperand(x0, input, SXTW));
4612 __ Prfm(op, MemOperand(x0, input, SXTW, 3));
4613 __ Prfm(op, MemOperand(x0, input, SXTX));
4614 __ Prfm(op, MemOperand(x0, input, SXTX, 3));
4633 __ prfm(op, INT64_C(0));
4634 __ prfm(op, 1);
4635 __ prfm(op, -1);
4642 __ prfm(op, 1000);
4643 __ prfm(op, -1000);
4644 __ prfm(op, 0x3ffff);
4645 __ prfm(op, -0x40000);
4666 __ B(&end_of_pool_before);
4669 __ place(&before);
4671 __ Bind(&end_of_pool_before);
4677 __ prfm(op, &before);
4678 __ prfm(op, &after);
4684 __ prfm(op, &before);
4685 __ prfm(op, &after);
4689 __ B(&end_of_pool_after);
4692 __ place(&after);
4694 __ Bind(&end_of_pool_after);
4708 __ Mov(x0, 0x0123456789abcdef);
4711 __ Prfm(op, MemOperand(x0, 0x40000));
4712 __ Prfm(op, MemOperand(x0, -0x40001));
4713 __ Prfm(op, MemOperand(x0, UINT64_C(0x5555555555555555)));
4714 __ Prfm(op, MemOperand(x0, UINT64_C(0xfedcba9876543210)));
4747 __ B(&end_of_pool_before);
4750 __ place(&before_x);
4751 __ place(&before_w);
4752 __ place(&before_sx);
4753 __ place(&before_d);
4754 __ place(&before_s);
4756 __ Bind(&end_of_pool_before);
4762 __ prfm(op, &before_x);
4763 __ prfm(op, &before_w);
4764 __ prfm(op, &before_sx);
4765 __ prfm(op, &before_d);
4766 __ prfm(op, &before_s);
4768 __ prfm(op, &after_x);
4769 __ prfm(op, &after_w);
4770 __ prfm(op, &after_sx);
4771 __ prfm(op, &after_d);
4772 __ prfm(op, &after_s);
4779 __ prfm(op, &before_x);
4780 __ prfm(op, &before_w);
4781 __ prfm(op, &before_sx);
4782 __ prfm(op, &before_d);
4783 __ prfm(op, &before_s);
4785 __ prfm(op, &after_x);
4786 __ prfm(op, &after_w);
4787 __ prfm(op, &after_sx);
4788 __ prfm(op, &after_d);
4789 __ prfm(op, &after_s);
4794 __ ldr(x2, &before_x);
4795 __ ldr(w3, &before_w);
4796 __ ldrsw(x5, &before_sx);
4797 __ ldr(d13, &before_d);
4798 __ ldr(s25, &before_s);
4800 __ ldr(x6, &after_x);
4801 __ ldr(w7, &after_w);
4802 __ ldrsw(x8, &after_sx);
4803 __ ldr(d14, &after_d);
4804 __ ldr(s26, &after_s);
4808 __ B(&end_of_pool_after);
4811 __ place(&after_x);
4812 __ place(&after_w);
4813 __ place(&after_sx);
4814 __ place(&after_d);
4815 __ place(&after_s);
4817 __ Bind(&end_of_pool_after);
4843 __ Mov(x0, 0x0);
4844 __ Mov(x1, 0x1111);
4845 __ Mov(x2, 0xffffffffffffffff);
4846 __ Mov(x3, 0x8000000000000000);
4848 __ Add(x10, x0, Operand(0x123));
4849 __ Add(x11, x1, Operand(0x122000));
4850 __ Add(x12, x0, Operand(0xabc << 12));
4851 __ Add(x13, x2, Operand(1));
4853 __ Add(w14, w0, Operand(0x123));
4854 __ Add(w15, w1, Operand(0x122000));
4855 __ Add(w16, w0, Operand(0xabc << 12));
4856 __ Add(w17, w2, Operand(1));
4858 __ Sub(x20, x0, Operand(0x1));
4859 __ Sub(x21, x1, Operand(0x111));
4860 __ Sub(x22, x1, Operand(0x1 << 12));
4861 __ Sub(x23, x3, Operand(1));
4863 __ Sub(w24, w0, Operand(0x1));
4864 __ Sub(w25, w1, Operand(0x111));
4865 __ Sub(w26, w1, Operand(0x1 << 12));
4866 __ Sub(w27, w3, Operand(1));
4899 __ Mov(x0, 0x0);
4900 __ Mov(x1, 0x1);
4902 __ Add(x10, x0, Operand(0x1234567890abcdef));
4903 __ Add(x11, x1, Operand(0xffffffff));
4905 __ Add(w12, w0, Operand(0x12345678));
4906 __ Add(w13, w1, Operand(0xffffffff));
4908 __ Add(w18, w0, Operand(kWMinInt));
4909 __ Sub(w19, w0, Operand(kWMinInt));
4911 __ Sub(x20, x0, Operand(0x1234567890abcdef));
4912 __ Sub(w21, w0, Operand(0x12345678));
4938 __ Mov(x0, 0);
4939 __ Mov(x1, 0x0123456789abcdef);
4940 __ Mov(x2, 0xfedcba9876543210);
4941 __ Mov(x3, 0xffffffffffffffff);
4943 __ Add(x10, x1, Operand(x2));
4944 __ Add(x11, x0, Operand(x1, LSL, 8));
4945 __ Add(x12, x0, Operand(x1, LSR, 8));
4946 __ Add(x13, x0, Operand(x1, ASR, 8));
4947 __ Add(x14, x0, Operand(x2, ASR, 8));
4948 __ Add(w15, w0, Operand(w1, ASR, 8));
4949 __ Add(w18, w3, Operand(w1, ROR, 8));
4950 __ Add(x19, x3, Operand(x1, ROR, 8));
4952 __ Sub(x20, x3, Operand(x2));
4953 __ Sub(x21, x3, Operand(x1, LSL, 8));
4954 __ Sub(x22, x3, Operand(x1, LSR, 8));
4955 __ Sub(x23, x3, Operand(x1, ASR, 8));
4956 __ Sub(x24, x3, Operand(x2, ASR, 8));
4957 __ Sub(w25, w3, Operand(w1, ASR, 8));
4958 __ Sub(w26, w3, Operand(w1, ROR, 8));
4959 __ Sub(x27, x3, Operand(x1, ROR, 8));
4990 __ Mov(x0, 0);
4991 __ Mov(x1, 0x0123456789abcdef);
4992 __ Mov(x2, 0xfedcba9876543210);
4993 __ Mov(w3, 0x80);
4995 __ Add(x10, x0, Operand(x1, UXTB, 0));
4996 __ Add(x11, x0, Operand(x1, UXTB, 1));
4997 __ Add(x12, x0, Operand(x1, UXTH, 2));
4998 __ Add(x13, x0, Operand(x1, UXTW, 4));
5000 __ Add(x14, x0, Operand(x1, SXTB, 0));
5001 __ Add(x15, x0, Operand(x1, SXTB, 1));
5002 __ Add(x16, x0, Operand(x1, SXTH, 2));
5003 __ Add(x17, x0, Operand(x1, SXTW, 3));
5004 __ Add(x18, x0, Operand(x2, SXTB, 0));
5005 __ Add(x19, x0, Operand(x2, SXTB, 1));
5006 __ Add(x20, x0, Operand(x2, SXTH, 2));
5007 __ Add(x21, x0, Operand(x2, SXTW, 3));
5009 __ Add(x22, x1, Operand(x2, SXTB, 1));
5010 __ Sub(x23, x1, Operand(x2, SXTB, 1));
5012 __ Add(w24, w1, Operand(w2, UXTB, 2));
5013 __ Add(w25, w0, Operand(w1, SXTB, 0));
5014 __ Add(w26, w0, Operand(w1, SXTB, 1));
5015 __ Add(w27, w2, Operand(w1, SXTW, 3));
5017 __ Add(w28, w0, Operand(w1, SXTW, 3));
5018 __ Add(x29, x0, Operand(w1, SXTW, 3));
5020 __ Sub(x30, x0, Operand(w3, SXTB, 1));
5060 __ Mov(x0, 0);
5061 __ Mov(x1, 4687);
5062 __ Mov(x2, 0x1122334455667788);
5063 __ Mov(w3, 0x11223344);
5064 __ Mov(w4, 400000);
5066 __ Add(x10, x0, -42);
5067 __ Add(x11, x1, -687);
5068 __ Add(x12, x2, -0x88);
5070 __ Sub(x13, x0, -600);
5071 __ Sub(x14, x1, -313);
5072 __ Sub(x15, x2, -0x555);
5074 __ Add(w19, w3, -0x344);
5075 __ Add(w20, w4, -2000);
5077 __ Sub(w21, w3, -0xbc);
5078 __ Sub(w22, w4, -2000);
5105 __ Mov(x0, 0);
5106 __ Mov(x1, 0);
5107 __ Mov(x2, 0);
5110 __ Bind(&blob1);
5111 __ Add(x0, x0, 0);
5112 __ Sub(x1, x1, 0);
5113 __ Sub(x2, x2, xzr);
5114 VIXL_CHECK(__ GetSizeOfCodeGeneratedSince(&blob1) == 0);
5117 __ Bind(&blob2);
5118 __ Add(w3, w3, 0);
5119 VIXL_CHECK(__ GetSizeOfCodeGeneratedSince(&blob2) != 0);
5122 __ Bind(&blob3);
5123 __ Sub(w3, w3, wzr);
5124 VIXL_CHECK(__ GetSizeOfCodeGeneratedSince(&blob3) != 0);
5144 __ Bind(&start);
5145 __ Claim(Operand(0));
5146 __ Drop(Operand(0));
5147 __ Claim(Operand(xzr));
5148 __ Drop(Operand(xzr));
5149 VIXL_CHECK(__ GetSizeOfCodeGeneratedSince(&start) == 0);
5163 __ Mov(x0, 0xf123456789abcdef);
5166 __ Neg(x1, 0x123);
5167 __ Neg(w2, 0x123);
5170 __ Neg(x3, Operand(x0, LSL, 1));
5171 __ Neg(w4, Operand(w0, LSL, 2));
5172 __ Neg(x5, Operand(x0, LSR, 3));
5173 __ Neg(w6, Operand(w0, LSR, 4));
5174 __ Neg(x7, Operand(x0, ASR, 5));
5175 __ Neg(w8, Operand(w0, ASR, 6));
5178 __ Neg(w9, Operand(w0, UXTB));
5179 __ Neg(x10, Operand(x0, SXTB, 1));
5180 __ Neg(w11, Operand(w0, UXTH, 2));
5181 __ Neg(x12, Operand(x0, SXTH, 3));
5182 __ Neg(w13, Operand(w0, UXTW, 4));
5183 __ Neg(x14, Operand(x0, SXTW, 4));
5218 __ Mov(left_reg, left);
5219 __ Mov(right_reg, right);
5220 __ Mov(x10, (carry ? CFlag : NoFlag));
5222 __ Msr(NZCV, x10);
5621 __ Mov(x0, 0);
5622 __ Mov(x1, 1);
5623 __ Mov(x2, 0x0123456789abcdef);
5624 __ Mov(x3, 0xfedcba9876543210);
5625 __ Mov(x4, 0xffffffffffffffff);
5628 __ Adds(x0, x0, Operand(0));
5630 __ Adc(x5, x2, Operand(x3));
5631 __ Adc(x6, x0, Operand(x1, LSL, 60));
5632 __ Sbc(x7, x4, Operand(x3, LSR, 4));
5633 __ Adc(x8, x2, Operand(x3, ASR, 4));
5634 __ Adc(x9, x2, Operand(x3, ROR, 8));
5636 __ Adc(w10, w2, Operand(w3));
5637 __ Adc(w11, w0, Operand(w1, LSL, 30));
5638 __ Sbc(w12, w4, Operand(w3, LSR, 4));
5639 __ Adc(w13, w2, Operand(w3, ASR, 4));
5640 __ Adc(w14, w2, Operand(w3, ROR, 8));
5643 __ Cmp(w0, Operand(w0));
5645 __ Adc(x18, x2, Operand(x3));
5646 __ Adc(x19, x0, Operand(x1, LSL, 60));
5647 __ Sbc(x20, x4, Operand(x3, LSR, 4));
5648 __ Adc(x21, x2, Operand(x3, ASR, 4));
5649 __ Adc(x22, x2, Operand(x3, ROR, 8));
5651 __ Adc(w23, w2, Operand(w3));
5652 __ Adc(w24, w0, Operand(w1, LSL, 30));
5653 __ Sbc(w25, w4, Operand(w3, LSR, 4));
5654 __ Adc(w26, w2, Operand(w3, ASR, 4));
5655 __ Adc(w27, w2, Operand(w3, ROR, 8));
5693 __ Adds(x0, x0, Operand(0));
5695 __ Mov(x0, 0);
5696 __ Mov(x1, 1);
5697 __ Mov(x2, 0x0123456789abcdef);
5699 __ Adc(x10, x1, Operand(w2, UXTB, 1));
5700 __ Adc(x11, x1, Operand(x2, SXTH, 2));
5701 __ Sbc(x12, x1, Operand(w2, UXTW, 4));
5702 __ Adc(x13, x1, Operand(x2, UXTX, 4));
5704 __ Adc(w14, w1, Operand(w2, UXTB, 1));
5705 __ Adc(w15, w1, Operand(w2, SXTH, 2));
5706 __ Adc(w9, w1, Operand(w2, UXTW, 4));
5709 __ Cmp(w0, Operand(w0));
5711 __ Adc(x20, x1, Operand(w2, UXTB, 1));
5712 __ Adc(x21, x1, Operand(x2, SXTH, 2));
5713 __ Sbc(x22, x1, Operand(w2, UXTW, 4));
5714 __ Adc(x23, x1, Operand(x2, UXTX, 4));
5716 __ Adc(w24, w1, Operand(w2, UXTB, 1));
5717 __ Adc(w25, w1, Operand(w2, SXTH, 2));
5718 __ Adc(w26, w1, Operand(w2, UXTW, 4));
5745 __ Mov(x0, 0xff);
5746 __ Mov(x1, 0xffffffffffffffff);
5748 __ Adds(x0, x0, Operand(0));
5749 __ Adcs(x10, x0, Operand(x1, SXTX, 1));
5759 __ Mov(x0, 0x7fffffffffffffff);
5760 __ Mov(x1, 1);
5762 __ Adds(x0, x0, Operand(0));
5763 __ Adcs(x10, x0, Operand(x1, UXTB, 2));
5773 __ Mov(x0, 0x7fffffffffffffff);
5775 __ Adds(x0, x0, Operand(0));
5776 __ Adcs(x10, x0, Operand(1));
5791 __ Mov(x0, 0);
5794 __ Adds(x0, x0, Operand(0));
5796 __ Adc(x7, x0, Operand(0x1234567890abcdef));
5797 __ Adc(w8, w0, Operand(0xffffffff));
5798 __ Sbc(x9, x0, Operand(0x1234567890abcdef));
5799 __ Sbc(w10, w0, Operand(0xffffffff));
5800 __ Ngc(x11, Operand(0xffffffff00000000));
5801 __ Ngc(w12, Operand(0xffff0000));
5804 __ Cmp(w0, Operand(w0));
5806 __ Adc(x18, x0, Operand(0x1234567890abcdef));
5807 __ Adc(w19, w0, Operand(0xffffffff));
5808 __ Sbc(x20, x0, Operand(0x1234567890abcdef));
5809 __ Sbc(w21, w0, Operand(0xffffffff));
5810 __ Ngc(x22, Operand(0xffffffff00000000));
5811 __ Ngc(w23, Operand(0xffff0000));
5838 __ Mov(x0, 0x0123456789abcdef);
5841 __ Rmif(x0, 0, NCVFlag);
5842 __ Mrs(x1, NZCV);
5845 __ Rmif(x0, 6, NZCVFlag);
5846 __ Mrs(x2, NZCV);
5849 __ Rmif(x0, 60, ZFlag);
5850 __ Mrs(x3, NZCV);
5853 __ Rmif(x0, 62, NCFlag);
5854 __ Mrs(x4, NZCV);
5857 __ Rmif(x0, 0, NoFlag);
5858 __ Mrs(x5, NZCV);
5876 __ Mov(x0, 0x0);
5877 __ Mov(x1, 0x1);
5878 __ Mov(x2, 0xff);
5879 __ Mov(x3, 0x100);
5880 __ Mov(x4, 0x101);
5881 __ Mov(x5, 0xffff);
5882 __ Mov(x6, 0x10000);
5883 __ Mov(x7, 0x10001);
5884 __ Mov(x8, 0xfffffffff);
5886 __ Setf8(w0);
5887 __ Mrs(x9, NZCV);
5888 __ Setf8(w1);
5889 __ Mrs(x10, NZCV);
5890 __ Setf8(w2);
5891 __ Mrs(x11, NZCV);
5892 __ Setf8(w3);
5893 __ Mrs(x12, NZCV);
5894 __ Setf8(w4);
5895 __ Mrs(x13, NZCV);
5896 __ Setf8(w8);
5897 __ Mrs(x14, NZCV);
5899 __ Setf16(w0);
5900 __ Mrs(x15, NZCV);
5901 __ Setf16(w1);
5902 __ Mrs(x16, NZCV);
5903 __ Setf16(w5);
5904 __ Mrs(x17, NZCV);
5905 __ Setf16(w6);
5906 __ Mrs(x18, NZCV);
5907 __ Setf16(w7);
5908 __ Mrs(x19, NZCV);
5909 __ Setf16(w8);
5910 __ Mrs(x20, NZCV);
5937 __ Mov(x0, 0);
5938 __ Mov(x1, 0x1111111111111111);
5939 __ Neg(x10, Operand(x0));
5940 __ Neg(x11, Operand(x1));
5941 __ Neg(w12, Operand(w1));
5943 __ Adds(x0, x0, Operand(0));
5944 __ Ngc(x13, Operand(x0));
5946 __ Cmp(x0, Operand(x0));
5947 __ Ngc(w14, Operand(w0));
5961 __ Mov(x0, 0);
5962 __ Cmp(x0, Operand(x0));
5972 __ Mov(w0, 0);
5973 __ Cmp(w0, Operand(w0));
5983 __ Mov(x0, 0);
5984 __ Mov(x1, 0x1111111111111111);
5985 __ Cmp(x0, Operand(x1));
5995 __ Mov(w0, 0);
5996 __ Mov(w1, 0x11111111);
5997 __ Cmp(w0, Operand(w1));
6007 __ Mov(x1, 0x1111111111111111);
6008 __ Cmp(x1, Operand(0));
6018 __ Mov(w1, 0x11111111);
6019 __ Cmp(w1, Operand(0));
6029 __ Mov(x0, 1);
6030 __ Mov(x1, 0x7fffffffffffffff);
6031 __ Cmn(x1, Operand(x0));
6041 __ Mov(w0, 1);
6042 __ Mov(w1, 0x7fffffff);
6043 __ Cmn(w1, Operand(w0));
6053 __ Mov(x0, 1);
6054 __ Mov(x1, 0xffffffffffffffff);
6055 __ Cmn(x1, Operand(x0));
6065 __ Mov(w0, 1);
6066 __ Mov(w1, 0xffffffff);
6067 __ Cmn(w1, Operand(w0));
6077 __ Mov(w0, 0);
6078 __ Mov(w1, 1);
6080 __ Adds(w0, w0, Operand(0));
6081 __ Ngcs(w0, Operand(w1));
6091 __ Mov(w0, 0);
6092 __ Mov(w1, 0);
6094 __ Cmp(w0, Operand(w0));
6095 __ Ngcs(w0, Operand(w1));
6110 __ Mov(x18, 0xf0000000);
6111 __ Mov(x19, 0xf000000010000000);
6112 __ Mov(x20, 0xf0000000f0000000);
6113 __ Mov(x21, 0x7800000078000000);
6114 __ Mov(x22, 0x3c0000003c000000);
6115 __ Mov(x23, 0x8000000780000000);
6116 __ Mov(x24, 0x0000000f00000000);
6117 __ Mov(x25, 0x00000003c0000000);
6118 __ Mov(x26, 0x8000000780000000);
6119 __ Mov(x27, 0xc0000003);
6121 __ Cmp(w20, Operand(w21, LSL, 1));
6122 __ Mrs(x0, NZCV);
6124 __ Cmp(x20, Operand(x22, LSL, 2));
6125 __ Mrs(x1, NZCV);
6127 __ Cmp(w19, Operand(w23, LSR, 3));
6128 __ Mrs(x2, NZCV);
6130 __ Cmp(x18, Operand(x24, LSR, 4));
6131 __ Mrs(x3, NZCV);
6133 __ Cmp(w20, Operand(w25, ASR, 2));
6134 __ Mrs(x4, NZCV);
6136 __ Cmp(x20, Operand(x26, ASR, 3));
6137 __ Mrs(x5, NZCV);
6139 __ Cmp(w27, Operand(w22, ROR, 28));
6140 __ Mrs(x6, NZCV);
6142 __ Cmp(x20, Operand(x21, ROR, 31));
6143 __ Mrs(x7, NZCV);
6165 __ Mov(w20, 0x2);
6166 __ Mov(w21, 0x1);
6167 __ Mov(x22, 0xffffffffffffffff);
6168 __ Mov(x23, 0xff);
6169 __ Mov(x24, 0xfffffffffffffffe);
6170 __ Mov(x25, 0xffff);
6171 __ Mov(x26, 0xffffffff);
6173 __ Cmp(w20, Operand(w21, LSL, 1));
6174 __ Mrs(x0, NZCV);
6176 __ Cmp(x22, Operand(x23, SXTB, 0));
6177 __ Mrs(x1, NZCV);
6179 __ Cmp(x24, Operand(x23, SXTB, 1));
6180 __ Mrs(x2, NZCV);
6182 __ Cmp(x24, Operand(x23, UXTB, 1));
6183 __ Mrs(x3, NZCV);
6185 __ Cmp(w22, Operand(w25, UXTH));
6186 __ Mrs(x4, NZCV);
6188 __ Cmp(x22, Operand(x25, SXTH));
6189 __ Mrs(x5, NZCV);
6191 __ Cmp(x22, Operand(x26, UXTW));
6192 __ Mrs(x6, NZCV);
6194 __ Cmp(x24, Operand(x26, SXTW, 1));
6195 __ Mrs(x7, NZCV);
6217 __ Mov(w16, 0);
6218 __ Mov(w17, 1);
6219 __ Cmp(w16, w16);
6220 __ Ccmp(w16, w17, NCFlag, eq);
6221 __ Mrs(x0, NZCV);
6223 __ Cmp(w16, w16);
6224 __ Ccmp(w16, w17, NCFlag, ne);
6225 __ Mrs(x1, NZCV);
6227 __ Cmp(x16, x16);
6228 __ Ccmn(x16, 2, NZCVFlag, eq);
6229 __ Mrs(x2, NZCV);
6231 __ Cmp(x16, x16);
6232 __ Ccmn(x16, 2, NZCVFlag, ne);
6233 __ Mrs(x3, NZCV);
6238 __ ccmp(x16, x16, NZCVFlag, al);
6240 __ Mrs(x4, NZCV);
6245 __ ccmp(x16, x16, NZCVFlag, nv);
6247 __ Mrs(x5, NZCV);
6268 __ Mov(w20, 0);
6270 __ Cmp(w20, Operand(w20));
6271 __ Ccmp(w20, Operand(0x12345678), NZCVFlag, eq);
6272 __ Mrs(x0, NZCV);
6274 __ Cmp(w20, Operand(w20));
6275 __ Ccmp(x20, Operand(0xffffffffffffffff), NZCVFlag, eq);
6276 __ Mrs(x1, NZCV);
6292 __ Mov(w20, 0x2);
6293 __ Mov(w21, 0x1);
6294 __ Mov(x22, 0xffffffffffffffff);
6295 __ Mov(x23, 0xff);
6296 __ Mov(x24, 0xfffffffffffffffe);
6298 __ Cmp(w20, Operand(w20));
6299 __ Ccmp(w20, Operand(w21, LSL, 1), NZCVFlag, eq);
6300 __ Mrs(x0, NZCV);
6302 __ Cmp(w20, Operand(w20));
6303 __ Ccmp(x22, Operand(x23, SXTB, 0), NZCVFlag, eq);
6304 __ Mrs(x1, NZCV);
6306 __ Cmp(w20, Operand(w20));
6307 __ Ccmp(x24, Operand(x23, SXTB, 1), NZCVFlag, eq);
6308 __ Mrs(x2, NZCV);
6310 __ Cmp(w20, Operand(w20));
6311 __ Ccmp(x24, Operand(x23, UXTB, 1), NZCVFlag, eq);
6312 __ Mrs(x3, NZCV);
6314 __ Cmp(w20, Operand(w20));
6315 __ Ccmp(x24, Operand(x23, UXTB, 1), NZCVFlag, ne);
6316 __ Mrs(x4, NZCV);
6335 __ Mov(x16, 0);
6336 __ Mov(x24, 0x0000000f0000000f);
6337 __ Mov(x25, 0x0000001f0000001f);
6339 __ Cmp(w16, Operand(0));
6340 __ Csel(w0, w24, w25, eq);
6341 __ Csel(w1, w24, w25, ne);
6342 __ Csinc(w2, w24, w25, mi);
6343 __ Csinc(w3, w24, w25, pl);
6348 __ csel(w13, w24, w25, al);
6349 __ csel(x14, x24, x25, nv);
6352 __ Cmp(x16, Operand(1));
6353 __ Csinv(x4, x24, x25, gt);
6354 __ Csinv(x5, x24, x25, le);
6355 __ Csneg(x6, x24, x25, hs);
6356 __ Csneg(x7, x24, x25, lo);
6358 __ Cset(w8, ne);
6359 __ Csetm(w9, ne);
6360 __ Cinc(x10, x25, ne);
6361 __ Cinv(x11, x24, ne);
6362 __ Cneg(x12, x24, ne);
6367 __ csel(w15, w24, w25, al);
6368 __ csel(x17, x24, x25, nv);
6401 __ Mov(x15, 0x0);
6402 __ Mov(x16, 0x0000001f0000002f);
6406 __ Cmp(x15, 0);
6407 __ Csinc(x0, x16, xzr, eq);
6408 __ Csinc(x1, xzr, x16, eq);
6409 __ Cmp(x15, 1);
6410 __ Csinc(w2, w16, wzr, eq);
6411 __ Csinc(w3, wzr, w16, eq);
6413 __ Csinc(x4, xzr, xzr, eq);
6415 __ Cmp(x15, 0);
6416 __ Csinv(x5, x16, xzr, eq);
6417 __ Csinv(x6, xzr, x16, eq);
6418 __ Cmp(x15, 1);
6419 __ Csinv(w7, w16, wzr, eq);
6420 __ Csinv(w8, wzr, w16, eq);
6422 __ Csinv(x9, xzr, xzr, eq);
6424 __ Cmp(x15, 0);
6425 __ Csneg(x10, x16, xzr, eq);
6426 __ Csneg(x11, xzr, x16, eq);
6427 __ Cmp(x15, 1);
6428 __ Csneg(w12, w16, wzr, eq);
6429 __ Csneg(w13, wzr, w16, eq);
6431 __ Csneg(x14, xzr, xzr, eq);
6469 __ Mov(x10, 0);
6470 __ Cmp(x10, 0);
6471 __ Csel(w0, left, right, eq);
6472 __ Csel(w1, left, right, ne);
6473 __ Csel(x2, left, right, eq);
6474 __ Csel(x3, left, right, ne);
6495 __ Mov(x18, 0);
6496 __ Mov(x19, 0x80000000);
6497 __ Mov(x20, 0x8000000000000000);
6499 __ Cmp(x18, Operand(0));
6500 __ Csel(w0, w19, -2, ne);
6501 __ Csel(w1, w19, -1, ne);
6502 __ Csel(w2, w19, 0, ne);
6503 __ Csel(w3, w19, 1, ne);
6504 __ Csel(w4, w19, 2, ne);
6505 __ Csel(w5, w19, Operand(w19, ASR, 31), ne);
6506 __ Csel(w6, w19, Operand(w19, ROR, 1), ne);
6507 __ Csel(w7, w19, 3, eq);
6509 __ Csel(x8, x20, -2, ne);
6510 __ Csel(x9, x20, -1, ne);
6511 __ Csel(x10, x20, 0, ne);
6512 __ Csel(x11, x20, 1, ne);
6513 __ Csel(x12, x20, 2, ne);
6514 __ Csel(x13, x20, Operand(x20, ASR, 63), ne);
6515 __ Csel(x14, x20, Operand(x20, ROR, 1), ne);
6516 __ Csel(x15, x20, 3, eq);
6551 __ Mov(x0, value);
6552 __ Mov(w1, shift[0]);
6553 __ Mov(w2, shift[1]);
6554 __ Mov(w3, shift[2]);
6555 __ Mov(w4, shift[3]);
6556 __ Mov(w5, shift[4]);
6557 __ Mov(w6, shift[5]);
6562 __ lslv(x0, x0, xzr);
6565 __ Lsl(x16, x0, x1);
6566 __ Lsl(x17, x0, x2);
6567 __ Lsl(x18, x0, x3);
6568 __ Lsl(x19, x0, x4);
6569 __ Lsl(x20, x0, x5);
6570 __ Lsl(x21, x0, x6);
6572 __ Lsl(w22, w0, w1);
6573 __ Lsl(w23, w0, w2);
6574 __ Lsl(w24, w0, w3);
6575 __ Lsl(w25, w0, w4);
6576 __ Lsl(w26, w0, w5);
6577 __ Lsl(w27, w0, w6);
6607 __ Mov(x0, value);
6608 __ Mov(w1, shift[0]);
6609 __ Mov(w2, shift[1]);
6610 __ Mov(w3, shift[2]);
6611 __ Mov(w4, shift[3]);
6612 __ Mov(w5, shift[4]);
6613 __ Mov(w6, shift[5]);
6618 __ lsrv(x0, x0, xzr);
6621 __ Lsr(x16, x0, x1);
6622 __ Lsr(x17, x0, x2);
6623 __ Lsr(x18, x0, x3);
6624 __ Lsr(x19, x0, x4);
6625 __ Lsr(x20, x0, x5);
6626 __ Lsr(x21, x0, x6);
6628 __ Lsr(w22, w0, w1);
6629 __ Lsr(w23, w0, w2);
6630 __ Lsr(w24, w0, w3);
6631 __ Lsr(w25, w0, w4);
6632 __ Lsr(w26, w0, w5);
6633 __ Lsr(w27, w0, w6);
6665 __ Mov(x0, value);
6666 __ Mov(w1, shift[0]);
6667 __ Mov(w2, shift[1]);
6668 __ Mov(w3, shift[2]);
6669 __ Mov(w4, shift[3]);
6670 __ Mov(w5, shift[4]);
6671 __ Mov(w6, shift[5]);
6676 __ asrv(x0, x0, xzr);
6679 __ Asr(x16, x0, x1);
6680 __ Asr(x17, x0, x2);
6681 __ Asr(x18, x0, x3);
6682 __ Asr(x19, x0, x4);
6683 __ Asr(x20, x0, x5);
6684 __ Asr(x21, x0, x6);
6686 __ Asr(w22, w0, w1);
6687 __ Asr(w23, w0, w2);
6688 __ Asr(w24, w0, w3);
6689 __ Asr(w25, w0, w4);
6690 __ Asr(w26, w0, w5);
6691 __ Asr(w27, w0, w6);
6723 __ Mov(x0, value);
6724 __ Mov(w1, shift[0]);
6725 __ Mov(w2, shift[1]);
6726 __ Mov(w3, shift[2]);
6727 __ Mov(w4, shift[3]);
6728 __ Mov(w5, shift[4]);
6729 __ Mov(w6, shift[5]);
6734 __ rorv(x0, x0, xzr);
6737 __ Ror(x16, x0, x1);
6738 __ Ror(x17, x0, x2);
6739 __ Ror(x18, x0, x3);
6740 __ Ror(x19, x0, x4);
6741 __ Ror(x20, x0, x5);
6742 __ Ror(x21, x0, x6);
6744 __ Ror(w22, w0, w1);
6745 __ Ror(w23, w0, w2);
6746 __ Ror(w24, w0, w3);
6747 __ Ror(w25, w0, w4);
6748 __ Ror(w26, w0, w5);
6749 __ Ror(w27, w0, w6);
6776 __ Mov(x1, 0x0123456789abcdef);
6778 __ Mov(x10, 0x8888888888888888);
6779 __ Mov(x11, 0x8888888888888888);
6780 __ Mov(x12, 0x8888888888888888);
6781 __ Mov(x13, 0x8888888888888888);
6782 __ Mov(x14, 0xffffffffffffffff);
6783 __ Mov(w20, 0x88888888);
6784 __ Mov(w21, 0x88888888);
6786 __ Bfm(x10, x1, 16, 31);
6787 __ Bfm(x11, x1, 32, 15);
6789 __ Bfm(w20, w1, 16, 23);
6790 __ Bfm(w21, w1, 24, 15);
6793 __ Bfi(x12, x1, 16, 8);
6794 __ Bfxil(x13, x1, 16, 8);
6795 __ Bfc(x14, 16, 8);
6819 __ Mov(x1, 0x0123456789abcdef);
6820 __ Mov(x2, 0xfedcba9876543210);
6822 __ Sbfm(x10, x1, 16, 31);
6823 __ Sbfm(x11, x1, 32, 15);
6824 __ Sbfm(x12, x1, 32, 47);
6825 __ Sbfm(x13, x1, 48, 35);
6827 __ Sbfm(w14, w1, 16, 23);
6828 __ Sbfm(w15, w1, 24, 15);
6829 __ Sbfm(w16, w2, 16, 23);
6830 __ Sbfm(w17, w2, 24, 15);
6833 __ Asr(x18, x1, 32);
6834 __ Asr(x19, x2, 32);
6835 __ Sbfiz(x20, x1, 8, 16);
6836 __ Sbfiz(x21, x2, 8, 16);
6837 __ Sbfx(x22, x1, 8, 16);
6838 __ Sbfx(x23, x2, 8, 16);
6839 __ Sxtb(x24, w1);
6840 __ Sxtb(x25, x2);
6841 __ Sxth(x26, w1);
6842 __ Sxth(x27, x2);
6843 __ Sxtw(x28, w1);
6844 __ Sxtw(x29, x2);
6881 __ Mov(x1, 0x0123456789abcdef);
6882 __ Mov(x2, 0xfedcba9876543210);
6884 __ Mov(x10, 0x8888888888888888);
6885 __ Mov(x11, 0x8888888888888888);
6887 __ Ubfm(x10, x1, 16, 31);
6888 __ Ubfm(x11, x1, 32, 15);
6889 __ Ubfm(x12, x1, 32, 47);
6890 __ Ubfm(x13, x1, 48, 35);
6892 __ Ubfm(w25, w1, 16, 23);
6893 __ Ubfm(w26, w1, 24, 15);
6894 __ Ubfm(w27, w2, 16, 23);
6895 __ Ubfm(w28, w2, 24, 15);
6898 __ Lsl(x15, x1, 63);
6899 __ Lsl(x16, x1, 0);
6900 __ Lsr(x17, x1, 32);
6901 __ Ubfiz(x18, x1, 8, 16);
6902 __ Ubfx(x19, x1, 8, 16);
6903 __ Uxtb(x20, x1);
6904 __ Uxth(x21, x1);
6905 __ Uxtw(x22, x1);
6937 __ Mov(x1, 0x0123456789abcdef);
6938 __ Mov(x2, 0xfedcba9876543210);
6940 __ Extr(w10, w1, w2, 0);
6941 __ Extr(w11, w1, w2, 1);
6942 __ Extr(x12, x2, x1, 2);
6944 __ Ror(w13, w1, 0);
6945 __ Ror(w14, w2, 17);
6946 __ Ror(w15, w1, 31);
6947 __ Ror(x18, x2, 0);
6948 __ Ror(x19, x2, 1);
6949 __ Ror(x20, x1, 63);
6972 __ Mov(w0, 0);
6973 __ Mov(w1, 1);
6974 __ Mov(w2, 0x80000000);
6977 __ Cmp(w0, w0);
6978 __ Mrs(x3, NZCV);
6981 __ Cmp(w0, w1);
6982 __ Mrs(x4, NZCV);
6985 __ Adds(w0, w2, w2);
6986 __ Mrs(x5, NZCV);
6989 __ Mrs(x6, FPCR);
7011 __ Mrs(x1, RNDR);
7014 __ Mrs(x2, NZCV);
7015 __ Mrs(x3, RNDR);
7016 __ Mrs(x4, NZCV);
7019 __ Mrs(x5, RNDRRS);
7022 __ Mrs(x6, NZCV);
7023 __ Mrs(x7, RNDRRS);
7024 __ Mrs(x8, NZCV);
7048 __ Mov(w0, 1);
7051 __ Cmp(w0, 0);
7052 __ Mrs(x1, NZCV);
7055 __ Cfinv();
7056 __ Mrs(x2, NZCV);
7059 __ Cfinv();
7060 __ Mrs(x3, NZCV);
7116 __ Mov(x0, i << Flags_offset);
7117 __ Msr(NZCV, x0);
7118 __ Axflag();
7119 __ Mrs(x1, NZCV);
7120 __ Msr(NZCV, x0);
7121 __ Xaflag();
7122 __ Mrs(x2, NZCV);
7144 __ Mov(w0, 0);
7145 __ Mov(w1, 0x7fffffff);
7147 __ Mov(x7, 0);
7149 __ Mov(x10, NVFlag);
7150 __ Cmp(w0, w0); // Set Z and C.
7151 __ Msr(NZCV, x10); // Set N and V.
7153 __ Cinc(x7, x7, mi); // N
7154 __ Cinc(x7, x7, ne); // !Z
7155 __ Cinc(x7, x7, lo); // !C
7156 __ Cinc(x7, x7, vs); // V
7158 __ Mov(x10, ZCFlag);
7159 __ Cmn(w1, w1); // Set N and V.
7160 __ Msr(NZCV, x10); // Set Z and C.
7162 __ Cinc(x7, x7, pl); // !N
7163 __ Cinc(x7, x7, eq); // Z
7164 __ Cinc(x7, x7, hs); // C
7165 __ Cinc(x7, x7, vc); // !V
7168 __ Mrs(old_fpcr, FPCR);
7171 __ Mov(x8, fpcr_core);
7172 __ Msr(FPCR, x8);
7173 __ Mrs(x8, FPCR);
7190 __ Mov(x9, fpcr_all);
7191 __ Msr(FPCR, x9);
7192 __ Mrs(x9, FPCR);
7193 __ And(x9, x9, fpcr_core);
7199 __ Mov(x10, ~fpcr_all);
7200 __ Msr(FPCR, x10);
7201 __ Mrs(x10, FPCR);
7204 __ Msr(FPCR, old_fpcr);
7235 __ Mov(x20, sp);
7238 __ Mov(x16, 0x477d469dec0b8760);
7239 __ Mov(sp, 0x477d469dec0b8760);
7242 __ Mov(x17, 0x0000000012345678);
7243 __ Pacia1716();
7244 __ Mov(x0, x17);
7246 __ Mov(lr, 0x0000000012345678);
7247 __ Paciaz();
7248 __ Mov(x1, lr);
7250 __ Mov(lr, 0x0000000012345678);
7251 __ Paciasp();
7252 __ Mov(x2, lr);
7255 __ Mov(x17, x0);
7256 __ Autia1716();
7257 __ Mov(x3, x17);
7259 __ Mov(lr, x1);
7260 __ Autiaz();
7261 __ Mov(x4, lr);
7263 __ Mov(lr, x2);
7264 __ Autiasp();
7265 __ Mov(x5, lr);
7268 __ Mov(x17, x1);
7269 __ Autia1716();
7270 __ Mov(x6, x17);
7272 __ Mov(lr, x0);
7273 __ Autiaz();
7274 __ Mov(x7, lr);
7276 __ Mov(lr, x1);
7277 __ Autiasp();
7278 __ Mov(x8, lr);
7281 __ Mov(lr, x0);
7282 __ Xpaclri();
7283 __ Mov(x9, lr);
7286 __ Mov(sp, x20);
7290 __ And(x0, x0, 0x007f000000000000);
7291 __ And(x1, x1, 0x007f000000000000);
7292 __ And(x2, x2, 0x007f000000000000);
7335 __ Mov(x20, sp);
7338 __ Mov(x16, 0x477d469dec0b8760);
7339 __ Mov(sp, 0x477d469dec0b8760);
7342 __ Mov(x17, 0x0000000012345678);
7343 __ Pacib1716();
7344 __ Mov(x0, x17);
7346 __ Mov(lr, 0x0000000012345678);
7347 __ Pacibz();
7348 __ Mov(x1, lr);
7350 __ Mov(lr, 0x0000000012345678);
7351 __ Pacibsp();
7352 __ Mov(x2, lr);
7355 __ Mov(x17, x0);
7356 __ Autib1716();
7357 __ Mov(x3, x17);
7359 __ Mov(lr, x1);
7360 __ Autibz();
7361 __ Mov(x4, lr);
7363 __ Mov(lr, x2);
7364 __ Autibsp();
7365 __ Mov(x5, lr);
7368 __ Mov(x17, x1);
7369 __ Autib1716();
7370 __ Mov(x6, x17);
7372 __ Mov(lr, x0);
7373 __ Autibz();
7374 __ Mov(x7, lr);
7376 __ Mov(lr, x1);
7377 __ Autibsp();
7378 __ Mov(x8, lr);
7381 __ Mov(lr, x0);
7382 __ Xpaclri();
7383 __ Mov(x9, lr);
7386 __ Mov(sp, x20);
7390 __ And(x0, x0, 0x007f000000000000);
7391 __ And(x1, x1, 0x007f000000000000);
7392 __ And(x2, x2, 0x007f000000000000);
7429 MUST_FAIL_WITH_MESSAGE(__ Pacia1716(),
7438 MUST_FAIL_WITH_MESSAGE(__ Pacia1716(),
7448 MUST_FAIL_WITH_MESSAGE(__ Pacia1716(),
7454 MUST_FAIL_WITH_MESSAGE(__ Pacib1716(),
7457 MUST_FAIL_WITH_MESSAGE(__ Autia1716(),
7460 MUST_FAIL_WITH_MESSAGE(__ Autib1716(),
7476 __ Nop();
7477 __ Esb();
7478 __ Csdb();
7496 __ Adr(x0, &jump_target);
7497 __ Br(x0);
7498 __ Nop();
7499 __ Bind(&jump_target, EmitBTI_j);
7500 __ Adr(x0, &call_target);
7501 __ Blr(x0);
7502 __ Adr(ipreg, &jump_call_target);
7503 __ Blr(ipreg);
7504 __ Adr(lr, &done); // Make Ret return to done label.
7505 __ Br(ipreg);
7506 __ Bind(&call_target, EmitBTI_c);
7507 __ Ret();
7508 __ Bind(&jump_call_target, EmitBTI_jc);
7509 __ Ret();
7510 __ Bind(&done);
7533 __ B(&start);
7534 __ Bind(&none, EmitBTI);
7535 __ Bind(&c, EmitBTI_c);
7536 __ Bind(&j, EmitBTI_j);
7537 __ Bind(&jc, EmitBTI_jc);
7538 VIXL_CHECK(__ GetSizeOfCodeGeneratedSince(&none) == 4 * kInstructionSize);
7539 __ Ret();
7542 __ Bind(&start);
7543 __ Adr(x0, &none);
7544 __ Adr(lr, &jump_to_c);
7545 __ Br(x0);
7547 __ Bind(&jump_to_c);
7548 __ Adr(x0, &c);
7549 __ Adr(lr, &call_to_j);
7550 __ Br(x0);
7552 __ Bind(&call_to_j);
7553 __ Adr(x0, &j);
7554 __ Blr(x0);
7575 __ Adr(x17, &l);
7576 __ Br(x17);
7577 __ Nop();
7578 __ Bind(&l);
7579 __ Nop();
7599 __ Adr(x0, &l);
7600 __ Br(x0);
7601 __ Nop();
7602 __ Bind(&l);
7603 __ Nop();
7623 __ Adr(x0, &l);
7624 __ Blr(x0);
7625 __ Nop();
7626 __ Bind(&l);
7627 __ Nop();
7648 __ Adr(x0, &jump_target);
7649 __ Br(x0);
7650 __ Nop();
7651 __ Bind(&jump_target, EmitBTI_c);
7652 __ Nop();
7671 __ Adr(x0, &call_target);
7672 __ Blr(x0);
7673 __ Nop();
7674 __ Bind(&call_target, EmitBTI_j);
7675 __ Nop();
7694 __ Mov(x0, 0); // 'Normal' instruction sets BTYPE to zero.
7695 __ Bind(&target, EmitBTI);
7696 __ Add(x0, x0, 1);
7697 __ Bind(&target_j, EmitBTI_j);
7698 __ Add(x0, x0, 1);
7699 __ Bind(&target_c, EmitBTI_c);
7700 __ Add(x0, x0, 1);
7701 __ Bind(&target_jc, EmitBTI_jc);
7702 __ Add(x0, x0, 1);
7703 __ Paciasp();
7725 __ Mov(x30, sp);
7728 __ Mov(x0, 0);
7729 __ Mov(x1, literal_base);
7731 __ Add(XRegister(i), XRegister(i - 1), x1);
7739 __ add(xzr, x0, x1);
7740 __ add(xzr, x1, xzr);
7741 __ add(xzr, xzr, x1);
7743 __ and_(xzr, x0, x2);
7744 __ and_(xzr, x2, xzr);
7745 __ and_(xzr, xzr, x2);
7747 __ bic(xzr, x0, x3);
7748 __ bic(xzr, x3, xzr);
7749 __ bic(xzr, xzr, x3);
7751 __ eon(xzr, x0, x4);
7752 __ eon(xzr, x4, xzr);
7753 __ eon(xzr, xzr, x4);
7755 __ eor(xzr, x0, x5);
7756 __ eor(xzr, x5, xzr);
7757 __ eor(xzr, xzr, x5);
7759 __ orr(xzr, x0, x6);
7760 __ orr(xzr, x6, xzr);
7761 __ orr(xzr, xzr, x6);
7763 __ sub(xzr, x0, x7);
7764 __ sub(xzr, x7, xzr);
7765 __ sub(xzr, xzr, x7);
7771 __ Mov(x29, x30);
7772 __ Mov(x30, sp);
7773 __ Mov(sp, x29);
7776 __ Add(x29, x28, x1);
7795 __ Mov(x30, sp);
7798 __ Mov(x0, 0);
7799 __ Mov(x1, literal_base);
7801 __ Add(XRegister(i), XRegister(i - 1), x1);
7809 __ adds(xzr, x0, Operand(x1, UXTX));
7810 __ adds(xzr, x1, Operand(xzr, UXTX));
7811 __ adds(xzr, x1, 1234);
7812 __ adds(xzr, x0, x1);
7813 __ adds(xzr, x1, xzr);
7814 __ adds(xzr, xzr, x1);
7819 __ ands(xzr, x2, ~0xf);
7820 __ ands(xzr, xzr, ~0xf);
7821 __ ands(xzr, x0, x2);
7822 __ ands(xzr, x2, xzr);
7823 __ ands(xzr, xzr, x2);
7828 __ bics(xzr, x3, ~0xf);
7829 __ bics(xzr, xzr, ~0xf);
7830 __ bics(xzr, x0, x3);
7831 __ bics(xzr, x3, xzr);
7832 __ bics(xzr, xzr, x3);
7837 __ subs(xzr, x0, Operand(x3, UXTX));
7838 __ subs(xzr, x3, Operand(xzr, UXTX));
7839 __ subs(xzr, x3, 1234);
7840 __ subs(xzr, x0, x3);
7841 __ subs(xzr, x3, xzr);
7842 __ subs(xzr, xzr, x3);
7848 __ Mov(x29, x30);
7849 __ Mov(x30, sp);
7850 __ Mov(sp, x29);
7853 __ Add(x29, x28, x1);
7871 VIXL_CHECK(sp.Is(__ StackPointer()));
7872 __ SetStackPointer(x0);
7873 VIXL_CHECK(x0.Is(__ StackPointer()));
7874 __ SetStackPointer(x28);
7875 VIXL_CHECK(x28.Is(__ StackPointer()));
7876 __ SetStackPointer(sp);
7877 VIXL_CHECK(sp.Is(__ StackPointer()));
7903 __ Mov(x0, literal_base);
7904 __ Add(x1, x0, x0);
7905 __ Add(x2, x1, x0);
7906 __ Add(x3, x2, x0);
7908 __ Claim(32);
7914 __ Poke(x0, 0);
7915 __ Poke(x1, 8);
7916 __ Poke(x2, 16);
7917 __ Poke(x3, 24);
7919 __ Peek(x0, 0);
7920 __ Peek(x1, 8);
7921 __ Peek(x2, 16);
7922 __ Peek(x3, 24);
7924 __ Poke(w0, 0);
7925 __ Poke(w1, 4);
7926 __ Poke(w2, 8);
7927 __ Poke(w3, 12);
7929 __ Peek(w10, 0);
7930 __ Peek(w11, 4);
7931 __ Peek(w12, 8);
7932 __ Peek(w13, 12);
7934 __ Drop(32);
7965 __ Mov(x0, literal_base);
7966 __ Add(x1, x0, x0);
7967 __ Add(x2, x1, x0);
7968 __ Add(x3, x2, x0);
7969 __ Add(x4, x3, x0);
7970 __ Add(x5, x4, x0);
7971 __ Add(x6, x5, x0);
7973 __ Claim(32);
7979 __ Poke(x0, 1);
7981 __ Peek(x0, 1);
7982 __ Poke(x1, 2);
7984 __ Peek(x1, 2);
7985 __ Poke(x2, 3);
7987 __ Peek(x2, 3);
7988 __ Poke(x3, 4);
7990 __ Peek(x3, 4);
7991 __ Poke(x4, 5);
7993 __ Peek(x4, 5);
7994 __ Poke(x5, 6);
7996 __ Peek(x5, 6);
7997 __ Poke(x6, 7);
7999 __ Peek(x6, 7);
8001 __ Poke(w0, 1);
8003 __ Peek(w10, 1);
8004 __ Poke(w1, 2);
8006 __ Peek(w11, 2);
8007 __ Poke(w2, 3);
8009 __ Peek(w12, 3);
8011 __ Drop(32);
8044 __ Mov(x0, literal_base);
8045 __ Add(x1, x0, x0);
8047 __ Claim(32);
8053 __ Poke(x0, 0);
8054 __ Poke(x0, 8);
8055 __ Peek(x4, 4);
8057 __ Poke(w1, 0);
8058 __ Poke(w1, 4);
8059 __ Peek(w5, 2);
8061 __ Drop(32);
8097 __ Mov(x0, literal_base);
8098 __ Add(x1, x0, x0);
8099 __ Add(x2, x1, x0);
8100 __ Add(x3, x2, x0);
8102 __ Claim(32);
8109 __ Poke(x1, 8);
8110 __ Poke(x0, 0);
8112 VIXL_ASSERT(__ StackPointer().Is(sp));
8113 __ Mov(x4, __ StackPointer());
8114 __ SetStackPointer(x4);
8116 __ Poke(wzr, 0); // Clobber the space we're about to drop.
8117 __ Drop(4);
8118 __ Peek(x6, 0);
8119 __ Claim(8);
8120 __ Peek(w7, 10);
8121 __ Poke(x3, 28);
8122 __ Poke(xzr, 0); // Clobber the space we're about to drop.
8123 __ Drop(8);
8124 __ Poke(x2, 12);
8125 __ Push(w0);
8127 __ Mov(sp, __ StackPointer());
8128 __ SetStackPointer(sp);
8131 __ Pop(x0, x1, x2, x3);
8172 __ Mov(x1, base);
8173 __ Add(x2, x1, x1);
8174 __ Add(x3, x2, x1);
8175 __ Add(x4, x3, x1);
8181 __ Claim(2 * list_1_size);
8183 __ PokeCPURegList(list_1, 0);
8184 __ PokeXRegList(list_1.GetList(), list_1_size);
8185 __ PeekCPURegList(list_2, 2 * kXRegSizeInBytes);
8186 __ PeekXRegList(x15.GetBit(), kWRegSizeInBytes);
8187 __ PeekWRegList(w16.GetBit() | w17.GetBit(), 3 * kXRegSizeInBytes);
8189 __ Drop(2 * list_1_size);
8195 __ Mov(x1, base_d);
8196 __ Add(x2, x1, x1);
8197 __ Add(x3, x2, x1);
8198 __ Add(x4, x3, x1);
8199 __ Fmov(d1, x1);
8200 __ Fmov(d2, x2);
8201 __ Fmov(d3, x3);
8202 __ Fmov(d4, x4);
8208 __ Claim(2 * list_d_1_size);
8210 __ PokeCPURegList(list_d_1, 0);
8211 __ PokeDRegList(list_d_1.GetList(), list_d_1_size);
8212 __ PeekCPURegList(list_d_2, 2 * kDRegSizeInBytes);
8213 __ PeekDRegList(d15.GetBit(), kSRegSizeInBytes);
8214 __ PeekSRegList(s16.GetBit() | s17.GetBit(), 3 * kDRegSizeInBytes);
8216 __ Drop(2 * list_d_1_size);
8263 __ Mov(x1, base);
8264 __ Add(x2, x1, x1);
8265 __ Add(x3, x2, x1);
8266 __ Add(x4, x3, x1);
8267 __ Fmov(d1, x1);
8268 __ Fmov(d2, x2);
8269 __ Fmov(d3, x3);
8270 __ Fmov(d4, x4);
8271 __ Fmov(d5, x1);
8272 __ Fmov(d6, x2);
8273 __ Fmov(d7, x3);
8274 __ Fmov(d8, x4);
8280 __ Mov(reg_base, reinterpret_cast<uintptr_t>(&array));
8288 __ StoreCPURegList(list_src, MemOperand(reg_base, 0 * sizeof(uint64_t)));
8289 __ LoadCPURegList(list_dst, MemOperand(reg_base, 0 * sizeof(uint64_t)));
8292 __ Mov(reg_index, size_stored);
8293 __ StoreCPURegList(list_src, MemOperand(reg_base, reg_index));
8294 __ LoadCPURegList(list_dst, MemOperand(reg_base, reg_index));
8297 __ StoreCPURegList(list_fp_src_1, MemOperand(reg_base, size_stored));
8298 __ LoadCPURegList(list_fp_dst_1, MemOperand(reg_base, size_stored));
8301 __ Mov(reg_index, size_stored);
8302 __ StoreCPURegList(list_fp_src_1, MemOperand(reg_base, reg_index));
8303 __ LoadCPURegList(list_fp_dst_1, MemOperand(reg_base, reg_index));
8310 __ Str(wzr, MemOperand(reg_base, size_stored));
8312 __ StoreCPURegList(list_fp_src_2, MemOperand(reg_base, size_stored));
8313 __ LoadCPURegList(list_fp_dst_2, MemOperand(reg_base, size_stored));
8316 __ Mov(reg_index, size_stored);
8317 __ StoreCPURegList(list_fp_src_2, MemOperand(reg_base, reg_index));
8318 __ LoadCPURegList(list_fp_dst_2, MemOperand(reg_base, reg_index));
8419 VIXL_ASSERT(__ StackPointer().Is(sp));
8420 __ Mov(stack_pointer, __ StackPointer());
8421 __ SetStackPointer(stack_pointer);
8429 __ Mov(x[i], literal_base * i);
8433 __ Claim(claim);
8439 __ Push(r[i - 1], r[i - 2], r[i - 3], r[i - 4]);
8444 __ Push(r[2], r[1], r[0]);
8447 __ Push(r[1], r[0]);
8450 __ Push(r[0]);
8458 __ PushSizeRegList(list, reg_size);
8469 __ Pop(r[i], r[i + 1], r[i + 2], r[i + 3]);
8474 __ Pop(r[i], r[i + 1], r[i + 2]);
8477 __ Pop(r[i], r[i + 1]);
8480 __ Pop(r[i]);
8488 __ PopSizeRegList(list, reg_size);
8493 __ Drop(claim);
8495 __ Mov(sp, __ StackPointer());
8496 __ SetStackPointer(sp);
8667 VIXL_ASSERT(__ StackPointer().Is(sp));
8668 __ Mov(stack_pointer, __ StackPointer());
8669 __ SetStackPointer(stack_pointer);
8674 __ Mov(x0, 0);
8675 __ Mov(x1, literal_base);
8679 __ Fmov(d[i], x0);
8681 __ Add(x0, x0, x1);
8685 __ Claim(claim);
8691 __ Push(v[i - 1], v[i - 2], v[i - 3], v[i - 4]);
8696 __ Push(v[2], v[1], v[0]);
8699 __ Push(v[1], v[0]);
8702 __ Push(v[0]);
8710 __ PushSizeRegList(list, reg_size, CPURegister::kVRegister);
8721 __ Pop(v[i], v[i + 1], v[i + 2], v[i + 3]);
8726 __ Pop(v[i], v[i + 1], v[i + 2]);
8729 __ Pop(v[i], v[i + 1]);
8732 __ Pop(v[i]);
8740 __ PopSizeRegList(list, reg_size, CPURegister::kVRegister);
8745 __ Drop(claim);
8747 __ Mov(sp, __ StackPointer());
8748 __ SetStackPointer(sp);
8908 VIXL_ASSERT(__ StackPointer().Is(sp));
8909 __ Mov(stack_pointer, __ StackPointer());
8910 __ SetStackPointer(stack_pointer);
8913 __ Claim(claim);
8915 __ Mov(x[3], literal_base * 3);
8916 __ Mov(x[2], literal_base * 2);
8917 __ Mov(x[1], literal_base * 1);
8918 __ Mov(x[0], literal_base * 0);
8920 __ PushSizeRegList(r0_to_r3, reg_size);
8921 __ Push(r[3], r[2]);
8924 __ PopSizeRegList(r0_to_r3, reg_size);
8926 __ Push(r[2], r[1], r[3], r[0]);
8929 __ Pop(r[4], r[5]);
8931 __ Pop(r[6], r[7], r[8], r[9]);
8934 __ Drop(claim);
8936 __ Mov(sp, __ StackPointer());
8937 __ SetStackPointer(sp);
9015 VIXL_ASSERT(__ StackPointer().Is(sp));
9016 __ Mov(stack_pointer, __ StackPointer());
9017 __ SetStackPointer(stack_pointer);
9023 __ Mov(x[i], literal_base * i);
9027 __ Claim(claim);
9068 __ PushMultipleTimes(times, w[i]);
9080 __ PushMultipleTimes(times, x[i]);
9097 __ Drop((active_w_slots - requested_w_slots) * kWRegSizeInBytes);
9114 __ Pop(x[i]);
9117 __ Pop(w[i]);
9125 __ Drop(claim);
9127 __ Mov(sp, __ StackPointer());
9128 __ SetStackPointer(sp);
9180 VIXL_ASSERT(sp.Is(__ StackPointer()));
9186 __ Mov(x3, 0x3333333333333333);
9187 __ Mov(x2, 0x2222222222222222);
9188 __ Mov(x1, 0x1111111111111111);
9189 __ Mov(x0, 0x0000000000000000);
9190 __ Claim(2 * kXRegSizeInBytes);
9191 __ PushXRegList(x0.GetBit() | x1.GetBit() | x2.GetBit() | x3.GetBit());
9192 __ Push(x3, x2);
9193 __ PopXRegList(x0.GetBit() | x1.GetBit() | x2.GetBit() | x3.GetBit());
9194 __ Push(x2, x1, x3, x0);
9195 __ Pop(x4, x5);
9196 __ Pop(x6, x7, x8, x9);
9198 __ Claim(2 * kXRegSizeInBytes);
9199 __ PushWRegList(w0.GetBit() | w1.GetBit() | w2.GetBit() | w3.GetBit());
9200 __ Push(w3, w1, w2, w0);
9201 __ PopWRegList(w10.GetBit() | w11.GetBit() | w12.GetBit() | w13.GetBit());
9202 __ Pop(w14, w15, w16, w17);
9204 __ Claim(2 * kXRegSizeInBytes);
9205 __ Push(w2, w2, w1, w1);
9206 __ Push(x3, x3);
9207 __ Pop(w18, w19, w20, w21);
9208 __ Pop(x22, x23);
9210 __ Claim(2 * kXRegSizeInBytes);
9211 __ PushXRegList(x1.GetBit() | x22.GetBit());
9212 __ PopXRegList(x24.GetBit() | x26.GetBit());
9214 __ Claim(2 * kXRegSizeInBytes);
9215 __ PushWRegList(w1.GetBit() | w2.GetBit() | w4.GetBit() | w22.GetBit());
9216 __ PopWRegList(w25.GetBit() | w27.GetBit() | w28.GetBit() | w29.GetBit());
9218 __ Claim(2 * kXRegSizeInBytes);
9219 __ PushXRegList(0);
9220 __ PopXRegList(0);
9221 __ PushXRegList(0xffffffff);
9222 __ PopXRegList(0xffffffff);
9223 __ Drop(12 * kXRegSizeInBytes);
9281 __ Mov(x29, __ StackPointer());
9284 __ Mov(x0, 1234);
9285 __ Mov(x1, 0x1234);
9288 __ Fmov(d0, 1.234);
9291 __ Mov(x2, reinterpret_cast<uintptr_t>(test_substring));
9294 __ Mov(w3, 0xffffffff);
9295 __ Mov(w4, 0xffffffff);
9296 __ Mov(x5, 0xffffffffffffffff);
9297 __ Mov(x6, 0xffffffffffffffff);
9298 __ Fmov(s1, 1.234);
9299 __ Fmov(s2, 2.345);
9300 __ Fmov(d3, 3.456);
9301 __ Fmov(d4, 4.567);
9304 __ Mov(x28, 0x123456789abcdef);
9305 __ Fmov(d10, 42.0);
9308 __ Mov(x10, 3);
9309 __ Mov(x11, 40);
9310 __ Mov(x12, 500);
9313 __ Mov(w13, 'x');
9318 __ Printf(test_plain_string); // NOLINT(runtime/printf)
9319 __ Printf("x0: %" PRId64 ", x1: 0x%08" PRIx64 "\n", x0, x1);
9320 __ Printf("w5: %" PRId32 ", x5: %" PRId64 "\n", w5, x5);
9321 __ Printf("d0: %f\n", d0);
9322 __ Printf("Test %%s: %s\n", x2);
9323 __ Printf("w3(uint32): %" PRIu32 "\nw4(int32): %" PRId32
9330 __ Printf("%%f: %f\n%%g: %g\n%%e: %e\n%%E: %E\n", s1, s2, d3, d4);
9331 __ Printf("0x%" PRIx32 ", 0x%" PRIx64 "\n", w28, x28);
9332 __ Printf("%g\n", d10);
9333 __ Printf("%%%%%s%%%c%%\n", x2, w13);
9336 __ Printf("StackPointer(sp): 0x%016" PRIx64 ", 0x%08" PRIx32 "\n",
9337 __ StackPointer(),
9338 __ StackPointer().W());
9341 const Register old_stack_pointer = __ StackPointer();
9342 __ Mov(x29, old_stack_pointer);
9343 __ SetStackPointer(x29);
9345 __ Printf("StackPointer(not sp): 0x%016" PRIx64 ", 0x%08" PRIx32 "\n",
9346 __ StackPointer(),
9347 __ StackPointer().W());
9348 __ Mov(old_stack_pointer, __ StackPointer());
9349 __ SetStackPointer(old_stack_pointer);
9352 __ Printf("3=%u, 4=%u, 5=%u\n", x10, x11, x12);
9355 __ Printf("w3: %" PRIu32 ", s1: %f, x5: %" PRIu64 ", d3: %f\n",
9360 __ Printf("s1: %f, d3: %f, w3: %" PRId32 ", x5: %" PRId64 "\n",
9389 __ PrintfNoPreserve(test_plain_string);
9390 __ Mov(x19, x0);
9393 __ Mov(x0, 1234);
9394 __ Mov(x1, 0x1234);
9395 __ PrintfNoPreserve("x0: %" PRId64 ", x1: 0x%08" PRIx64 "\n", x0, x1);
9396 __ Mov(x20, x0);
9399 __ Fmov(d0, 1.234);
9400 __ PrintfNoPreserve("d0: %f\n", d0);
9401 __ Mov(x21, x0);
9404 __ Mov(x2, reinterpret_cast<uintptr_t>(test_substring));
9405 __ PrintfNoPreserve("Test %%s: %s\n", x2);
9406 __ Mov(x22, x0);
9409 __ Mov(w3, 0xffffffff);
9410 __ Mov(w4, 0xffffffff);
9411 __ Mov(x5, 0xffffffffffffffff);
9412 __ Mov(x6, 0xffffffffffffffff);
9413 __ PrintfNoPreserve("w3(uint32): %" PRIu32 "\nw4(int32): %" PRId32
9420 __ Mov(x23, x0);
9422 __ Fmov(s1, 1.234);
9423 __ Fmov(s2, 2.345);
9424 __ Fmov(d3, 3.456);
9425 __ Fmov(d4, 4.567);
9426 __ PrintfNoPreserve("%%f: %f\n%%g: %g\n%%e: %e\n%%E: %E\n", s1, s2, d3, d4);
9427 __ Mov(x24, x0);
9430 __ Mov(x28, 0x123456789abcdef);
9431 __ PrintfNoPreserve("0x%" PRIx32 ", 0x%" PRIx64 "\n", w28, x28);
9432 __ Mov(x25, x0);
9434 __ Fmov(d10, 42.0);
9435 __ PrintfNoPreserve("%g\n", d10);
9436 __ Mov(x26, x0);
9439 const Register old_stack_pointer = __ StackPointer();
9440 __ Mov(x29, old_stack_pointer);
9441 __ SetStackPointer(x29);
9443 __ PrintfNoPreserve("StackPointer(not sp): 0x%016" PRIx64 ", 0x%08" PRIx32
9445 __ StackPointer(),
9446 __ StackPointer().W());
9447 __ Mov(x27, x0);
9448 __ Mov(old_stack_pointer, __ StackPointer());
9449 __ SetStackPointer(old_stack_pointer);
9452 __ Mov(x3, 3);
9453 __ Mov(x4, 40);
9454 __ Mov(x5, 500);
9455 __ PrintfNoPreserve("3=%u, 4=%u, 5=%u\n", x3, x4, x5);
9456 __ Mov(x28, x0);
9459 __ Mov(w3, 0xffffffff);
9460 __ Fmov(s1, 1.234);
9461 __ Mov(x5, 0xffffffffffffffff);
9462 __ Fmov(d3, 3.456);
9463 __ PrintfNoPreserve("w3: %" PRIu32 ", s1: %f, x5: %" PRIu64 ", d3: %f\n",
9468 __ Mov(x29, x0);
9519 __ Bind(&start);
9520 __ Trace(LOG_ALL, TRACE_ENABLE);
9521 __ Trace(LOG_ALL, TRACE_DISABLE);
9523 VIXL_CHECK(__ GetSizeOfCodeGeneratedSince(&start) > 0);
9525 VIXL_CHECK(__ GetSizeOfCodeGeneratedSince(&start) == 0);
9539 __ Bind(&start);
9540 __ Log(LOG_ALL);
9542 VIXL_CHECK(__ GetSizeOfCodeGeneratedSince(&start) > 0);
9544 VIXL_CHECK(__ GetSizeOfCodeGeneratedSince(&start) == 0);
9559 __ Mov(x0, 0x0);
9560 __ Adr(lr, &target);
9562 __ Blr(lr);
9563 __ Mov(x0, 0xdeadbeef);
9564 __ B(&end);
9566 __ Bind(&target);
9567 __ Mov(x0, 0xc001c0de);
9569 __ Bind(&end);
9587 __ Dmb(FullSystem, BarrierAll);
9588 __ Dmb(FullSystem, BarrierReads);
9589 __ Dmb(FullSystem, BarrierWrites);
9590 __ Dmb(FullSystem, BarrierOther);
9592 __ Dmb(InnerShareable, BarrierAll);
9593 __ Dmb(InnerShareable, BarrierReads);
9594 __ Dmb(InnerShareable, BarrierWrites);
9595 __ Dmb(InnerShareable, BarrierOther);
9597 __ Dmb(NonShareable, BarrierAll);
9598 __ Dmb(NonShareable, BarrierReads);
9599 __ Dmb(NonShareable, BarrierWrites);
9600 __ Dmb(NonShareable, BarrierOther);
9602 __ Dmb(OuterShareable, BarrierAll);
9603 __ Dmb(OuterShareable, BarrierReads);
9604 __ Dmb(OuterShareable, BarrierWrites);
9605 __ Dmb(OuterShareable, BarrierOther);
9608 __ Dsb(FullSystem, BarrierAll);
9609 __ Dsb(FullSystem, BarrierReads);
9610 __ Dsb(FullSystem, BarrierWrites);
9611 __ Dsb(FullSystem, BarrierOther);
9613 __ Dsb(InnerShareable, BarrierAll);
9614 __ Dsb(InnerShareable, BarrierReads);
9615 __ Dsb(InnerShareable, BarrierWrites);
9616 __ Dsb(InnerShareable, BarrierOther);
9618 __ Dsb(NonShareable, BarrierAll);
9619 __ Dsb(NonShareable, BarrierReads);
9620 __ Dsb(NonShareable, BarrierWrites);
9621 __ Dsb(NonShareable, BarrierOther);
9623 __ Dsb(OuterShareable, BarrierAll);
9624 __ Dsb(OuterShareable, BarrierReads);
9625 __ Dsb(OuterShareable, BarrierWrites);
9626 __ Dsb(OuterShareable, BarrierOther);
9629 __ Isb();
9650 __ Mov(x10, reinterpret_cast<uintptr_t>(&b[1]));
9651 __ Ldarb(w0, MemOperand(x10));
9652 __ Add(w0, w0, 1);
9653 __ Stlrb(w0, MemOperand(x10));
9655 __ Mov(x10, reinterpret_cast<uintptr_t>(&h[1]));
9656 __ Ldarh(w0, MemOperand(x10));
9657 __ Add(w0, w0, 1);
9658 __ Stlrh(w0, MemOperand(x10));
9660 __ Mov(x10, reinterpret_cast<uintptr_t>(&w[1]));
9661 __ Ldar(w0, MemOperand(x10));
9662 __ Add(w0, w0, 1);
9663 __ Stlr(w0, MemOperand(x10));
9665 __ Mov(x10, reinterpret_cast<uintptr_t>(&x[1]));
9666 __ Ldar(x0, MemOperand(x10));
9667 __ Add(x0, x0, 1);
9668 __ Stlr(x0, MemOperand(x10));
9704 __ Mov(x10, reinterpret_cast<uintptr_t>(&b[1]));
9705 __ Ldlarb(w0, MemOperand(x10));
9706 __ Add(w0, w0, 1);
9707 __ Stllrb(w0, MemOperand(x10));
9709 __ Mov(x10, reinterpret_cast<uintptr_t>(&h[1]));
9710 __ Ldlarh(w0, MemOperand(x10));
9711 __ Add(w0, w0, 1);
9712 __ Stllrh(w0, MemOperand(x10));
9714 __ Mov(x10, reinterpret_cast<uintptr_t>(&w[1]));
9715 __ Ldlar(w0, MemOperand(x10));
9716 __ Add(w0, w0, 1);
9717 __ Stllr(w0, MemOperand(x10));
9719 __ Mov(x10, reinterpret_cast<uintptr_t>(&x[1]));
9720 __ Ldlar(x0, MemOperand(x10));
9721 __ Add(x0, x0, 1);
9722 __ Stllr(x0, MemOperand(x10));
9768 __ Mov(x10, reinterpret_cast<uintptr_t>(&b[1]));
9770 __ Bind(&try_b);
9771 __ Ldxrb(w0, MemOperand(x10));
9772 __ Add(w0, w0, 1);
9773 __ Stxrb(w5, w0, MemOperand(x10));
9774 __ Cbnz(w5, &try_b);
9776 __ Mov(x10, reinterpret_cast<uintptr_t>(&h[1]));
9778 __ Bind(&try_h);
9779 __ Ldxrh(w0, MemOperand(x10));
9780 __ Add(w0, w0, 1);
9781 __ Stxrh(w5, w0, MemOperand(x10));
9782 __ Cbnz(w5, &try_h);
9784 __ Mov(x10, reinterpret_cast<uintptr_t>(&w[1]));
9786 __ Bind(&try_w);
9787 __ Ldxr(w0, MemOperand(x10));
9788 __ Add(w0, w0, 1);
9789 __ Stxr(w5, w0, MemOperand(x10));
9790 __ Cbnz(w5, &try_w);
9792 __ Mov(x10, reinterpret_cast<uintptr_t>(&x[1]));
9794 __ Bind(&try_x);
9795 __ Ldxr(x0, MemOperand(x10));
9796 __ Add(x0, x0, 1);
9797 __ Stxr(w5, x0, MemOperand(x10));
9798 __ Cbnz(w5, &try_x);
9800 __ Mov(x10, reinterpret_cast<uintptr_t>(&wp[1]));
9802 __ Bind(&try_wp);
9803 __ Ldxp(w0, w1, MemOperand(x10));
9804 __ Add(w0, w0, 1);
9805 __ Add(w1, w1, 1);
9806 __ Stxp(w5, w0, w1, MemOperand(x10));
9807 __ Cbnz(w5, &try_wp);
9809 __ Mov(x10, reinterpret_cast<uintptr_t>(&xp[1]));
9811 __ Bind(&try_xp);
9812 __ Ldxp(x0, x1, MemOperand(x10));
9813 __ Add(x0, x0, 1);
9814 __ Add(x1, x1, 1);
9815 __ Stxp(w5, x0, x1, MemOperand(x10));
9816 __ Cbnz(w5, &try_xp);
9869 __ Mov(x10, reinterpret_cast<uintptr_t>(&b[1]));
9871 __ Bind(&try_b);
9872 __ Ldaxrb(w0, MemOperand(x10));
9873 __ Add(w0, w0, 1);
9874 __ Stlxrb(w5, w0, MemOperand(x10));
9875 __ Cbnz(w5, &try_b);
9877 __ Mov(x10, reinterpret_cast<uintptr_t>(&h[1]));
9879 __ Bind(&try_h);
9880 __ Ldaxrh(w0, MemOperand(x10));
9881 __ Add(w0, w0, 1);
9882 __ Stlxrh(w5, w0, MemOperand(x10));
9883 __ Cbnz(w5, &try_h);
9885 __ Mov(x10, reinterpret_cast<uintptr_t>(&w[1]));
9887 __ Bind(&try_w);
9888 __ Ldaxr(w0, MemOperand(x10));
9889 __ Add(w0, w0, 1);
9890 __ Stlxr(w5, w0, MemOperand(x10));
9891 __ Cbnz(w5, &try_w);
9893 __ Mov(x10, reinterpret_cast<uintptr_t>(&x[1]));
9895 __ Bind(&try_x);
9896 __ Ldaxr(x0, MemOperand(x10));
9897 __ Add(x0, x0, 1);
9898 __ Stlxr(w5, x0, MemOperand(x10));
9899 __ Cbnz(w5, &try_x);
9901 __ Mov(x10, reinterpret_cast<uintptr_t>(&wp[1]));
9903 __ Bind(&try_wp);
9904 __ Ldaxp(w0, w1, MemOperand(x10));
9905 __ Add(w0, w0, 1);
9906 __ Add(w1, w1, 1);
9907 __ Stlxp(w5, w0, w1, MemOperand(x10));
9908 __ Cbnz(w5, &try_wp);
9910 __ Mov(x10, reinterpret_cast<uintptr_t>(&xp[1]));
9912 __ Bind(&try_xp);
9913 __ Ldaxp(x0, x1, MemOperand(x10));
9914 __ Add(x0, x0, 1);
9915 __ Add(x1, x1, 1);
9916 __ Stlxp(w5, x0, x1, MemOperand(x10));
9917 __ Cbnz(w5, &try_xp);
9957 __ Mov(x10, reinterpret_cast<uintptr_t>(data_aligned));
9958 __ Mov(w6, 0);
9960 __ Ldxrb(w0, MemOperand(x10));
9961 __ Clrex();
9962 __ Add(w0, w0, 1);
9963 __ Stxrb(w5, w0, MemOperand(x10));
9964 __ Add(w6, w6, w5);
9966 __ Ldxrh(w0, MemOperand(x10));
9967 __ Clrex();
9968 __ Add(w0, w0, 1);
9969 __ Stxrh(w5, w0, MemOperand(x10));
9970 __ Add(w6, w6, w5);
9972 __ Ldxr(w0, MemOperand(x10));
9973 __ Clrex();
9974 __ Add(w0, w0, 1);
9975 __ Stxr(w5, w0, MemOperand(x10));
9976 __ Add(w6, w6, w5);
9978 __ Ldxr(x0, MemOperand(x10));
9979 __ Clrex();
9980 __ Add(x0, x0, 1);
9981 __ Stxr(w5, x0, MemOperand(x10));
9982 __ Add(w6, w6, w5);
9984 __ Ldxp(w0, w1, MemOperand(x10));
9985 __ Clrex();
9986 __ Add(w0, w0, 1);
9987 __ Add(w1, w1, 1);
9988 __ Stxp(w5, w0, w1, MemOperand(x10));
9989 __ Add(w6, w6, w5);
9991 __ Ldxp(x0, x1, MemOperand(x10));
9992 __ Clrex();
9993 __ Add(x0, x0, 1);
9994 __ Add(x1, x1, 1);
9995 __ Stxp(w5, x0, x1, MemOperand(x10));
9996 __ Add(w6, w6, w5);
10000 __ Ldaxrb(w0, MemOperand(x10));
10001 __ Clrex();
10002 __ Add(w0, w0, 1);
10003 __ Stlxrb(w5, w0, MemOperand(x10));
10004 __ Add(w6, w6, w5);
10006 __ Ldaxrh(w0, MemOperand(x10));
10007 __ Clrex();
10008 __ Add(w0, w0, 1);
10009 __ Stlxrh(w5, w0, MemOperand(x10));
10010 __ Add(w6, w6, w5);
10012 __ Ldaxr(w0, MemOperand(x10));
10013 __ Clrex();
10014 __ Add(w0, w0, 1);
10015 __ Stlxr(w5, w0, MemOperand(x10));
10016 __ Add(w6, w6, w5);
10018 __ Ldaxr(x0, MemOperand(x10));
10019 __ Clrex();
10020 __ Add(x0, x0, 1);
10021 __ Stlxr(w5, x0, MemOperand(x10));
10022 __ Add(w6, w6, w5);
10024 __ Ldaxp(w0, w1, MemOperand(x10));
10025 __ Clrex();
10026 __ Add(w0, w0, 1);
10027 __ Add(w1, w1, 1);
10028 __ Stlxp(w5, w0, w1, MemOperand(x10));
10029 __ Add(w6, w6, w5);
10031 __ Ldaxp(x0, x1, MemOperand(x10));
10032 __ Clrex();
10033 __ Add(x0, x0, 1);
10034 __ Add(x1, x1, 1);
10035 __ Stlxp(w5, x0, x1, MemOperand(x10));
10036 __ Add(w6, w6, w5);
10065 __ Mov(x10, reinterpret_cast<uintptr_t>(data_aligned));
10066 __ Mov(x11, kWatchdog);
10071 __ Bind(&try_b);
10072 __ Ldxrb(w0, MemOperand(x10));
10073 __ Stxrb(w5, w0, MemOperand(x10));
10075 __ Sub(x11, x11, 1);
10076 __ Cbz(x11, &done);
10078 __ Cbz(w5, &try_b);
10081 __ Bind(&try_h);
10082 __ Ldxrh(w0, MemOperand(x10));
10083 __ Stxrh(w5, w0, MemOperand(x10));
10084 __ Sub(x11, x11, 1);
10085 __ Cbz(x11, &done);
10086 __ Cbz(w5, &try_h);
10089 __ Bind(&try_w);
10090 __ Ldxr(w0, MemOperand(x10));
10091 __ Stxr(w5, w0, MemOperand(x10));
10092 __ Sub(x11, x11, 1);
10093 __ Cbz(x11, &done);
10094 __ Cbz(w5, &try_w);
10097 __ Bind(&try_x);
10098 __ Ldxr(x0, MemOperand(x10));
10099 __ Stxr(w5, x0, MemOperand(x10));
10100 __ Sub(x11, x11, 1);
10101 __ Cbz(x11, &done);
10102 __ Cbz(w5, &try_x);
10105 __ Bind(&try_wp);
10106 __ Ldxp(w0, w1, MemOperand(x10));
10107 __ Stxp(w5, w0, w1, MemOperand(x10));
10108 __ Sub(x11, x11, 1);
10109 __ Cbz(x11, &done);
10110 __ Cbz(w5, &try_wp);
10113 __ Bind(&try_xp);
10114 __ Ldxp(x0, x1, MemOperand(x10));
10115 __ Stxp(w5, x0, x1, MemOperand(x10));
10116 __ Sub(x11, x11, 1);
10117 __ Cbz(x11, &done);
10118 __ Cbz(w5, &try_xp);
10120 __ Bind(&done);
10122 __ Cmp(x11, 0);
10123 __ Cset(x12, eq);
10149 __ Mov(x10, reinterpret_cast<uintptr_t>(data_aligned));
10150 __ Mov(x11, kWatchdog);
10155 __ Bind(&try_b);
10156 __ Ldxrb(w0, MemOperand(x10));
10157 __ Stxrb(w5, w0, MemOperand(x10));
10159 __ Sub(x11, x11, 1);
10160 __ Cbz(x11, &done);
10162 __ Cbz(w5, &try_b);
10165 __ Bind(&try_h);
10166 __ Ldaxrh(w0, MemOperand(x10));
10167 __ Stlxrh(w5, w0, MemOperand(x10));
10168 __ Sub(x11, x11, 1);
10169 __ Cbz(x11, &done);
10170 __ Cbz(w5, &try_h);
10173 __ Bind(&try_w);
10174 __ Ldaxr(w0, MemOperand(x10));
10175 __ Stlxr(w5, w0, MemOperand(x10));
10176 __ Sub(x11, x11, 1);
10177 __ Cbz(x11, &done);
10178 __ Cbz(w5, &try_w);
10181 __ Bind(&try_x);
10182 __ Ldaxr(x0, MemOperand(x10));
10183 __ Stlxr(w5, x0, MemOperand(x10));
10184 __ Sub(x11, x11, 1);
10185 __ Cbz(x11, &done);
10186 __ Cbz(w5, &try_x);
10189 __ Bind(&try_wp);
10190 __ Ldaxp(w0, w1, MemOperand(x10));
10191 __ Stlxp(w5, w0, w1, MemOperand(x10));
10192 __ Sub(x11, x11, 1);
10193 __ Cbz(x11, &done);
10194 __ Cbz(w5, &try_wp);
10197 __ Bind(&try_xp);
10198 __ Ldaxp(x0, x1, MemOperand(x10));
10199 __ Stlxp(w5, x0, x1, MemOperand(x10));
10200 __ Sub(x11, x11, 1);
10201 __ Cbz(x11, &done);
10202 __ Cbz(w5, &try_xp);
10204 __ Bind(&done);
10206 __ Cmp(x11, 0);
10207 __ Cset(x12, eq);
10233 __ Mov(x21, reinterpret_cast<uintptr_t>(&data1) + 0);
10234 __ Mov(x22, reinterpret_cast<uintptr_t>(&data2) + 0);
10235 __ Mov(x23, reinterpret_cast<uintptr_t>(&data3) + 4);
10236 __ Mov(x24, reinterpret_cast<uintptr_t>(&data4) + 4);
10237 __ Mov(x25, reinterpret_cast<uintptr_t>(&data5) + 0);
10238 __ Mov(x26, reinterpret_cast<uintptr_t>(&data6) + 0);
10239 __ Mov(x27, reinterpret_cast<uintptr_t>(&data7) + 4);
10240 __ Mov(x28, reinterpret_cast<uintptr_t>(&data8) + 4);
10242 __ Mov(x0, 0xffffffff);
10244 __ Mov(x1, 0xfedcba9876543210);
10245 __ Mov(x2, 0x0123456789abcdef);
10246 __ Mov(x3, 0xfedcba9876543210);
10247 __ Mov(x4, 0x89abcdef01234567);
10248 __ Mov(x5, 0xfedcba9876543210);
10249 __ Mov(x6, 0x0123456789abcdef);
10250 __ Mov(x7, 0xfedcba9876543210);
10251 __ Mov(x8, 0x89abcdef01234567);
10253 __ Cas(w1, w0, MemOperand(x21));
10254 __ Cas(w2, w0, MemOperand(x22));
10255 __ Casa(w3, w0, MemOperand(x23));
10256 __ Casa(w4, w0, MemOperand(x24));
10257 __ Casl(w5, w0, MemOperand(x25));
10258 __ Casl(w6, w0, MemOperand(x26));
10259 __ Casal(w7, w0, MemOperand(x27));
10260 __ Casal(w8, w0, MemOperand(x28));
10301 __ Mov(x21, reinterpret_cast<uintptr_t>(&data1));
10302 __ Mov(x22, reinterpret_cast<uintptr_t>(&data2));
10303 __ Mov(x23, reinterpret_cast<uintptr_t>(&data3));
10304 __ Mov(x24, reinterpret_cast<uintptr_t>(&data4));
10305 __ Mov(x25, reinterpret_cast<uintptr_t>(&data5));
10306 __ Mov(x26, reinterpret_cast<uintptr_t>(&data6));
10307 __ Mov(x27, reinterpret_cast<uintptr_t>(&data7));
10308 __ Mov(x28, reinterpret_cast<uintptr_t>(&data8));
10310 __ Mov(x0, 0xffffffffffffffff);
10312 __ Mov(x1, 0xfedcba9876543210);
10313 __ Mov(x2, 0x0123456789abcdef);
10314 __ Mov(x3, 0xfedcba9876543210);
10315 __ Mov(x4, 0x0123456789abcdef);
10316 __ Mov(x5, 0xfedcba9876543210);
10317 __ Mov(x6, 0x0123456789abcdef);
10318 __ Mov(x7, 0xfedcba9876543210);
10319 __ Mov(x8, 0x0123456789abcdef);
10321 __ Cas(x1, x0, MemOperand(x21));
10322 __ Cas(x2, x0, MemOperand(x22));
10323 __ Casa(x3, x0, MemOperand(x23));
10324 __ Casa(x4, x0, MemOperand(x24));
10325 __ Casl(x5, x0, MemOperand(x25));
10326 __ Casl(x6, x0, MemOperand(x26));
10327 __ Casal(x7, x0, MemOperand(x27));
10328 __ Casal(x8, x0, MemOperand(x28));
10369 __ Mov(x21, reinterpret_cast<uintptr_t>(&data1) + 0);
10370 __ Mov(x22, reinterpret_cast<uintptr_t>(&data2) + 0);
10371 __ Mov(x23, reinterpret_cast<uintptr_t>(&data3) + 1);
10372 __ Mov(x24, reinterpret_cast<uintptr_t>(&data4) + 1);
10373 __ Mov(x25, reinterpret_cast<uintptr_t>(&data5) + 2);
10374 __ Mov(x26, reinterpret_cast<uintptr_t>(&data6) + 2);
10375 __ Mov(x27, reinterpret_cast<uintptr_t>(&data7) + 3);
10376 __ Mov(x28, reinterpret_cast<uintptr_t>(&data8) + 3);
10378 __ Mov(x0, 0xff);
10380 __ Mov(x1, 0x76543210);
10381 __ Mov(x2, 0x01234567);
10382 __ Mov(x3, 0x76543210);
10383 __ Mov(x4, 0x67012345);
10384 __ Mov(x5, 0x76543210);
10385 __ Mov(x6, 0x45670123);
10386 __ Mov(x7, 0x76543210);
10387 __ Mov(x8, 0x23456701);
10389 __ Casb(w1, w0, MemOperand(x21));
10390 __ Casb(w2, w0, MemOperand(x22));
10391 __ Casab(w3, w0, MemOperand(x23));
10392 __ Casab(w4, w0, MemOperand(x24));
10393 __ Caslb(w5, w0, MemOperand(x25));
10394 __ Caslb(w6, w0, MemOperand(x26));
10395 __ Casalb(w7, w0, MemOperand(x27));
10396 __ Casalb(w8, w0, MemOperand(x28));
10437 __ Mov(x21, reinterpret_cast<uintptr_t>(&data1) + 0);
10438 __ Mov(x22, reinterpret_cast<uintptr_t>(&data2) + 0);
10439 __ Mov(x23, reinterpret_cast<uintptr_t>(&data3) + 2);
10440 __ Mov(x24, reinterpret_cast<uintptr_t>(&data4) + 2);
10441 __ Mov(x25, reinterpret_cast<uintptr_t>(&data5) + 4);
10442 __ Mov(x26, reinterpret_cast<uintptr_t>(&data6) + 4);
10443 __ Mov(x27, reinterpret_cast<uintptr_t>(&data7) + 6);
10444 __ Mov(x28, reinterpret_cast<uintptr_t>(&data8) + 6);
10446 __ Mov(x0, 0xffff);
10448 __ Mov(x1, 0xfedcba9876543210);
10449 __ Mov(x2, 0x0123456789abcdef);
10450 __ Mov(x3, 0xfedcba9876543210);
10451 __ Mov(x4, 0xcdef0123456789ab);
10452 __ Mov(x5, 0xfedcba9876543210);
10453 __ Mov(x6, 0x89abcdef01234567);
10454 __ Mov(x7, 0xfedcba9876543210);
10455 __ Mov(x8, 0x456789abcdef0123);
10457 __ Cash(w1, w0, MemOperand(x21));
10458 __ Cash(w2, w0, MemOperand(x22));
10459 __ Casah(w3, w0, MemOperand(x23));
10460 __ Casah(w4, w0, MemOperand(x24));
10461 __ Caslh(w5, w0, MemOperand(x25));
10462 __ Caslh(w6, w0, MemOperand(x26));
10463 __ Casalh(w7, w0, MemOperand(x27));
10464 __ Casalh(w8, w0, MemOperand(x28));
10505 __ Mov(x21, reinterpret_cast<uintptr_t>(data1) + 0);
10506 __ Mov(x22, reinterpret_cast<uintptr_t>(data2) + 0);
10507 __ Mov(x23, reinterpret_cast<uintptr_t>(data3) + 8);
10508 __ Mov(x24, reinterpret_cast<uintptr_t>(data4) + 8);
10509 __ Mov(x25, reinterpret_cast<uintptr_t>(data5) + 8);
10510 __ Mov(x26, reinterpret_cast<uintptr_t>(data6) + 8);
10511 __ Mov(x27, reinterpret_cast<uintptr_t>(data7) + 0);
10512 __ Mov(x28, reinterpret_cast<uintptr_t>(data8) + 0);
10514 __ Mov(x0, 0xfff00fff);
10515 __ Mov(x1, 0xfff11fff);
10517 __ Mov(x2, 0x77665544);
10518 __ Mov(x3, 0x33221100);
10519 __ Mov(x4, 0x33221100);
10520 __ Mov(x5, 0x77665544);
10522 __ Mov(x6, 0xffeeddcc);
10523 __ Mov(x7, 0xbbaa9988);
10524 __ Mov(x8, 0xbbaa9988);
10525 __ Mov(x9, 0xffeeddcc);
10527 __ Mov(x10, 0xffeeddcc);
10528 __ Mov(x11, 0xbbaa9988);
10529 __ Mov(x12, 0xbbaa9988);
10530 __ Mov(x13, 0xffeeddcc);
10532 __ Mov(x14, 0x77665544);
10533 __ Mov(x15, 0x33221100);
10534 __ Mov(x16, 0x33221100);
10535 __ Mov(x17, 0x77665544);
10537 __ Casp(w2, w3, w0, w1, MemOperand(x21));
10538 __ Casp(w4, w5, w0, w1, MemOperand(x22));
10539 __ Caspa(w6, w7, w0, w1, MemOperand(x23));
10540 __ Caspa(w8, w9, w0, w1, MemOperand(x24));
10541 __ Caspl(w10, w11, w0, w1, MemOperand(x25));
10542 __ Caspl(w12, w13, w0, w1, MemOperand(x26));
10543 __ Caspal(w14, w15, w0, w1, MemOperand(x27));
10544 __ Caspal(w16, w17, w0, w1, MemOperand(x28));
10625 __ Mov(x21, reinterpret_cast<uintptr_t>(data1) + 0);
10626 __ Mov(x22, reinterpret_cast<uintptr_t>(data2) + 0);
10627 __ Mov(x23, reinterpret_cast<uintptr_t>(data3) + 16);
10628 __ Mov(x24, reinterpret_cast<uintptr_t>(data4) + 16);
10629 __ Mov(x25, reinterpret_cast<uintptr_t>(data5) + 16);
10630 __ Mov(x26, reinterpret_cast<uintptr_t>(data6) + 16);
10631 __ Mov(x27, reinterpret_cast<uintptr_t>(data7) + 0);
10632 __ Mov(x28, reinterpret_cast<uintptr_t>(data8) + 0);
10634 __ Mov(x0, 0xfffffff00fffffff);
10635 __ Mov(x1, 0xfffffff11fffffff);
10637 __ Mov(x2, 0xffeeddccbbaa9988);
10638 __ Mov(x3, 0x7766554433221100);
10639 __ Mov(x4, 0x7766554433221100);
10640 __ Mov(x5, 0xffeeddccbbaa9988);
10642 __ Mov(x6, 0x0123456789abcdef);
10643 __ Mov(x7, 0xfedcba9876543210);
10644 __ Mov(x8, 0xfedcba9876543210);
10645 __ Mov(x9, 0x0123456789abcdef);
10647 __ Mov(x10, 0x0123456789abcdef);
10648 __ Mov(x11, 0xfedcba9876543210);
10649 __ Mov(x12, 0xfedcba9876543210);
10650 __ Mov(x13, 0x0123456789abcdef);
10652 __ Mov(x14, 0xffeeddccbbaa9988);
10653 __ Mov(x15, 0x7766554433221100);
10654 __ Mov(x16, 0x7766554433221100);
10655 __ Mov(x17, 0xffeeddccbbaa9988);
10657 __ Casp(x2, x3, x0, x1, MemOperand(x21));
10658 __ Casp(x4, x5, x0, x1, MemOperand(x22));
10659 __ Caspa(x6, x7, x0, x1, MemOperand(x23));
10660 __ Caspa(x8, x9, x0, x1, MemOperand(x24));
10661 __ Caspl(x10, x11, x0, x1, MemOperand(x25));
10662 __ Caspl(x12, x13, x0, x1, MemOperand(x26));
10663 __ Caspal(x14, x15, x0, x1, MemOperand(x27));
10664 __ Caspal(x16, x17, x0, x1, MemOperand(x28));
10755 __ Mov(x20, reinterpret_cast<uintptr_t>(data0));
10756 __ Mov(x21, reinterpret_cast<uintptr_t>(data1));
10757 __ Mov(x22, reinterpret_cast<uintptr_t>(data2));
10758 __ Mov(x23, reinterpret_cast<uintptr_t>(data3));
10760 __ Mov(x0, arg1);
10761 __ Mov(x1, arg1);
10762 __ Mov(x2, arg1);
10763 __ Mov(x3, arg1);
10771 __ Mov(x24, reinterpret_cast<uintptr_t>(data4));
10772 __ Mov(x25, reinterpret_cast<uintptr_t>(data5));
10773 __ Mov(x4, arg1);
10774 __ Mov(x5, arg1);
10821 __ Mov(x20, reinterpret_cast<uintptr_t>(data0));
10822 __ Mov(x21, reinterpret_cast<uintptr_t>(data1));
10823 __ Mov(x22, reinterpret_cast<uintptr_t>(data2));
10824 __ Mov(x23, reinterpret_cast<uintptr_t>(data3));
10826 __ Mov(x0, arg1);
10827 __ Mov(x1, arg1);
10828 __ Mov(x2, arg1);
10829 __ Mov(x3, arg1);
10837 __ Mov(x24, reinterpret_cast<uintptr_t>(data4));
10838 __ Mov(x25, reinterpret_cast<uintptr_t>(data5));
10839 __ Mov(x4, arg1);
10840 __ Mov(x5, arg1);
11084 __ Mov(x20, reinterpret_cast<uintptr_t>(data0_aligned));
11085 __ Mov(x21, reinterpret_cast<uintptr_t>(data1_aligned));
11086 __ Mov(x22, reinterpret_cast<uintptr_t>(data2_aligned));
11087 __ Mov(x23, reinterpret_cast<uintptr_t>(data3_aligned));
11089 __ Ldaprb(w0, MemOperand(x20));
11090 __ Ldaprh(w1, MemOperand(x21));
11091 __ Ldapr(w2, MemOperand(x22));
11092 __ Ldapr(x3, MemOperand(x23));
11116 __ Mov(x20, data_base);
11117 __ Mov(x21, data_base + 2 * sizeof(data[0]));
11119 __ Ldaprb(w0, MemOperand(x20));
11120 __ Ldaprh(w1, MemOperand(x20));
11121 __ Ldapr(w2, MemOperand(x20));
11122 __ Ldapr(x3, MemOperand(x20));
11123 __ Ldaprb(w4, MemOperand(x20, 12));
11124 __ Ldaprh(w5, MemOperand(x20, 8));
11125 __ Ldapr(w6, MemOperand(x20, 10));
11126 __ Ldapr(x7, MemOperand(x20, 7));
11127 __ Ldaprb(w8, MemOperand(x21, -1));
11128 __ Ldaprh(w9, MemOperand(x21, -3));
11129 __ Ldapr(w10, MemOperand(x21, -9));
11130 __ Ldapr(x11, MemOperand(x21, -12));
11162 __ Mov(x20, data_base);
11163 __ Mov(x21, data_base + 2 * sizeof(data[0]));
11165 __ Ldapursb(w0, MemOperand(x20));
11166 __ Ldapursb(x1, MemOperand(x20));
11167 __ Ldapursh(w2, MemOperand(x20));
11168 __ Ldapursh(x3, MemOperand(x20));
11169 __ Ldapursw(x4, MemOperand(x20));
11170 __ Ldapursb(w5, MemOperand(x20, 12));
11171 __ Ldapursb(x6, MemOperand(x20, 12));
11172 __ Ldapursh(w7, MemOperand(x20, 13));
11173 __ Ldapursh(x8, MemOperand(x20, 13));
11174 __ Ldapursw(x9, MemOperand(x20, 10));
11175 __ Ldapursb(w10, MemOperand(x21, -1));
11176 __ Ldapursb(x11, MemOperand(x21, -1));
11177 __ Ldapursh(w12, MemOperand(x21, -4));
11178 __ Ldapursh(x13, MemOperand(x21, -4));
11179 __ Ldapursw(x14, MemOperand(x21, -5));
11181 __ Ldapursb(x15, MemOperand(x20, 8));
11182 __ Ldapursh(x16, MemOperand(x20, 8));
11183 __ Ldapursw(x17, MemOperand(x20, 8));
11220 __ Mov(x0, 0x0011223344556677);
11221 __ Mov(x20, data_base);
11222 __ Mov(x21, data_base + 2 * sizeof(data[0]));
11224 __ Stlrb(w0, MemOperand(x20));
11225 __ Stlrh(w0, MemOperand(x20, 1));
11226 __ Stlr(w0, MemOperand(x20, 3));
11227 __ Stlr(x0, MemOperand(x21, -8));
11274 __ Mov(x0, 0x0123456789abcdef);
11275 __ Mov(x1, 0x456789abcdef0123);
11276 __ Mov(x2, 0x89abcdef01234567);
11277 __ Mov(x3, 0xcdef0123456789ab);
11278 __ Mov(x18, reinterpret_cast<uintptr_t>(data0_aligned));
11279 __ Mov(x19, reinterpret_cast<uintptr_t>(dst_aligned));
11280 __ Mov(x20, x18);
11281 __ Mov(x21, x19);
11284 __ Stxrb(w0, w1, MemOperand(x20));
11285 __ Stlxrb(w0, w1, MemOperand(x20));
11286 __ Ldxrb(w0, MemOperand(x20));
11287 __ Ldaxrb(w0, MemOperand(x20));
11288 __ Stllrb(w0, MemOperand(x20));
11289 __ Stlrb(w0, MemOperand(x20));
11290 __ Casb(w0, w1, MemOperand(x20));
11291 __ Caslb(w0, w1, MemOperand(x20));
11292 __ Ldlarb(w0, MemOperand(x20));
11293 __ Ldarb(w0, MemOperand(x20));
11294 __ Casab(w0, w1, MemOperand(x20));
11295 __ Casalb(w0, w1, MemOperand(x20));
11297 __ Swpb(w0, w1, MemOperand(x20));
11298 __ Swplb(w0, w1, MemOperand(x20));
11299 __ Swpab(w0, w1, MemOperand(x20));
11300 __ Swpalb(w0, w1, MemOperand(x20));
11301 __ Ldaprb(w0, MemOperand(x20));
11303 __ Stlrb(w0, MemOperand(x19, i));
11304 __ Ldaprb(w0, MemOperand(x19, i));
11305 __ Ldapursb(w0, MemOperand(x20));
11306 __ Ldapursb(x0, MemOperand(x20));
11308 #define ATOMIC_LOAD_B(NAME) __ Ld##NAME##b(w0, w1, MemOperand(x20));
11309 #define ATOMIC_STORE_B(NAME) __ St##NAME##b(w0, MemOperand(x20));
11316 __ Stxrh(w0, w1, MemOperand(x20));
11317 __ Stlxrh(w0, w1, MemOperand(x20));
11318 __ Ldxrh(w0, MemOperand(x20));
11319 __ Ldaxrh(w0, MemOperand(x20));
11320 __ Stllrh(w0, MemOperand(x20));
11321 __ Stlrh(w0, MemOperand(x20));
11322 __ Cash(w0, w1, MemOperand(x20));
11323 __ Caslh(w0, w1, MemOperand(x20));
11324 __ Ldlarh(w0, MemOperand(x20));
11325 __ Ldarh(w0, MemOperand(x20));
11326 __ Casah(w0, w1, MemOperand(x20));
11327 __ Casalh(w0, w1, MemOperand(x20));
11329 __ Swph(w0, w1, MemOperand(x20));
11330 __ Swplh(w0, w1, MemOperand(x20));
11331 __ Swpah(w0, w1, MemOperand(x20));
11332 __ Swpalh(w0, w1, MemOperand(x20));
11333 __ Ldaprh(w0, MemOperand(x20));
11335 __ Stlrh(w0, MemOperand(x19, i));
11336 __ Ldaprh(w0, MemOperand(x19, i));
11337 __ Ldapursh(w0, MemOperand(x20));
11338 __ Ldapursh(x0, MemOperand(x20));
11340 #define ATOMIC_LOAD_H(NAME) __ Ld##NAME##h(w0, w1, MemOperand(x20));
11341 #define ATOMIC_STORE_H(NAME) __ St##NAME##h(w0, MemOperand(x20));
11349 __ Stxr(w0, w1, MemOperand(x20));
11350 __ Stlxr(w0, w1, MemOperand(x20));
11351 __ Ldxr(w0, MemOperand(x20));
11352 __ Ldaxr(w0, MemOperand(x20));
11353 __ Stllr(w0, MemOperand(x20));
11354 __ Stlr(w0, MemOperand(x20));
11355 __ Cas(w0, w1, MemOperand(x20));
11356 __ Casl(w0, w1, MemOperand(x20));
11357 __ Ldlar(w0, MemOperand(x20));
11358 __ Ldar(w0, MemOperand(x20));
11359 __ Casa(w0, w1, MemOperand(x20));
11360 __ Casal(w0, w1, MemOperand(x20));
11362 __ Swp(w0, w1, MemOperand(x20));
11363 __ Swpl(w0, w1, MemOperand(x20));
11364 __ Swpa(w0, w1, MemOperand(x20));
11365 __ Swpal(w0, w1, MemOperand(x20));
11366 __ Ldapr(w0, MemOperand(x20));
11368 __ Stlr(w0, MemOperand(x19, i));
11369 __ Ldapr(w0, MemOperand(x19, i));
11370 __ Ldapursw(x0, MemOperand(x20));
11372 #define ATOMIC_LOAD_W(NAME) __ Ld##NAME(w0, w1, MemOperand(x20));
11373 #define ATOMIC_STORE_W(NAME) __ St##NAME(w0, MemOperand(x20));
11381 __ Casp(w0, w1, w2, w3, MemOperand(x20));
11382 __ Caspl(w0, w1, w2, w3, MemOperand(x20));
11383 __ Caspa(w0, w1, w2, w3, MemOperand(x20));
11384 __ Caspal(w0, w1, w2, w3, MemOperand(x20));
11385 __ Stxp(w0, w1, w2, MemOperand(x20));
11386 __ Stlxp(w0, w1, w2, MemOperand(x20));
11387 __ Ldxp(w0, w1, MemOperand(x20));
11388 __ Ldaxp(w0, w1, MemOperand(x20));
11392 __ Stxr(x0, x1, MemOperand(x20));
11393 __ Stlxr(x0, x1, MemOperand(x20));
11394 __ Ldxr(x0, MemOperand(x20));
11395 __ Ldaxr(x0, MemOperand(x20));
11396 __ Stllr(x0, MemOperand(x20));
11397 __ Stlr(x0, MemOperand(x20));
11398 __ Cas(x0, x1, MemOperand(x20));
11399 __ Casl(x0, x1, MemOperand(x20));
11400 __ Ldlar(x0, MemOperand(x20));
11401 __ Ldar(x0, MemOperand(x20));
11402 __ Casa(x0, x1, MemOperand(x20));
11403 __ Casal(x0, x1, MemOperand(x20));
11405 __ Swp(x0, x1, MemOperand(x20));
11406 __ Swpl(x0, x1, MemOperand(x20));
11407 __ Swpa(x0, x1, MemOperand(x20));
11408 __ Swpal(x0, x1, MemOperand(x20));
11409 __ Ldapr(x0, MemOperand(x20));
11411 __ Stlr(x0, MemOperand(x19, i));
11412 __ Ldapr(x0, MemOperand(x19, i));
11414 #define ATOMIC_LOAD_X(NAME) __ Ld##NAME(x0, x1, MemOperand(x20));
11415 #define ATOMIC_STORE_X(NAME) __ St##NAME(x0, MemOperand(x20));
11423 __ Casp(x0, x1, x2, x3, MemOperand(x20));
11424 __ Caspl(x0, x1, x2, x3, MemOperand(x20));
11425 __ Caspa(x0, x1, x2, x3, MemOperand(x20));
11426 __ Caspal(x0, x1, x2, x3, MemOperand(x20));
11427 __ Stxp(x0, x1, x2, MemOperand(x20));
11428 __ Stlxp(x0, x1, x2, MemOperand(x20));
11429 __ Ldxp(x0, x1, MemOperand(x20));
11430 __ Ldaxp(x0, x1, MemOperand(x20));
11433 __ Add(x20, x20, 1);
11434 __ Add(x21, x21, 1);
11457 __ Mov(x0, 0x0123456789abcdef); \
11458 __ Mov(x1, 0x456789abcdef0123); \
11459 __ Mov(x2, 0x89abcdef01234567); \
11460 __ Mov(x3, 0xcdef0123456789ab); \
11461 __ Mov(x20, reinterpret_cast<uintptr_t>(data0_aligned)); \
11462 __ Mov(x21, reinterpret_cast<uintptr_t>(dst_aligned)); \
11463 __ Add(x20, x20, i); \
11464 __ Add(x21, x21, i); \
11484 CHECK_ALIGN_FAIL(i, __ Stxrh(w0, w1, MemOperand(x20)));
11485 CHECK_ALIGN_FAIL(i, __ Stlxrh(w0, w1, MemOperand(x20)));
11486 CHECK_ALIGN_FAIL(i, __ Ldxrh(w0, MemOperand(x20)));
11487 CHECK_ALIGN_FAIL(i, __ Ldaxrh(w0, MemOperand(x20)));
11488 CHECK_ALIGN_FAIL(i, __ Stllrh(w0, MemOperand(x20)));
11489 CHECK_ALIGN_FAIL(i, __ Stlrh(w0, MemOperand(x20)));
11490 CHECK_ALIGN_FAIL(i, __ Cash(w0, w1, MemOperand(x20)));
11491 CHECK_ALIGN_FAIL(i, __ Caslh(w0, w1, MemOperand(x20)));
11492 CHECK_ALIGN_FAIL(i, __ Ldlarh(w0, MemOperand(x20)));
11493 CHECK_ALIGN_FAIL(i, __ Ldarh(w0, MemOperand(x20)));
11494 CHECK_ALIGN_FAIL(i, __ Casah(w0, w1, MemOperand(x20)));
11495 CHECK_ALIGN_FAIL(i, __ Casalh(w0, w1, MemOperand(x20)));
11497 CHECK_ALIGN_FAIL(i, __ Swph(w0, w1, MemOperand(x20)));
11498 CHECK_ALIGN_FAIL(i, __ Swplh(w0, w1, MemOperand(x20)));
11499 CHECK_ALIGN_FAIL(i, __ Swpah(w0, w1, MemOperand(x20)));
11500 CHECK_ALIGN_FAIL(i, __ Swpalh(w0, w1, MemOperand(x20)));
11501 CHECK_ALIGN_FAIL(i, __ Ldaprh(w0, MemOperand(x20)));
11503 CHECK_ALIGN_FAIL(0, __ Stlrh(w0, MemOperand(x20, i)));
11504 CHECK_ALIGN_FAIL(0, __ Ldaprh(w0, MemOperand(x20, i)));
11505 CHECK_ALIGN_FAIL(i, __ Ldapursh(w0, MemOperand(x20)));
11506 CHECK_ALIGN_FAIL(i, __ Ldapursh(x0, MemOperand(x20)));
11509 CHECK_ALIGN_FAIL(i, __ Ld##NAME##h(w0, w1, MemOperand(x20)));
11511 CHECK_ALIGN_FAIL(i, __ St##NAME##h(w0, MemOperand(x20)));
11519 CHECK_ALIGN_FAIL(i, __ Stxr(w0, w1, MemOperand(x20)));
11520 CHECK_ALIGN_FAIL(i, __ Stlxr(w0, w1, MemOperand(x20)));
11521 CHECK_ALIGN_FAIL(i, __ Ldxr(w0, MemOperand(x20)));
11522 CHECK_ALIGN_FAIL(i, __ Ldaxr(w0, MemOperand(x20)));
11523 CHECK_ALIGN_FAIL(i, __ Stllr(w0, MemOperand(x20)));
11524 CHECK_ALIGN_FAIL(i, __ Stlr(w0, MemOperand(x20)));
11525 CHECK_ALIGN_FAIL(i, __ Cas(w0, w1, MemOperand(x20)));
11526 CHECK_ALIGN_FAIL(i, __ Casl(w0, w1, MemOperand(x20)));
11527 CHECK_ALIGN_FAIL(i, __ Ldlar(w0, MemOperand(x20)));
11528 CHECK_ALIGN_FAIL(i, __ Ldar(w0, MemOperand(x20)));
11529 CHECK_ALIGN_FAIL(i, __ Casa(w0, w1, MemOperand(x20)));
11530 CHECK_ALIGN_FAIL(i, __ Casal(w0, w1, MemOperand(x20)));
11532 CHECK_ALIGN_FAIL(i, __ Swp(w0, w1, MemOperand(x20)));
11533 CHECK_ALIGN_FAIL(i, __ Swpl(w0, w1, MemOperand(x20)));
11534 CHECK_ALIGN_FAIL(i, __ Swpa(w0, w1, MemOperand(x20)));
11535 CHECK_ALIGN_FAIL(i, __ Swpal(w0, w1, MemOperand(x20)));
11536 CHECK_ALIGN_FAIL(i, __ Ldapr(w0, MemOperand(x20)));
11538 CHECK_ALIGN_FAIL(0, __ Stlr(w0, MemOperand(x20, i)));
11539 CHECK_ALIGN_FAIL(0, __ Ldapr(w0, MemOperand(x20, i)));
11540 CHECK_ALIGN_FAIL(i, __ Ldapursw(x0, MemOperand(x20)));
11543 CHECK_ALIGN_FAIL(i, __ Ld##NAME(w0, w1, MemOperand(x20)));
11545 CHECK_ALIGN_FAIL(i, __ St##NAME(w0, MemOperand(x20)));
11553 CHECK_ALIGN_FAIL(i, __ Casp(w0, w1, w2, w3, MemOperand(x20)));
11554 CHECK_ALIGN_FAIL(i, __ Caspl(w0, w1, w2, w3, MemOperand(x20)));
11555 CHECK_ALIGN_FAIL(i, __ Caspa(w0, w1, w2, w3, MemOperand(x20)));
11556 CHECK_ALIGN_FAIL(i, __ Caspal(w0, w1, w2, w3, MemOperand(x20)));
11557 CHECK_ALIGN_FAIL(i, __ Stxp(w0, w1, w2, MemOperand(x20)));
11558 CHECK_ALIGN_FAIL(i, __ Stlxp(w0, w1, w2, MemOperand(x20)));
11559 CHECK_ALIGN_FAIL(i, __ Ldxp(w0, w1, MemOperand(x20)));
11560 CHECK_ALIGN_FAIL(i, __ Ldaxp(w0, w1, MemOperand(x20)));
11564 CHECK_ALIGN_FAIL(i, __ Stxr(x0, x1, MemOperand(x20)));
11565 CHECK_ALIGN_FAIL(i, __ Stlxr(x0, x1, MemOperand(x20)));
11566 CHECK_ALIGN_FAIL(i, __ Ldxr(x0, MemOperand(x20)));
11567 CHECK_ALIGN_FAIL(i, __ Ldaxr(x0, MemOperand(x20)));
11568 CHECK_ALIGN_FAIL(i, __ Stllr(x0, MemOperand(x20)));
11569 CHECK_ALIGN_FAIL(i, __ Stlr(x0, MemOperand(x20)));
11570 CHECK_ALIGN_FAIL(i, __ Cas(x0, x1, MemOperand(x20)));
11571 CHECK_ALIGN_FAIL(i, __ Casl(x0, x1, MemOperand(x20)));
11572 CHECK_ALIGN_FAIL(i, __ Ldlar(x0, MemOperand(x20)));
11573 CHECK_ALIGN_FAIL(i, __ Ldar(x0, MemOperand(x20)));
11574 CHECK_ALIGN_FAIL(i, __ Casa(x0, x1, MemOperand(x20)));
11575 CHECK_ALIGN_FAIL(i, __ Casal(x0, x1, MemOperand(x20)));
11577 CHECK_ALIGN_FAIL(i, __ Swp(x0, x1, MemOperand(x20)));
11578 CHECK_ALIGN_FAIL(i, __ Swpl(x0, x1, MemOperand(x20)));
11579 CHECK_ALIGN_FAIL(i, __ Swpa(x0, x1, MemOperand(x20)));
11580 CHECK_ALIGN_FAIL(i, __ Swpal(x0, x1, MemOperand(x20)));
11581 CHECK_ALIGN_FAIL(i, __ Ldapr(x0, MemOperand(x20)));
11583 CHECK_ALIGN_FAIL(0, __ Stlr(x0, MemOperand(x20, i)));
11584 CHECK_ALIGN_FAIL(0, __ Ldapr(x0, MemOperand(x20, i)));
11587 CHECK_ALIGN_FAIL(i, __ Ld##NAME(x0, x1, MemOperand(x20)));
11589 CHECK_ALIGN_FAIL(i, __ St##NAME(x0, MemOperand(x20)));
11597 CHECK_ALIGN_FAIL(i, __ Casp(x0, x1, x2, x3, MemOperand(x20)));
11598 CHECK_ALIGN_FAIL(i, __ Caspl(x0, x1, x2, x3, MemOperand(x20)));
11599 CHECK_ALIGN_FAIL(i, __ Caspa(x0, x1, x2, x3, MemOperand(x20)));
11600 CHECK_ALIGN_FAIL(i, __ Caspal(x0, x1, x2, x3, MemOperand(x20)));
11601 CHECK_ALIGN_FAIL(i, __ Stxp(x0, x1, x2, MemOperand(x20)));
11602 CHECK_ALIGN_FAIL(i, __ Stlxp(x0, x1, x2, MemOperand(x20)));
11603 CHECK_ALIGN_FAIL(i, __ Ldxp(x0, x1, MemOperand(x20)));
11604 CHECK_ALIGN_FAIL(i, __ Ldaxp(x0, x1, MemOperand(x20)));
11619 __ Mov(x0, reinterpret_cast<uintptr_t>(data_aligned));
11620 __ Add(x0, x0, 1);
11621 __ Ldxrh(w1, MemOperand(x0));
11630 __ Mov(x0, reinterpret_cast<uintptr_t>(data_aligned));
11631 __ Add(x0, x0, 1);
11632 __ Ldxrh(w1, MemOperand(x0));
11669 __ Mov(x0, src_tagged);
11670 __ Mov(x1, dst_tagged);
11677 __ ldp(q0, q1, MemOperand(x0, offset));
11678 __ stp(q0, q1, MemOperand(x1, offset));
11684 __ ldp(x2, x3, MemOperand(x0, offset));
11685 __ stp(x2, x3, MemOperand(x1, offset));
11691 __ ldpsw(x2, x3, MemOperand(x0, offset));
11692 __ stp(w2, w3, MemOperand(x1, offset));
11698 __ ldp(d0, d1, MemOperand(x0, offset));
11699 __ stp(d0, d1, MemOperand(x1, offset));
11705 __ ldp(w2, w3, MemOperand(x0, offset));
11706 __ stp(w2, w3, MemOperand(x1, offset));
11712 __ ldp(s0, s1, MemOperand(x0, offset));
11713 __ stp(s0, s1, MemOperand(x1, offset));
11719 __ ldr(x2, MemOperand(x0, offset), RequireScaledOffset);
11720 __ str(x2, MemOperand(x1, offset), RequireScaledOffset);
11726 __ ldr(d0, MemOperand(x0, offset), RequireScaledOffset);
11727 __ str(d0, MemOperand(x1, offset), RequireScaledOffset);
11733 __ ldr(w2, MemOperand(x0, offset), RequireScaledOffset);
11734 __ str(w2, MemOperand(x1, offset), RequireScaledOffset);
11740 __ ldr(s0, MemOperand(x0, offset), RequireScaledOffset);
11741 __ str(s0, MemOperand(x1, offset), RequireScaledOffset);
11747 __ ldrh(w2, MemOperand(x0, offset), RequireScaledOffset);
11748 __ strh(w2, MemOperand(x1, offset), RequireScaledOffset);
11754 __ ldrsh(w2, MemOperand(x0, offset), RequireScaledOffset);
11755 __ strh(w2, MemOperand(x1, offset), RequireScaledOffset);
11761 __ ldrb(w2, MemOperand(x0, offset), RequireScaledOffset);
11762 __ strb(w2, MemOperand(x1, offset), RequireScaledOffset);
11768 __ ldrsb(w2, MemOperand(x0, offset), RequireScaledOffset);
11769 __ strb(w2, MemOperand(x1, offset), RequireScaledOffset);
11777 __ ldur(x2, MemOperand(x0, offset), RequireUnscaledOffset);
11778 __ stur(x2, MemOperand(x1, offset), RequireUnscaledOffset);
11784 __ ldur(d0, MemOperand(x0, offset), RequireUnscaledOffset);
11785 __ stur(d0, MemOperand(x1, offset), RequireUnscaledOffset);
11791 __ ldur(w2, MemOperand(x0, offset), RequireUnscaledOffset);
11792 __ stur(w2, MemOperand(x1, offset), RequireUnscaledOffset);
11798 __ ldur(s0, MemOperand(x0, offset), RequireUnscaledOffset);
11799 __ stur(s0, MemOperand(x1, offset), RequireUnscaledOffset);
11805 __ ldurh(w2, MemOperand(x0, offset), RequireUnscaledOffset);
11806 __ sturh(w2, MemOperand(x1, offset), RequireUnscaledOffset);
11812 __ ldursh(w2, MemOperand(x0, offset), RequireUnscaledOffset);
11813 __ sturh(w2, MemOperand(x1, offset), RequireUnscaledOffset);
11819 __ ldurb(w2, MemOperand(x0, offset), RequireUnscaledOffset);
11820 __ sturb(w2, MemOperand(x1, offset), RequireUnscaledOffset);
11826 __ ldursb(w2, MemOperand(x0, offset), RequireUnscaledOffset);
11827 __ sturb(w2, MemOperand(x1, offset), RequireUnscaledOffset);
11832 __ Ubfx(x0, x0, kAddressTagOffset, kAddressTagWidth);
11833 __ Ubfx(x1, x1, kAddressTagOffset, kAddressTagWidth);
11889 __ Mov(x0, src_tagged - preindex);
11890 __ Mov(x1, dst_tagged - preindex);
11894 __ ldp(q0, q1, MemOperand(x0, preindex, PreIndex));
11895 __ stp(q0, q1, MemOperand(x1, preindex, PreIndex));
11902 __ ldp(x2, x3, MemOperand(x0, preindex, PreIndex));
11903 __ stp(x2, x3, MemOperand(x1, preindex, PreIndex));
11910 __ ldpsw(x2, x3, MemOperand(x0, preindex, PreIndex));
11911 __ stp(w2, w3, MemOperand(x1, preindex, PreIndex));
11918 __ ldp(d0, d1, MemOperand(x0, preindex, PreIndex));
11919 __ stp(d0, d1, MemOperand(x1, preindex, PreIndex));
11926 __ ldp(w2, w3, MemOperand(x0, preindex, PreIndex));
11927 __ stp(w2, w3, MemOperand(x1, preindex, PreIndex));
11934 __ ldp(s0, s1, MemOperand(x0, preindex, PreIndex));
11935 __ stp(s0, s1, MemOperand(x1, preindex, PreIndex));
11942 __ ldr(x2, MemOperand(x0, preindex, PreIndex));
11943 __ str(x2, MemOperand(x1, preindex, PreIndex));
11950 __ ldr(d0, MemOperand(x0, preindex, PreIndex));
11951 __ str(d0, MemOperand(x1, preindex, PreIndex));
11958 __ ldr(w2, MemOperand(x0, preindex, PreIndex));
11959 __ str(w2, MemOperand(x1, preindex, PreIndex));
11966 __ ldr(s0, MemOperand(x0, preindex, PreIndex));
11967 __ str(s0, MemOperand(x1, preindex, PreIndex));
11974 __ ldrh(w2, MemOperand(x0, preindex, PreIndex));
11975 __ strh(w2, MemOperand(x1, preindex, PreIndex));
11982 __ ldrsh(w2, MemOperand(x0, preindex, PreIndex));
11983 __ strh(w2, MemOperand(x1, preindex, PreIndex));
11990 __ ldrb(w2, MemOperand(x0, preindex, PreIndex));
11991 __ strb(w2, MemOperand(x1, preindex, PreIndex));
11998 __ ldrsb(w2, MemOperand(x0, preindex, PreIndex));
11999 __ strb(w2, MemOperand(x1, preindex, PreIndex));
12056 __ Mov(x0, src_tagged);
12057 __ Mov(x1, dst_tagged);
12061 __ ldp(x2, x3, MemOperand(x0, postindex, PostIndex));
12062 __ stp(x2, x3, MemOperand(x1, postindex, PostIndex));
12069 __ ldp(q0, q1, MemOperand(x0, postindex, PostIndex));
12070 __ stp(q0, q1, MemOperand(x1, postindex, PostIndex));
12077 __ ldpsw(x2, x3, MemOperand(x0, postindex, PostIndex));
12078 __ stp(w2, w3, MemOperand(x1, postindex, PostIndex));
12085 __ ldp(d0, d1, MemOperand(x0, postindex, PostIndex));
12086 __ stp(d0, d1, MemOperand(x1, postindex, PostIndex));
12093 __ ldp(w2, w3, MemOperand(x0, postindex, PostIndex));
12094 __ stp(w2, w3, MemOperand(x1, postindex, PostIndex));
12101 __ ldp(s0, s1, MemOperand(x0, postindex, PostIndex));
12102 __ stp(s0, s1, MemOperand(x1, postindex, PostIndex));
12109 __ ldr(x2, MemOperand(x0, postindex, PostIndex));
12110 __ str(x2, MemOperand(x1, postindex, PostIndex));
12117 __ ldr(d0, MemOperand(x0, postindex, PostIndex));
12118 __ str(d0, MemOperand(x1, postindex, PostIndex));
12125 __ ldr(w2, MemOperand(x0, postindex, PostIndex));
12126 __ str(w2, MemOperand(x1, postindex, PostIndex));
12133 __ ldr(s0, MemOperand(x0, postindex, PostIndex));
12134 __ str(s0, MemOperand(x1, postindex, PostIndex));
12141 __ ldrh(w2, MemOperand(x0, postindex, PostIndex));
12142 __ strh(w2, MemOperand(x1, postindex, PostIndex));
12149 __ ldrsh(w2, MemOperand(x0, postindex, PostIndex));
12150 __ strh(w2, MemOperand(x1, postindex, PostIndex));
12157 __ ldrb(w2, MemOperand(x0, postindex, PostIndex));
12158 __ strb(w2, MemOperand(x1, postindex, PostIndex));
12165 __ ldrsb(w2, MemOperand(x0, postindex, PostIndex));
12166 __ strb(w2, MemOperand(x1, postindex, PostIndex));
12224 __ Mov(x0, src_tagged);
12225 __ Mov(x1, dst_tagged);
12227 __ Mov(x10, offset_base + data_length);
12230 __ ldr(x2, MemOperand(x0, x10));
12231 __ str(x2, MemOperand(x1, x10));
12235 __ Mov(x10, offset_base + data_length);
12238 __ ldr(d0, MemOperand(x0, x10));
12239 __ str(d0, MemOperand(x1, x10));
12243 __ Mov(x10, offset_base + data_length);
12246 __ ldr(w2, MemOperand(x0, x10));
12247 __ str(w2, MemOperand(x1, x10));
12251 __ Mov(x10, offset_base + data_length);
12254 __ ldr(s0, MemOperand(x0, x10));
12255 __ str(s0, MemOperand(x1, x10));
12259 __ Mov(x10, offset_base + data_length);
12262 __ ldrh(w2, MemOperand(x0, x10));
12263 __ strh(w2, MemOperand(x1, x10));
12267 __ Mov(x10, offset_base + data_length);
12270 __ ldrsh(w2, MemOperand(x0, x10));
12271 __ strh(w2, MemOperand(x1, x10));
12275 __ Mov(x10, offset_base + data_length);
12278 __ ldrb(w2, MemOperand(x0, x10));
12279 __ strb(w2, MemOperand(x1, x10));
12283 __ Mov(x10, offset_base + data_length);
12286 __ ldrsb(w2, MemOperand(x0, x10));
12287 __ strb(w2, MemOperand(x1, x10));
12327 __ Mov(x10, src_tagged);
12328 __ Mov(x11, offset_tagged);
12329 __ Ld1(v0.V16B(), MemOperand(x10, x11, PostIndex));
12349 __ Adr(x0, &loop);
12350 __ Mov(x1, 0);
12351 __ B(&loop_entry);
12353 __ Bind(&loop);
12354 __ Add(x1, x1, 1); // Count successful jumps.
12357 __ Add(x0, x0, UINT64_C(1) << kAddressTagOffset);
12358 __ Tst(x0, kAddressTagMask);
12359 __ B(eq, &done);
12361 __ Bind(&loop_entry);
12362 __ Br(x0);
12364 __ Bind(&done);
12380 __ Adr(x0, &loop);
12381 __ Mov(x1, 0);
12382 __ B(&loop_entry);
12384 __ Bind(&loop);
12387 __ Tst(lr, kAddressTagMask);
12388 __ B(ne, &done);
12390 __ Add(x1, x1, 1); // Count successful jumps.
12393 __ Add(x0, x0, UINT64_C(1) << kAddressTagOffset);
12394 __ Tst(x0, kAddressTagMask);
12395 __ B(eq, &done);
12397 __ Bind(&loop_entry);
12398 __ Blr(x0);
12400 __ Bind(&done);
12416 __ Adr(x0, &loop);
12417 __ Mov(x1, 0);
12418 __ B(&loop_entry);
12420 __ Bind(&loop);
12423 __ Adr(x10, &done);
12424 __ Tst(x10, kAddressTagMask);
12425 __ B(ne, &done);
12428 __ Adrp(x11, &done);
12429 __ Tst(x11, kAddressTagMask);
12430 __ B(ne, &done);
12432 __ Add(x1, x1, 1); // Count successful iterations.
12435 __ Add(x0, x0, UINT64_C(1) << kAddressTagOffset);
12436 __ Tst(x0, kAddressTagMask);
12437 __ B(eq, &done);
12439 __ Bind(&loop_entry);
12440 __ Br(x0);
12442 __ Bind(&done);
12458 __ Mov(x4, msg_addr);
12459 __ Sys(3, 0x7, 0x5, 1, x4);
12460 __ Mov(x3, x4);
12461 __ Sys(3, 0x7, 0xa, 1, x3);
12462 __ Mov(x2, x3);
12463 __ Sys(3, 0x7, 0xb, 1, x2);
12464 __ Mov(x1, x2);
12465 __ Sys(3, 0x7, 0xe, 1, x1);
12481 __ Mov(x11, msg_addr);
12482 __ Ic(IVAU, x11);
12497 __ Mov(x20, msg_addr);
12498 __ Dc(CVAC, x20);
12499 __ Mov(x21, msg_addr);
12500 __ Dc(CVAU, x21);
12501 __ Mov(x22, msg_addr);
12502 __ Dc(CIVAC, x22);
12521 __ Mov(x20, msg_addr);
12522 __ Dc(CVAP, x20);
12537 __ Mov(x20, msg_addr);
12538 __ Dc(CVADP, x20);
12553 __ Mov(x20, msg_addr);
12554 __ Dc(CGVAC, x20);
12555 __ Dc(CGDVAC, x20);
12556 __ Dc(CGVAP, x20);
12557 __ Dc(CGDVAP, x20);
12558 __ Dc(CIGVAC, x20);
12559 __ Dc(CIGDVAC, x20);
12576 __ Mov(w0, 0);
12577 __ Mov(w1, 0);
12578 __ Crc32b(w10, w0, w1);
12580 __ Mov(w0, 0x1);
12581 __ Mov(w1, 0x138);
12582 __ Crc32b(w11, w0, w1);
12584 __ Mov(w0, 0x1);
12585 __ Mov(w1, 0x38);
12586 __ Crc32b(w12, w0, w1);
12588 __ Mov(w0, 0);
12589 __ Mov(w1, 128);
12590 __ Crc32b(w13, w0, w1);
12592 __ Mov(w0, UINT32_MAX);
12593 __ Mov(w1, 255);
12594 __ Crc32b(w14, w0, w1);
12596 __ Mov(w0, 0x00010001);
12597 __ Mov(w1, 0x10001000);
12598 __ Crc32b(w15, w0, w1);
12620 __ Mov(w0, 0);
12621 __ Mov(w1, 0);
12622 __ Crc32h(w10, w0, w1);
12624 __ Mov(w0, 0x1);
12625 __ Mov(w1, 0x10038);
12626 __ Crc32h(w11, w0, w1);
12628 __ Mov(w0, 0x1);
12629 __ Mov(w1, 0x38);
12630 __ Crc32h(w12, w0, w1);
12632 __ Mov(w0, 0);
12633 __ Mov(w1, 128);
12634 __ Crc32h(w13, w0, w1);
12636 __ Mov(w0, UINT32_MAX);
12637 __ Mov(w1, 255);
12638 __ Crc32h(w14, w0, w1);
12640 __ Mov(w0, 0x00010001);
12641 __ Mov(w1, 0x10001000);
12642 __ Crc32h(w15, w0, w1);
12664 __ Mov(w0, 0);
12665 __ Mov(w1, 0);
12666 __ Crc32w(w10, w0, w1);
12668 __ Mov(w0, 0x1);
12669 __ Mov(w1, 0x80000031);
12670 __ Crc32w(w11, w0, w1);
12672 __ Mov(w0, 0);
12673 __ Mov(w1, 128);
12674 __ Crc32w(w13, w0, w1);
12676 __ Mov(w0, UINT32_MAX);
12677 __ Mov(w1, 255);
12678 __ Crc32w(w14, w0, w1);
12680 __ Mov(w0, 0x00010001);
12681 __ Mov(w1, 0x10001000);
12682 __ Crc32w(w15, w0, w1);
12703 __ Mov(w0, 0);
12704 __ Mov(x1, 0);
12705 __ Crc32x(w10, w0, x1);
12707 __ Mov(w0, 0x1);
12708 __ Mov(x1, UINT64_C(0x0000000800000031));
12709 __ Crc32x(w11, w0, x1);
12711 __ Mov(w0, 0);
12712 __ Mov(x1, 128);
12713 __ Crc32x(w13, w0, x1);
12715 __ Mov(w0, UINT32_MAX);
12716 __ Mov(x1, 255);
12717 __ Crc32x(w14, w0, x1);
12719 __ Mov(w0, 0x00010001);
12720 __ Mov(x1, UINT64_C(0x1000100000000000));
12721 __ Crc32x(w15, w0, x1);
12742 __ Mov(w0, 0);
12743 __ Mov(w1, 0);
12744 __ Crc32cb(w10, w0, w1);
12746 __ Mov(w0, 0x1);
12747 __ Mov(w1, 0x138);
12748 __ Crc32cb(w11, w0, w1);
12750 __ Mov(w0, 0x1);
12751 __ Mov(w1, 0x38);
12752 __ Crc32cb(w12, w0, w1);
12754 __ Mov(w0, 0);
12755 __ Mov(w1, 128);
12756 __ Crc32cb(w13, w0, w1);
12758 __ Mov(w0, UINT32_MAX);
12759 __ Mov(w1, 255);
12760 __ Crc32cb(w14, w0, w1);
12762 __ Mov(w0, 0x00010001);
12763 __ Mov(w1, 0x10001000);
12764 __ Crc32cb(w15, w0, w1);
12786 __ Mov(w0, 0);
12787 __ Mov(w1, 0);
12788 __ Crc32ch(w10, w0, w1);
12790 __ Mov(w0, 0x1);
12791 __ Mov(w1, 0x10038);
12792 __ Crc32ch(w11, w0, w1);
12794 __ Mov(w0, 0x1);
12795 __ Mov(w1, 0x38);
12796 __ Crc32ch(w12, w0, w1);
12798 __ Mov(w0, 0);
12799 __ Mov(w1, 128);
12800 __ Crc32ch(w13, w0, w1);
12802 __ Mov(w0, UINT32_MAX);
12803 __ Mov(w1, 255);
12804 __ Crc32ch(w14, w0, w1);
12806 __ Mov(w0, 0x00010001);
12807 __ Mov(w1, 0x10001000);
12808 __ Crc32ch(w15, w0, w1);
12830 __ Mov(w0, 0);
12831 __ Mov(w1, 0);
12832 __ Crc32cw(w10, w0, w1);
12834 __ Mov(w0, 0x1);
12835 __ Mov(w1, 0x80000031);
12836 __ Crc32cw(w11, w0, w1);
12838 __ Mov(w0, 0);
12839 __ Mov(w1, 128);
12840 __ Crc32cw(w13, w0, w1);
12842 __ Mov(w0, UINT32_MAX);
12843 __ Mov(w1, 255);
12844 __ Crc32cw(w14, w0, w1);
12846 __ Mov(w0, 0x00010001);
12847 __ Mov(w1, 0x10001000);
12848 __ Crc32cw(w15, w0, w1);
12869 __ Mov(w0, 0);
12870 __ Mov(x1, 0);
12871 __ Crc32cx(w10, w0, x1);
12873 __ Mov(w0, 0x1);
12874 __ Mov(x1, UINT64_C(0x0000000800000031));
12875 __ Crc32cx(w11, w0, x1);
12877 __ Mov(w0, 0);
12878 __ Mov(x1, 128);
12879 __ Crc32cx(w13, w0, x1);
12881 __ Mov(w0, UINT32_MAX);
12882 __ Mov(x1, 255);
12883 __ Crc32cx(w14, w0, x1);
12885 __ Mov(w0, 0x00010001);
12886 __ Mov(x1, UINT64_C(0x1000100000000000));
12887 __ Crc32cx(w15, w0, x1);
12907 __ Mov(x0, 0x3d720c8d);
12908 __ Cmp(x0, Operand(0x3d720c8d));
12928 __ Mov(base, base_address);
12929 __ Mov(offset, reg_offset);
12932 __ ComputeAddress(x2, MemOperand(base, 0));
12933 __ ComputeAddress(x3, MemOperand(base, 8));
12934 __ ComputeAddress(x4, MemOperand(base, -100));
12936 __ ComputeAddress(x5, MemOperand(base, offset));
12937 __ ComputeAddress(x6, MemOperand(base, offset, LSL, 2));
12938 __ ComputeAddress(x7, MemOperand(base, offset, LSL, 4));
12939 __ ComputeAddress(x8, MemOperand(base, offset, LSL, 8));
12941 __ ComputeAddress(x9, MemOperand(base, offset, SXTW));
12942 __ ComputeAddress(x10, MemOperand(base, offset, UXTW, 1));
12943 __ ComputeAddress(x11, MemOperand(base, offset, SXTW, 2));
12944 __ ComputeAddress(x12, MemOperand(base, offset, UXTW, 3));
12989 __ Mov(x0, 0);
12990 __ Mov(x1, 1);
12991 __ Mov(x10, 0);
12993 __ B(&test_tbz);
12994 __ Bind(&success_tbz);
12995 __ Orr(x0, x0, 1 << 0);
12996 __ B(&test_cbz);
12997 __ Bind(&success_cbz);
12998 __ Orr(x0, x0, 1 << 1);
12999 __ B(&test_bcond);
13000 __ Bind(&success_bcond);
13001 __ Orr(x0, x0, 1 << 2);
13003 __ B(&done);
13011 __ B(&fail);
13013 __ Nop();
13016 __ B(&fail);
13018 __ Bind(&test_tbz);
13019 __ Tbz(x10, 7, &success_tbz);
13020 __ Bind(&test_cbz);
13021 __ Cbz(x10, &success_cbz);
13022 __ Bind(&test_bcond);
13023 __ Cmp(x10, 0);
13024 __ B(eq, &success_bcond);
13031 __ Bind(&fail);
13032 __ Mov(x1, 0);
13033 __ Bind(&done);
13053 __ Mov(x0, 0);
13054 __ Mov(x1, 1);
13055 __ Mov(x10, 0);
13057 __ Tbz(x10, 7, &success);
13064 __ B(&fail);
13066 __ Nop();
13069 __ B(&fail);
13071 __ Bind(&success);
13072 __ Mov(x0, 1);
13074 __ B(&done);
13075 __ Bind(&fail);
13076 __ Mov(x1, 0);
13077 __ Bind(&done);
13105 __ Mov(x0, 0);
13106 __ Mov(x1, 1);
13107 __ Mov(x10, 0);
13109 __ Bind(&test_tbz);
13110 __ Tbz(x10, 7, &success_tbz);
13111 __ Bind(&test_cbz);
13112 __ Cbz(x10, &success_cbz);
13113 __ Bind(&test_bcond);
13114 __ Cmp(x10, 0);
13115 __ B(eq, &success_bcond);
13123 __ B(&fail);
13125 __ Nop();
13128 __ B(&fail);
13130 __ Bind(&success_tbz);
13131 __ Orr(x0, x0, 1 << 0);
13132 __ B(&test_cbz);
13133 __ Bind(&success_cbz);
13134 __ Orr(x0, x0, 1 << 1);
13135 __ B(&test_bcond);
13136 __ Bind(&success_bcond);
13137 __ Orr(x0, x0, 1 << 2);
13139 __ B(&done);
13140 __ Bind(&fail);
13141 __ Mov(x1, 0);
13142 __ Bind(&done);
13167 __ B(&target);
13168 __ B(eq, &target);
13169 __ Cbz(x0, &target);
13170 __ Tbz(x0, 0, &target);
13172 __ Bind(&target);
13198 __ Cbz(x0, &target_cbz);
13200 __ Nop();
13202 __ Tbz(x0, 0, &target_tbz);
13204 __ Nop();
13208 __ Nop();
13210 __ Bind(&target_cbz);
13211 __ Bind(&target_tbz);
13263 __ B(eq, &labels[i]);
13267 __ Nop();
13271 __ Cbz(x0, &labels[n_bcond + i]);
13278 __ Nop();
13281 __ Tbz(x0, 0, &labels[n_bcond + n_cbz]);
13284 __ Nop();
13294 __ Nop();
13297 __ Bind(&labels[i]);
13341 __ Tbz(x0, 0, &target_tbz);
13344 __ Nop();
13350 __ Ldr(s0, i + 0.1);
13360 __ Bind(&target_tbz);
13377 __ b(&over_literal);
13378 __ place(&manually_placed_literal);
13379 __ bind(&over_literal);
13381 __ Ldr(x1, &manually_placed_literal);
13382 __ Ldr(x2, &automatically_placed_literal);
13383 __ Add(x0, x1, x2);
13409 __ Ldr(d1, 1.1);
13414 __ Ldr(x2, &explicit_literal);
13419 __ Ldr(d3, 3.3);
13426 __ Ldr(x4, &explicit_literal);
13460 __ Ldr(w1, &lit_32_update_before_pool);
13461 __ Ldr(x2, &lit_64_update_before_pool);
13462 __ Ldr(w3, &lit_32_update_after_pool);
13463 __ Ldr(x4, &lit_64_update_after_pool);
13511 __ Ldr(w1, &lit_manual);
13512 __ Ldr(w2, lit_deleted_on_placement);
13513 __ Ldr(w3, lit_deleted_on_pool_destruction);
13555 __ Mov(data_32, data_32_address);
13556 __ Mov(data_64, data_64_address);
13558 __ Move(GenericOperand(w0),
13560 __ Move(GenericOperand(s0),
13562 __ Move(GenericOperand(x10),
13564 __ Move(GenericOperand(d10),
13567 __ Move(GenericOperand(w1), GenericOperand(w0));
13568 __ Move(GenericOperand(s1), GenericOperand(s0));
13569 __ Move(GenericOperand(x11), GenericOperand(x10));
13570 __ Move(GenericOperand(d11), GenericOperand(d10));
13572 __ Move(GenericOperand(MemOperand(data_32, 0 * size_32), size_32),
13574 __ Move(GenericOperand(MemOperand(data_32, 2 * size_32), size_32),
13576 __ Move(GenericOperand(MemOperand(data_64, 0 * size_64), size_64),
13578 __ Move(GenericOperand(MemOperand(data_64, 2 * size_64), size_64),
13581 __ Move(GenericOperand(MemOperand(data_32, 4 * size_32), size_32),
13583 __ Move(GenericOperand(MemOperand(data_64, 4 * size_64), size_64),
13702 __ Mov(w0, 0);
13703 __ CallRuntime(runtime_call_add_one);
13704 __ Mov(w20, w0);
13706 __ Fmov(d0, 0.0);
13707 __ Fmov(d1, 1.5);
13708 __ Fmov(d2, 2.5);
13709 __ CallRuntime(runtime_call_add_doubles);
13710 __ Fmov(d20, d0);
13712 __ Mov(x0, 0x123);
13713 __ Push(x0, x0);
13714 __ CallRuntime(runtime_call_one_argument_on_stack);
13715 __ Mov(x21, x0);
13716 __ Pop(x0, x1);
13718 __ Fmov(d0, 314.0);
13719 __ Fmov(d1, 4.0);
13720 __ Push(d1, d0);
13721 __ CallRuntime(runtime_call_two_arguments_on_stack);
13722 __ Fmov(d21, d0);
13723 __ Pop(d1, d0);
13726 __ Mov(w0, 0);
13727 __ CallRuntime(runtime_call_enum);
13728 __ Mov(w0, 0);
13729 __ CallRuntime(runtime_call_enum_class);
13734 __ B(&after_function);
13735 __ Bind(&function);
13736 __ Mov(x22, 0);
13737 __ Mov(w0, 123);
13738 __ TailCallRuntime(runtime_call_add_one);
13740 __ Mov(x22, 0xbad);
13741 __ Ret();
13742 __ Bind(&after_function);
13745 __ Push(ip0, lr);
13746 __ Bl(&function);
13747 __ Pop(lr, ip0);
13749 __ Mov(w23, w0);
13751 __ Mov(x24, 0);
13764 __ Mov(w0, x);
13765 __ CallRuntime(test_int8_t);
13766 __ Sxtb(w0, w0);
13767 __ Cmp(w0, ExtractSignedBitfield32(7, 0, x));
13768 __ Cinc(x24, x24, ne);
13769 __ Mov(w0, x);
13770 __ CallRuntime(test_uint8_t);
13771 __ Uxtb(w0, w0);
13772 __ Cmp(w0, ExtractUnsignedBitfield32(7, 0, x));
13773 __ Cinc(x24, x24, ne);
13774 __ Mov(w0, x);
13775 __ CallRuntime(test_int16_t);
13776 __ Sxth(w0, w0);
13777 __ Cmp(w0, ExtractSignedBitfield32(15, 0, x));
13778 __ Cinc(x24, x24, ne);
13779 __ Mov(w0, x);
13780 __ CallRuntime(test_uint16_t);
13781 __ Uxth(w0, w0);
13782 __ Cmp(w0, ExtractUnsignedBitfield32(15, 0, x));
13783 __ Cinc(x24, x24, ne);
13788 __ Mov(x0, reinterpret_cast<uint64_t>(&value));
13789 __ CallRuntime(runtime_call_store_at_address);
13791 __ Mov(w0, 0);
13792 __ CallRuntime(runtime_call_no_args);
13793 __ Mov(w25, w0);
13827 __ Mov(x16, reinterpret_cast<uint64_t>(func)); \
13828 __ Blr(x16);
13837 __ Mov(w20, w0);
13839 __ Mov(w0, 2);
13841 __ Mov(w21, w0);
13845 __ Mov(w22, w0);
13847 __ Mov(w23, w0);
13848 __ Mov(w0, 4);
13850 __ Mov(w24, w0);
13852 __ Mov(w25, w0);
13891 __ Bind(&start);
13892 __ Mov(x0, x0);
13894 __ Mov(w0, w0, kDiscardForSameWReg);
13896 __ Mov(w0, w0);
13911 __ Bind(&start);
13912 __ Nop();
13924 __ Mov(x0, 0x5555000055555555);
13927 __ Addg(x1, x0, 16, 2);
13928 __ Subg(x2, x1, 16, 1);
13931 __ Addg(x3, x0, 1008, 0);
13932 __ Subg(x4, x3, 1008, 0);
13935 __ Addg(x5, x0, 0, 15);
13936 __ Subg(x6, x0, 0, 14);
13939 __ Addg(x7, x0, 0, 0);
13940 __ Subg(x8, x0, 0, 0);
13943 __ Mov(x20, sp); // Store original sp.
13945 __ Subg(sp, sp, 32, 0); // Claim 32 bytes.
13946 __ Sub(x9, sp, x20); // Subtract original sp and store difference.
13948 __ Mov(sp, x20); // Restore original sp.
13949 __ Claim(32);
13950 __ Addg(sp, sp, 32, 0); // Drop 32 bytes.
13951 __ Sub(x10, sp, x20); // Subtract original sp and store difference.
13953 __ Mov(sp, x20); // Restore sp (should be no-op)
13954 __ Addg(sp, sp, 0, 1); // Tag the sp.
13955 __ Sub(x11, sp, x20); // Subtract original sp and store for later comparison.
13956 __ Mov(sp, x20); // Restore sp.
13981 __ Mov(x0, 0x5555555555555555);
13982 __ Mov(x1, -42);
13985 __ Sbfx(x10, x0, 0, 56);
13986 __ Sbfx(x11, x1, 0, 56);
13988 __ Subp(x4, x0, x1);
13989 __ Sub(x5, x10, x11);
13991 __ Subp(x6, x1, x0);
13992 __ Sub(x7, x11, x10);
13994 __ Subps(x8, x0, x1);
13995 __ Mrs(x18, NZCV);
13996 __ Subs(x9, x10, x11);
13997 __ Mrs(x19, NZCV);
13999 __ Cmpp(x1, x0);
14000 __ Mrs(x20, NZCV);
14001 __ Cmp(x11, x10);
14002 __ Mrs(x21, NZCV);
14006 __ Mov(x2, 0x20); // Exclude tag 5.
14007 __ Irg(x3, x0, x2);
14008 __ Subps(x22, x0, x3);
14029 __ Mov(x0, 0xaaaa);
14030 __ Mov(x20, 0x12345678);
14032 __ Gmi(x0, x20, x0); // Add mask bit 0.
14033 __ Addg(x20, x20, 0, 1);
14034 __ Gmi(x1, x20, x0); // No effect.
14035 __ Addg(x20, x20, 0, 1);
14036 __ Gmi(x2, x20, x1); // Add mask bit 2.
14037 __ Addg(x20, x20, 0, 1);
14038 __ Gmi(x3, x20, x2); // No effect.
14039 __ Addg(x20, x20, 0, 1);
14040 __ Gmi(x4, x20, x3); // Add mask bit 4.
14041 __ Addg(x20, x20, 0, 1);
14042 __ Gmi(x5, x20, x4); // No effect.
14043 __ Addg(x20, x20, 0, 9);
14044 __ Gmi(x6, x20, x5); // Add mask bit 14.
14045 __ Gmi(x7, x20, xzr); // Only mask bit 14.
14066 __ Mov(x10, 8);
14067 __ Mov(x0, 0x5555555555555555);
14071 __ Bind(&loop);
14072 __ Irg(x1, x0);
14073 __ Sub(x10, x10, 1);
14074 __ Cbz(x10, &failed); // Exit if loop count exceeded.
14075 __ Cmp(x1, 0x5555555555555555);
14076 __ B(eq, &loop); // Loop if the tag hasn't changed.
14079 __ Bic(x1, x1, 0x0f00000000000000);
14080 __ Subs(x1, x1, 0x5055555555555555);
14081 __ B(&done);
14083 __ Bind(&failed);
14084 __ Mov(x1, 1);
14086 __ Bind(&done);
14091 __ Mov(x3, 0);
14092 __ Mov(x10, 128);
14093 __ Mov(x11, 0xaaaa);
14096 __ Bind(&loop2);
14097 __ Irg(x2, x1, x11);
14098 __ Orr(x3, x3, x2);
14099 __ Subs(x10, x10, 1);
14100 __ B(ne, &loop2);
14101 __ Lsr(x2, x3, 56);
14104 __ Mov(x3, 0xffffffffffffffff);
14105 __ Irg(x3, x3, x3);
14125 __ Mov(x0, dst_addr);
14126 __ Add(x1, x0, 1);
14127 __ Mov(x2, 13);
14128 __ Mov(x3, 0x1234aa);
14131 __ Setp(x1, x2, x3);
14132 __ Setm(x1, x2, x3);
14133 __ Sete(x1, x2, x3);
14136 __ Setp(x1, x2, x3);
14137 __ Setm(x1, x2, x3);
14138 __ Sete(x1, x2, x3);
14141 __ Add(x1, x0, 15);
14142 __ Mov(x2, 1);
14143 __ Set(x1, x2, xzr);
14146 __ Ldp(x10, x11, MemOperand(x0));
14169 __ Mov(x0, dst_addr);
14170 __ Mov(x1, x0);
14171 __ Mov(x2, 16);
14172 __ Mov(x3, 0x42);
14173 __ Setn(x1, x2, x3);
14174 __ Ldp(x10, x11, MemOperand(x0));
14210 __ Mov(x0, reinterpret_cast<uint64_t>(dst_addr));
14211 __ Gmi(x2, x0, xzr);
14212 __ Irg(x1, x0, x2); // Choose new tag for setg destination.
14213 __ Mov(x2, 16);
14214 __ Mov(x3, 0x42);
14215 __ Setg(x1, x2, x3);
14217 __ Ubfx(x4, x1, 56, 4); // Extract new tag.
14218 __ Bfi(x0, x4, 56, 4); // Tag dst_addr so set region can be loaded.
14219 __ Ldp(x10, x11, MemOperand(x0));
14221 __ Mov(x0, reinterpret_cast<uint64_t>(dst_addr));
14222 __ Ldp(x12, x13, MemOperand(x0, 16)); // Unset region has original tag.
14251 __ Mov(x0, buf_addr);
14254 __ Mov(x2, x0); // src = &buf[0]
14255 __ Add(x3, x0, 8); // dst = &buf[8]
14256 __ Mov(x4, 8); // count = 8
14257 __ Cpyp(x3, x2, x4);
14258 __ Cpym(x3, x2, x4);
14259 __ Cpye(x3, x2, x4);
14260 __ Ldp(x10, x11, MemOperand(x0));
14261 __ Mrs(x20, NZCV);
14264 __ Mov(x5, x0); // src = &buf[0]
14265 __ Add(x6, x0, 4); // dst = &buf[4]
14266 __ Mov(x7, 8); // count = 8
14267 __ Cpy(x6, x5, x7);
14268 __ Ldp(x12, x13, MemOperand(x0));
14303 __ Mov(x0, buf_addr);
14305 __ Add(x2, x0, 1); // src = &buf[1]
14306 __ Mov(x3, x0); // dst = &buf[0]
14307 __ Mov(x4, 15); // count = 15
14308 __ Cpyn(x3, x2, x4);
14309 __ Ldp(x10, x11, MemOperand(x0));
14311 __ Add(x5, x0, 1); // src = &buf[1]
14312 __ Mov(x6, x0); // dst = &buf[0]
14313 __ Mov(x4, 15); // count = 15
14314 __ Cpyrn(x6, x5, x4);
14315 __ Ldp(x12, x13, MemOperand(x0));
14317 __ Add(x7, x0, 1); // src = &buf[1]
14318 __ Mov(x8, x0); // dst = &buf[0]
14319 __ Mov(x4, 15); // count = 15
14320 __ Cpywn(x8, x7, x4);
14321 __ Ldp(x14, x15, MemOperand(x0));
14359 __ Mov(x0, buf_addr);
14362 __ Mov(x2, x0); // src = &buf[0]
14363 __ Add(x3, x0, 8); // dst = &buf[8]
14364 __ Mov(x4, 8); // count = 8
14365 __ Cpyf(x3, x2, x4);
14366 __ Ldp(x10, x11, MemOperand(x0));
14367 __ Mrs(x20, NZCV);
14370 __ Mov(x5, x0); // src = &buf[0]
14371 __ Add(x6, x0, 4); // dst = &buf[4]
14372 __ Mov(x7, 8); // count = 8
14373 __ Cpyf(x6, x5, x7);
14374 __ Ldp(x12, x13, MemOperand(x0));
14413 __ Mov(x0, buf_addr);
14415 __ Add(x2, x0, 1); // src = &buf[1]
14416 __ Mov(x3, x0); // dst = &buf[0]
14417 __ Mov(x4, 15); // count = 15
14418 __ Cpyfn(x3, x2, x4);
14419 __ Ldp(x10, x11, MemOperand(x0));
14421 __ Add(x5, x0, 1); // src = &buf[1]
14422 __ Mov(x6, x0); // dst = &buf[0]
14423 __ Mov(x4, 15); // count = 15
14424 __ Cpyfrn(x6, x5, x4);
14425 __ Ldp(x12, x13, MemOperand(x0));
14427 __ Add(x7, x0, 1); // src = &buf[1]
14428 __ Mov(x8, x0); // dst = &buf[0]
14429 __ Mov(x4, 15); // count = 15
14430 __ Cpyfwn(x8, x7, x4);
14431 __ Ldp(x14, x15, MemOperand(x0));
14460 __ Mov(x0, -1);
14461 __ Mov(x1, 1);
14462 __ Mov(x2, 0);
14463 __ Mov(x3, 0x7fff'ffff);
14464 __ Mov(x4, 0x8000'0000);
14465 __ Mov(x5, 0x8000'0001);
14466 __ Mov(x6, 0x7fff'ffff'ffff'ffff);
14467 __ Mov(x7, 0x8000'0000'0000'0000);
14468 __ Mov(x8, 0x8000'0000'0000'0001);
14470 __ Abs(w10, w0);
14471 __ Abs(x11, x0);
14472 __ Abs(w12, w1);
14473 __ Abs(x13, x1);
14474 __ Abs(w14, w2);
14475 __ Abs(x15, x2);
14477 __ Abs(w19, w3);
14478 __ Abs(x20, x3);
14479 __ Abs(w21, w4);
14480 __ Abs(x22, x4);
14481 __ Abs(w23, w5);
14482 __ Abs(x24, x5);
14483 __ Abs(w25, w6);
14484 __ Abs(x26, x6);
14485 __ Abs(w27, w7);
14486 __ Abs(x28, x7);
14487 __ Abs(w29, w8);
14488 __ Abs(x30, x8);
14519 __ Mov(x0, -1);
14520 __ Mov(x1, 1);
14521 __ Mov(x2, 0);
14522 __ Mov(x3, 0x7fff'ffff);
14523 __ Mov(x4, 0x8000'0000);
14524 __ Mov(x5, 0x8000'0001);
14525 __ Mov(x6, 0x7fff'ffff'ffff'ffff);
14526 __ Mov(x7, 0x4242'4242'aaaa'aaaa);
14528 __ Cnt(w10, w0);
14529 __ Cnt(x11, x0);
14530 __ Cnt(w12, w1);
14531 __ Cnt(x13, x1);
14532 __ Cnt(w14, w2);
14533 __ Cnt(x15, x2);
14534 __ Cnt(w19, w3);
14535 __ Cnt(x20, x3);
14536 __ Cnt(w21, w4);
14537 __ Cnt(x22, x4);
14538 __ Cnt(w23, w5);
14539 __ Cnt(x24, x5);
14540 __ Cnt(w25, w6);
14541 __ Cnt(x26, x6);
14542 __ Cnt(w27, w7);
14543 __ Cnt(x28, x7);
14572 __ Mov(x0, -1);
14573 __ Mov(x1, 1);
14574 __ Mov(x2, 2);
14575 __ Mov(x3, 0x7fff'ff00);
14576 __ Mov(x4, 0x8000'4000);
14577 __ Mov(x5, 0x4000'0001);
14578 __ Mov(x6, 0x0000'0001'0000'0000);
14579 __ Mov(x7, 0x4200'0000'0000'0000);
14581 __ Ctz(w10, w0);
14582 __ Ctz(x11, x0);
14583 __ Ctz(w12, w1);
14584 __ Ctz(x13, x1);
14585 __ Ctz(w14, w2);
14586 __ Ctz(x15, x2);
14587 __ Ctz(w19, w3);
14588 __ Ctz(x20, x3);
14589 __ Ctz(w21, w4);
14590 __ Ctz(x22, x4);
14591 __ Ctz(w23, w5);
14592 __ Ctz(x24, x5);
14593 __ Ctz(w25, w6);
14594 __ Ctz(x26, x6);
14595 __ Ctz(w27, w7);
14596 __ Ctz(x28, x7);
14634 __ Mov(x0, a);
14635 __ Mov(x1, b);
14775 __ SetSimulatorCPUFeatures(f);
14793 __ EnableSimulatorCPUFeatures(f);
14811 __ DisableSimulatorCPUFeatures(f);
14830 __ SaveSimulatorCPUFeatures();
14831 __ SetSimulatorCPUFeatures(f);
14833 __ SaveSimulatorCPUFeatures();
14834 __ SetSimulatorCPUFeatures(CPUFeatures::All());
14835 __ RestoreSimulatorCPUFeatures();
14837 __ RestoreSimulatorCPUFeatures();
14864 __ Fadd(v0.V4S(), v1.V4S(), v2.V4S()); // Requires {FP, NEON}.
14893 __ Mov(x0, base);
14894 __ Mov(x1, limit);
14895 __ Mov(x2, sp);
14896 __ Add(sp, x1, 1); // Avoid accessing memory below `sp`.
14898 __ Mov(x10, 42);
14899 __ Poke(x10, 0);
14900 __ Peek(x10, base - limit - kXRegSizeInBytes - 1);
14902 __ Mov(sp, x2);
14918 __ Mov(x1, limit);
14919 __ Mov(x2, sp);
14920 __ Add(sp, x1, 1); // Avoid accessing memory below `sp`.
14923 __ Mov(w10, 42);
14924 __ Ldrb(w10, MemOperand(sp, -1));
14926 __ Mov(sp, x2);
14941 __ Mov(x1, limit);
14942 __ Mov(x2, sp);
14943 __ Add(sp, x1, 1); // Avoid accessing memory below `sp`.
14946 __ Mov(w10, 42);
14947 __ Strb(w10, MemOperand(sp, -1));
14949 __ Mov(sp, x2);
14964 __ Mov(x0, base);
14967 __ Mov(x10, 42);
14968 __ Ldr(x10, MemOperand(x0, -static_cast<int64_t>(kXRegSizeInBytes) + 1));
14983 __ Mov(x0, base);
14986 __ Mov(x10, 42);
14987 __ Str(x10, MemOperand(x0, -static_cast<int64_t>(kXRegSizeInBytes) + 1));
15002 __ Movi(v0.V16B(), 0xFF);
15006 __ Movi(v0.V1D(), 0xDECAFC0FFEE);
15007 __ Mov(x0, v0.V2D(), 1);