Lines Matching refs:Mov
57 __ Mov(x29, sp);
60 __ Mov(x0, 0x1000);
61 __ Mov(sp, 0x1004);
80 __ Mov(x12, sp);
81 __ Mov(sp, 0x1004);
84 __ Mov(x13, sp);
85 __ Mov(sp, 0x1004);
90 __ Mov(x15, sp);
93 __ Mov(sp, x29);
124 __ Mov(x29, sp);
127 __ Mov(sp, 0x1004);
128 __ Mov(x0, sp);
132 __ Mov(x1, sp);
135 __ Mov(x17, 0xfff);
137 __ Mov(x2, sp);
141 __ Mov(x3, sp);
145 __ Mov(x4, sp);
149 __ Mov(w5, wsp);
154 __ Mov(w6, wsp);
157 __ Mov(sp, x29);
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);
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);
495 __ Mov(x0, 1);
496 __ Mov(x1, 0x8000000080008080);
526 __ Mov(x0, 0);
527 __ Mov(x1, 0xf0f0f0f0f0f0f0f0);
553 __ Mov(x0, 0xf0f0);
554 __ Mov(x1, 0xf00000ff);
589 __ Mov(x0, 1);
590 __ Mov(x1, 0x8000000080008081);
620 __ Mov(x0, 0xfff0);
621 __ Mov(x1, 0xf00000ff);
656 __ Mov(x0, 0xffffffffffffffff);
657 __ Mov(x1, 0x8000000080008081);
687 __ Mov(x1, 0xf00000ff);
699 __ Mov(x0, 0xfff0);
700 __ Mov(x1, 0xf00000ff);
712 __ Mov(x0, 0x8000000000000000);
713 __ Mov(x1, 0x00000001);
725 __ Mov(x0, 0xfff0);
737 __ Mov(x0, 0xff000000);
754 __ Mov(x0, 0xfff0);
755 __ Mov(x1, 0xf00000ff);
772 __ Mov(x20, sp);
773 __ Mov(x0, 0xffffff);
775 __ Mov(x21, sp);
776 __ Mov(sp, x20);
802 __ Mov(x0, 0xffffffffffffffff);
803 __ Mov(x1, 0x8000000080008081);
833 __ Mov(x1, 0xffff);
845 __ Mov(x0, 0xffffffff);
857 __ Mov(x0, 0x8000000000000000);
858 __ Mov(x1, 0x00000001);
870 __ Mov(x0, 0xffffffffffffffff);
882 __ Mov(w0, 0xffff0000);
899 __ Mov(x0, 0xfff0);
900 __ Mov(x1, 0xf00000ff);
934 __ Mov(x0, 0x1111111111111111);
935 __ Mov(x1, 0x8000000080008081);
965 __ Mov(x0, 0xfff0);
966 __ Mov(x1, 0xf00000ff);
1001 __ Mov(x0, 0x1111111111111111);
1002 __ Mov(x1, 0x8000000080008081);
1032 __ Mov(x25, 0);
1033 __ Mov(x26, 1);
1034 __ Mov(x18, 0xffffffff);
1035 __ Mov(x19, 0xffffffffffffffff);
1087 __ Mov(w0, a);
1088 __ Mov(w1, b);
1112 __ Mov(x16, 0);
1113 __ Mov(x17, 1);
1114 __ Mov(x18, 0xffffffff);
1115 __ Mov(x19, 0xffffffffffffffff);
1181 __ Mov(x16, 0);
1182 __ Mov(x17, 1);
1183 __ Mov(x18, 0xffffffff);
1184 __ Mov(x19, 0xffffffffffffffff);
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);
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);
1346 __ Mov(x17, 1);
1347 __ Mov(x18, 0x00000000ffffffff);
1348 __ Mov(x19, 0xffffffffffffffff);
1349 __ Mov(x20, 4);
1350 __ Mov(x21, 0x0000000200000000);
1385 __ Mov(x17, 1);
1386 __ Mov(x18, 0x00000000ffffffff);
1387 __ Mov(x19, 0xffffffffffffffff);
1388 __ Mov(x20, 4);
1389 __ Mov(x21, 0x0000000200000000);
1420 __ Mov(x16, 1);
1421 __ Mov(x17, 0xffffffff);
1422 __ Mov(x18, 0xffffffffffffffff);
1423 __ Mov(x19, 0x80000000);
1424 __ Mov(x20, 0x8000000000000000);
1425 __ Mov(x21, 2);
1456 __ Mov(x17, 0);
1502 __ Mov(x24, 0xfedcba9876543210);
1595 __ Mov(x24, 0x0008000000800000);
1596 __ Mov(x25, 0xff800000fff80000);
1597 __ Mov(x26, 0);
1639 __ Mov(pointer, 0x0000000012345678);
1640 __ Mov(modifier, 0x477d469dec0b8760);
1643 __ Mov(x0, pointer);
1646 __ Mov(x1, pointer);
1650 __ Mov(x2, x0);
1653 __ Mov(x3, x1);
1657 __ Mov(x4, x1);
1660 __ Mov(x5, x0);
1698 __ Mov(pointer, 0x0000000012345678);
1701 __ Mov(x0, pointer);
1704 __ Mov(x1, pointer);
1708 __ Mov(x2, x0);
1711 __ Mov(x3, x1);
1715 __ Mov(x4, x1);
1718 __ Mov(x5, x0);
1757 __ Mov(pointer, 0x0000000012345678);
1758 __ Mov(modifier, 0x477d469dec0b8760);
1761 __ Mov(x0, pointer);
1764 __ Mov(x1, pointer);
1768 __ Mov(x2, x0);
1771 __ Mov(x3, x1);
1775 __ Mov(x4, x1);
1778 __ Mov(x5, x0);
1816 __ Mov(pointer, 0x0000000012345678);
1819 __ Mov(x0, pointer);
1822 __ Mov(x1, pointer);
1826 __ Mov(x2, x0);
1829 __ Mov(x3, x1);
1833 __ Mov(x4, x1);
1836 __ Mov(x5, x0);
1875 __ Mov(pointer, 0x0000000012345678);
1876 __ Mov(modifier, 0x477d469dec0b8760);
1882 __ Mov(x1, pointer);
1883 __ Mov(x2, pointer);
1888 __ Mov(x3, x1);
1889 __ Mov(x4, x2);
1924 __ Mov(x0, 0x0000000012345678);
1925 __ Mov(x1, x0);
1926 __ Mov(x10, sp);
1933 __ Mov(x2, x0);
1934 __ Mov(x3, x1);
1954 __ Mov(x0, 0x1);
1955 __ Mov(x1, 0x0);
1956 __ Mov(x22, lr); // Save lr.
1961 __ Mov(x0, 0x0);
1964 __ Mov(x0, 0x0);
1967 __ Mov(x0, 0x0);
1973 __ Mov(x1, 0x1);
1974 __ Mov(lr, x22);
1993 __ Mov(x0, 0x0);
2032 __ Mov(x0, 0x0); // Set to non-zero to indicate failure.
2292 __ Mov(x0, 0x1);
2293 __ Mov(x1, 0x1);
2294 __ Mov(x2, 0x8000000000000000);
2309 __ Mov(x0, 0x0);
2322 __ Mov(x0, 0x0);
2335 __ Mov(x0, 0x0);
2348 __ Mov(x0, 0x0);
2357 __ Mov(x0, 0x0);
2366 __ Mov(x0, 0x0);
2372 __ Mov(x0, 0x0);
2392 __ Mov(x29, lr);
2394 __ Mov(x1, 0);
2398 __ Mov(x0, lr);
2399 __ Mov(x1, 42);
2408 __ Mov(x2, 0);
2412 __ Mov(x0, lr);
2413 __ Mov(x2, 84);
2419 __ Mov(x3, lr);
2423 __ Mov(lr, x29);
2443 __ Mov(x28, 0x477d469dec0b8760);
2444 __ Mov(x29, lr);
2446 __ Mov(x1, 0);
2450 __ Mov(x0, lr);
2451 __ Mov(x1, 42);
2460 __ Mov(x2, 0);
2464 __ Mov(x0, lr);
2465 __ Mov(x2, 84);
2472 __ Mov(x3, lr);
2477 __ Mov(lr, x29);
2497 __ Mov(x28, sp);
2498 __ Mov(x29, lr);
2499 __ Mov(sp, 0x477d469dec0b8760);
2501 __ Mov(x0, 0);
2505 __ Mov(x0, 42);
2514 __ Mov(x1, 0);
2518 __ Mov(x1, 84);
2525 __ Mov(sp, x28);
2526 __ Mov(lr, x29);
2544 __ Mov(x28, sp);
2545 __ Mov(x29, lr);
2546 __ Mov(sp, 0x477d469dec0b8760);
2548 __ Mov(x0, 0);
2552 __ Mov(x0, 42);
2561 __ Mov(x1, 0);
2565 __ Mov(x1, 84);
2572 __ Mov(sp, x28);
2573 __ Mov(lr, x29);
2597 __ Mov(x29, lr);
2602 __ Mov(x0, lr);
2614 __ Mov(lr, x29);
2631 __ Mov(x28, sp);
2632 __ Mov(x29, lr);
2633 __ Mov(sp, 0x477d469dec0b8760);
2649 __ Mov(sp, x28);
2650 __ Mov(lr, x29);
2666 __ Mov(x29, lr);
2668 __ Mov(x1, 0);
2672 __ Mov(x0, lr);
2673 __ Mov(x1, 42);
2682 __ Mov(x2, 0);
2686 __ Mov(x0, lr);
2687 __ Mov(x2, 84);
2694 __ Mov(x3, lr);
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);
2730 __ Mov(x0, 1);
2737 __ Mov(x1, 1);
2744 __ Mov(x2, 1);
2751 __ Mov(x3, 1);
2754 __ Mov(x18, 0xffffffff00000000);
2760 __ Mov(x4, 1);
2767 __ Mov(x5, 1);
2789 __ Mov(x0, 0);
2790 __ Mov(x1, 0);
2791 __ Mov(x2, 0);
2792 __ Mov(x3, 0);
2793 __ Mov(x16, 0xaaaaaaaaaaaaaaaa);
2799 __ Mov(x0, 1);
2806 __ Mov(x1, 1);
2813 __ Mov(x2, 1);
2820 __ Mov(x3, 1);
2841 __ Mov(x0, 0x0);
2842 __ Mov(x10, 0x7);
2843 __ Mov(x11, 0x0);
2876 __ Mov(x0, 0x1);
2916 __ Mov(XRegister(i), 0);
2940 __ Mov(base, reinterpret_cast<uint64_t>(&data_ptr[data_size / 2]));
2951 __ Mov(XRegister(i), tag);
3001 __ Mov(x7, sp);
3002 __ Mov(base_tag, base);
3005 __ Mov(x8, 11UL << tag_lsb);
3006 __ Mov(sp, x8);
3044 __ Mov(sp, x7);
3114 __ Mov(XRegister(i), 0);
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);
3178 __ Mov(sp, base);
3199 __ Mov(sp, base);
3220 __ Mov(sp, base);
3224 __ Mov(sp, x0);
3265 __ Mov(x17, src_base);
3266 __ Mov(x18, dst_base);
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);
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);
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);
3477 __ Mov(x19, drifted_addr);
3480 __ Mov(x20, base_addr);
3483 __ Mov(x21, drifted_addr);
3486 __ Mov(x22, base_addr + 16);
3514 __ Mov(x24, src_base);
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.
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]));
3644 __ Mov(x16, src_base);
3674 __ Mov(x16, src_base);
3675 __ Mov(x17, dst_base);
3676 __ Mov(x18, src_base + 24);
3677 __ Mov(x19, dst_base + 56);
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);
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);
3864 __ Mov(x16, src_base);
3865 __ Mov(x17, dst_base);
3866 __ Mov(x18, dst_base + 16);
3868 __ Mov(x19, x16);
3871 __ Mov(x20, x17);
3874 __ Mov(x21, x16);
3877 __ Mov(x22, x18);
3922 __ Mov(x24, src_base - base_offset);
3923 __ Mov(x25, dst_base + base_offset);
3924 __ Mov(x18, dst_base + base_offset + 16);
3926 __ Mov(x19, x24);
3927 __ Mov(x24, src_base - base_offset + 4);
3930 __ Mov(x20, x25);
3931 __ Mov(x25, dst_base + base_offset + 4);
3932 __ Mov(x24, src_base - base_offset);
3935 __ Mov(x21, x24);
3936 __ Mov(x24, src_base - base_offset + 8);
3939 __ Mov(x22, x18);
3940 __ Mov(x18, dst_base + base_offset + 16 + 8);
3983 __ Mov(x16, src_base);
3984 __ Mov(x17, dst_base);
3985 __ Mov(x18, dst_base + 16);
3987 __ Mov(x19, x16);
3990 __ Mov(x20, x17);
3993 __ Mov(x21, x16);
3996 __ Mov(x22, x18);
4042 __ Mov(x24, src_base);
4043 __ Mov(x25, dst_base);
4044 __ Mov(x18, dst_base + 16);
4046 __ Mov(x19, x24);
4050 __ Mov(x20, x25);
4055 __ Mov(x21, x24);
4059 __ Mov(x22, x18);
4098 __ Mov(x24, src_base);
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);
4164 __ Mov(x17, src_base);
4165 __ Mov(x18, dst_base);
4291 __ Mov(x0, 0);
4295 __ Mov(tgt1, values[i]);
4536 __ Mov(x0, 0x0123456789abcdef);
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);
4708 __ Mov(x0, 0x0123456789abcdef);
4843 __ Mov(x0, 0x0);
4844 __ Mov(x1, 0x1111);
4845 __ Mov(x2, 0xffffffffffffffff);
4846 __ Mov(x3, 0x8000000000000000);
4899 __ Mov(x0, 0x0);
4900 __ Mov(x1, 0x1);
4938 __ Mov(x0, 0);
4939 __ Mov(x1, 0x0123456789abcdef);
4940 __ Mov(x2, 0xfedcba9876543210);
4941 __ Mov(x3, 0xffffffffffffffff);
4990 __ Mov(x0, 0);
4991 __ Mov(x1, 0x0123456789abcdef);
4992 __ Mov(x2, 0xfedcba9876543210);
4993 __ Mov(w3, 0x80);
5060 __ Mov(x0, 0);
5061 __ Mov(x1, 4687);
5062 __ Mov(x2, 0x1122334455667788);
5063 __ Mov(w3, 0x11223344);
5064 __ Mov(w4, 400000);
5105 __ Mov(x0, 0);
5106 __ Mov(x1, 0);
5107 __ Mov(x2, 0);
5163 __ Mov(x0, 0xf123456789abcdef);
5218 __ Mov(left_reg, left);
5219 __ Mov(right_reg, right);
5220 __ Mov(x10, (carry ? CFlag : NoFlag));
5621 __ Mov(x0, 0);
5622 __ Mov(x1, 1);
5623 __ Mov(x2, 0x0123456789abcdef);
5624 __ Mov(x3, 0xfedcba9876543210);
5625 __ Mov(x4, 0xffffffffffffffff);
5695 __ Mov(x0, 0);
5696 __ Mov(x1, 1);
5697 __ Mov(x2, 0x0123456789abcdef);
5745 __ Mov(x0, 0xff);
5746 __ Mov(x1, 0xffffffffffffffff);
5759 __ Mov(x0, 0x7fffffffffffffff);
5760 __ Mov(x1, 1);
5773 __ Mov(x0, 0x7fffffffffffffff);
5791 __ Mov(x0, 0);
5838 __ Mov(x0, 0x0123456789abcdef);
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);
5937 __ Mov(x0, 0);
5938 __ Mov(x1, 0x1111111111111111);
5961 __ Mov(x0, 0);
5972 __ Mov(w0, 0);
5983 __ Mov(x0, 0);
5984 __ Mov(x1, 0x1111111111111111);
5995 __ Mov(w0, 0);
5996 __ Mov(w1, 0x11111111);
6007 __ Mov(x1, 0x1111111111111111);
6018 __ Mov(w1, 0x11111111);
6029 __ Mov(x0, 1);
6030 __ Mov(x1, 0x7fffffffffffffff);
6041 __ Mov(w0, 1);
6042 __ Mov(w1, 0x7fffffff);
6053 __ Mov(x0, 1);
6054 __ Mov(x1, 0xffffffffffffffff);
6065 __ Mov(w0, 1);
6066 __ Mov(w1, 0xffffffff);
6077 __ Mov(w0, 0);
6078 __ Mov(w1, 1);
6091 __ Mov(w0, 0);
6092 __ Mov(w1, 0);
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);
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);
6217 __ Mov(w16, 0);
6218 __ Mov(w17, 1);
6268 __ Mov(w20, 0);
6292 __ Mov(w20, 0x2);
6293 __ Mov(w21, 0x1);
6294 __ Mov(x22, 0xffffffffffffffff);
6295 __ Mov(x23, 0xff);
6296 __ Mov(x24, 0xfffffffffffffffe);
6335 __ Mov(x16, 0);
6336 __ Mov(x24, 0x0000000f0000000f);
6337 __ Mov(x25, 0x0000001f0000001f);
6401 __ Mov(x15, 0x0);
6402 __ Mov(x16, 0x0000001f0000002f);
6469 __ Mov(x10, 0);
6495 __ Mov(x18, 0);
6496 __ Mov(x19, 0x80000000);
6497 __ Mov(x20, 0x8000000000000000);
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]);
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]);
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]);
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]);
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);
6819 __ Mov(x1, 0x0123456789abcdef);
6820 __ Mov(x2, 0xfedcba9876543210);
6881 __ Mov(x1, 0x0123456789abcdef);
6882 __ Mov(x2, 0xfedcba9876543210);
6884 __ Mov(x10, 0x8888888888888888);
6885 __ Mov(x11, 0x8888888888888888);
6937 __ Mov(x1, 0x0123456789abcdef);
6938 __ Mov(x2, 0xfedcba9876543210);
6972 __ Mov(w0, 0);
6973 __ Mov(w1, 1);
6974 __ Mov(w2, 0x80000000);
7048 __ Mov(w0, 1);
7116 __ Mov(x0, i << Flags_offset);
7144 __ Mov(w0, 0);
7145 __ Mov(w1, 0x7fffffff);
7147 __ Mov(x7, 0);
7149 __ Mov(x10, NVFlag);
7158 __ Mov(x10, ZCFlag);
7171 __ Mov(x8, fpcr_core);
7190 __ Mov(x9, fpcr_all);
7199 __ Mov(x10, ~fpcr_all);
7235 __ Mov(x20, sp);
7238 __ Mov(x16, 0x477d469dec0b8760);
7239 __ Mov(sp, 0x477d469dec0b8760);
7242 __ Mov(x17, 0x0000000012345678);
7244 __ Mov(x0, x17);
7246 __ Mov(lr, 0x0000000012345678);
7248 __ Mov(x1, lr);
7250 __ Mov(lr, 0x0000000012345678);
7252 __ Mov(x2, lr);
7255 __ Mov(x17, x0);
7257 __ Mov(x3, x17);
7259 __ Mov(lr, x1);
7261 __ Mov(x4, lr);
7263 __ Mov(lr, x2);
7265 __ Mov(x5, lr);
7268 __ Mov(x17, x1);
7270 __ Mov(x6, x17);
7272 __ Mov(lr, x0);
7274 __ Mov(x7, lr);
7276 __ Mov(lr, x1);
7278 __ Mov(x8, lr);
7281 __ Mov(lr, x0);
7283 __ Mov(x9, lr);
7286 __ Mov(sp, x20);
7335 __ Mov(x20, sp);
7338 __ Mov(x16, 0x477d469dec0b8760);
7339 __ Mov(sp, 0x477d469dec0b8760);
7342 __ Mov(x17, 0x0000000012345678);
7344 __ Mov(x0, x17);
7346 __ Mov(lr, 0x0000000012345678);
7348 __ Mov(x1, lr);
7350 __ Mov(lr, 0x0000000012345678);
7352 __ Mov(x2, lr);
7355 __ Mov(x17, x0);
7357 __ Mov(x3, x17);
7359 __ Mov(lr, x1);
7361 __ Mov(x4, lr);
7363 __ Mov(lr, x2);
7365 __ Mov(x5, lr);
7368 __ Mov(x17, x1);
7370 __ Mov(x6, x17);
7372 __ Mov(lr, x0);
7374 __ Mov(x7, lr);
7376 __ Mov(lr, x1);
7378 __ Mov(x8, lr);
7381 __ Mov(lr, x0);
7383 __ Mov(x9, lr);
7386 __ Mov(sp, x20);
7694 __ Mov(x0, 0); // 'Normal' instruction sets BTYPE to zero.
7725 __ Mov(x30, sp);
7728 __ Mov(x0, 0);
7729 __ Mov(x1, literal_base);
7771 __ Mov(x29, x30);
7772 __ Mov(x30, sp);
7773 __ Mov(sp, x29);
7795 __ Mov(x30, sp);
7798 __ Mov(x0, 0);
7799 __ Mov(x1, literal_base);
7848 __ Mov(x29, x30);
7849 __ Mov(x30, sp);
7850 __ Mov(sp, x29);
7903 __ Mov(x0, literal_base);
7965 __ Mov(x0, literal_base);
8044 __ Mov(x0, literal_base);
8097 __ Mov(x0, literal_base);
8113 __ Mov(x4, __ StackPointer());
8127 __ Mov(sp, __ StackPointer());
8172 __ Mov(x1, base);
8195 __ Mov(x1, base_d);
8263 __ Mov(x1, base);
8280 __ Mov(reg_base, reinterpret_cast<uintptr_t>(&array));
8292 __ Mov(reg_index, size_stored);
8301 __ Mov(reg_index, size_stored);
8316 __ Mov(reg_index, size_stored);
8420 __ Mov(stack_pointer, __ StackPointer());
8429 __ Mov(x[i], literal_base * i);
8495 __ Mov(sp, __ StackPointer());
8668 __ Mov(stack_pointer, __ StackPointer());
8674 __ Mov(x0, 0);
8675 __ Mov(x1, literal_base);
8747 __ Mov(sp, __ StackPointer());
8909 __ Mov(stack_pointer, __ StackPointer());
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);
8936 __ Mov(sp, __ StackPointer());
9016 __ Mov(stack_pointer, __ StackPointer());
9023 __ Mov(x[i], literal_base * i);
9127 __ Mov(sp, __ StackPointer());
9186 __ Mov(x3, 0x3333333333333333);
9187 __ Mov(x2, 0x2222222222222222);
9188 __ Mov(x1, 0x1111111111111111);
9189 __ Mov(x0, 0x0000000000000000);
9281 __ Mov(x29, __ StackPointer());
9284 __ Mov(x0, 1234);
9285 __ Mov(x1, 0x1234);
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);
9304 __ Mov(x28, 0x123456789abcdef);
9308 __ Mov(x10, 3);
9309 __ Mov(x11, 40);
9310 __ Mov(x12, 500);
9313 __ Mov(w13, 'x');
9342 __ Mov(x29, old_stack_pointer);
9348 __ Mov(old_stack_pointer, __ StackPointer());
9390 __ Mov(x19, x0);
9393 __ Mov(x0, 1234);
9394 __ Mov(x1, 0x1234);
9396 __ Mov(x20, x0);
9401 __ Mov(x21, x0);
9404 __ Mov(x2, reinterpret_cast<uintptr_t>(test_substring));
9406 __ Mov(x22, x0);
9409 __ Mov(w3, 0xffffffff);
9410 __ Mov(w4, 0xffffffff);
9411 __ Mov(x5, 0xffffffffffffffff);
9412 __ Mov(x6, 0xffffffffffffffff);
9420 __ Mov(x23, x0);
9427 __ Mov(x24, x0);
9430 __ Mov(x28, 0x123456789abcdef);
9432 __ Mov(x25, x0);
9436 __ Mov(x26, x0);
9440 __ Mov(x29, old_stack_pointer);
9447 __ Mov(x27, x0);
9448 __ Mov(old_stack_pointer, __ StackPointer());
9452 __ Mov(x3, 3);
9453 __ Mov(x4, 40);
9454 __ Mov(x5, 500);
9456 __ Mov(x28, x0);
9459 __ Mov(w3, 0xffffffff);
9461 __ Mov(x5, 0xffffffffffffffff);
9468 __ Mov(x29, x0);
9559 __ Mov(x0, 0x0);
9563 __ Mov(x0, 0xdeadbeef);
9567 __ Mov(x0, 0xc001c0de);
9650 __ Mov(x10, reinterpret_cast<uintptr_t>(&b[1]));
9655 __ Mov(x10, reinterpret_cast<uintptr_t>(&h[1]));
9660 __ Mov(x10, reinterpret_cast<uintptr_t>(&w[1]));
9665 __ Mov(x10, reinterpret_cast<uintptr_t>(&x[1]));
9704 __ Mov(x10, reinterpret_cast<uintptr_t>(&b[1]));
9709 __ Mov(x10, reinterpret_cast<uintptr_t>(&h[1]));
9714 __ Mov(x10, reinterpret_cast<uintptr_t>(&w[1]));
9719 __ Mov(x10, reinterpret_cast<uintptr_t>(&x[1]));
9768 __ Mov(x10, reinterpret_cast<uintptr_t>(&b[1]));
9776 __ Mov(x10, reinterpret_cast<uintptr_t>(&h[1]));
9784 __ Mov(x10, reinterpret_cast<uintptr_t>(&w[1]));
9792 __ Mov(x10, reinterpret_cast<uintptr_t>(&x[1]));
9800 __ Mov(x10, reinterpret_cast<uintptr_t>(&wp[1]));
9809 __ Mov(x10, reinterpret_cast<uintptr_t>(&xp[1]));
9869 __ Mov(x10, reinterpret_cast<uintptr_t>(&b[1]));
9877 __ Mov(x10, reinterpret_cast<uintptr_t>(&h[1]));
9885 __ Mov(x10, reinterpret_cast<uintptr_t>(&w[1]));
9893 __ Mov(x10, reinterpret_cast<uintptr_t>(&x[1]));
9901 __ Mov(x10, reinterpret_cast<uintptr_t>(&wp[1]));
9910 __ Mov(x10, reinterpret_cast<uintptr_t>(&xp[1]));
9957 __ Mov(x10, reinterpret_cast<uintptr_t>(data_aligned));
9958 __ Mov(w6, 0);
10065 __ Mov(x10, reinterpret_cast<uintptr_t>(data_aligned));
10066 __ Mov(x11, kWatchdog);
10149 __ Mov(x10, reinterpret_cast<uintptr_t>(data_aligned));
10150 __ Mov(x11, kWatchdog);
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);
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);
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);
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);
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);
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);
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));
11116 __ Mov(x20, data_base);
11117 __ Mov(x21, data_base + 2 * sizeof(data[0]));
11162 __ Mov(x20, data_base);
11163 __ Mov(x21, data_base + 2 * sizeof(data[0]));
11220 __ Mov(x0, 0x0011223344556677);
11221 __ Mov(x20, data_base);
11222 __ Mov(x21, data_base + 2 * sizeof(data[0]));
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);
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)); \
11619 __ Mov(x0, reinterpret_cast<uintptr_t>(data_aligned));
11630 __ Mov(x0, reinterpret_cast<uintptr_t>(data_aligned));
11669 __ Mov(x0, src_tagged);
11670 __ Mov(x1, dst_tagged);
11889 __ Mov(x0, src_tagged - preindex);
11890 __ Mov(x1, dst_tagged - preindex);
12056 __ Mov(x0, src_tagged);
12057 __ Mov(x1, dst_tagged);
12224 __ Mov(x0, src_tagged);
12225 __ Mov(x1, dst_tagged);
12227 __ Mov(x10, offset_base + data_length);
12235 __ Mov(x10, offset_base + data_length);
12243 __ Mov(x10, offset_base + data_length);
12251 __ Mov(x10, offset_base + data_length);
12259 __ Mov(x10, offset_base + data_length);
12267 __ Mov(x10, offset_base + data_length);
12275 __ Mov(x10, offset_base + data_length);
12283 __ Mov(x10, offset_base + data_length);
12327 __ Mov(x10, src_tagged);
12328 __ Mov(x11, offset_tagged);
12350 __ Mov(x1, 0);
12381 __ Mov(x1, 0);
12417 __ Mov(x1, 0);
12458 __ Mov(x4, msg_addr);
12460 __ Mov(x3, x4);
12462 __ Mov(x2, x3);
12464 __ Mov(x1, x2);
12481 __ Mov(x11, msg_addr);
12497 __ Mov(x20, msg_addr);
12499 __ Mov(x21, msg_addr);
12501 __ Mov(x22, msg_addr);
12521 __ Mov(x20, msg_addr);
12537 __ Mov(x20, msg_addr);
12553 __ Mov(x20, msg_addr);
12576 __ Mov(w0, 0);
12577 __ Mov(w1, 0);
12580 __ Mov(w0, 0x1);
12581 __ Mov(w1, 0x138);
12584 __ Mov(w0, 0x1);
12585 __ Mov(w1, 0x38);
12588 __ Mov(w0, 0);
12589 __ Mov(w1, 128);
12592 __ Mov(w0, UINT32_MAX);
12593 __ Mov(w1, 255);
12596 __ Mov(w0, 0x00010001);
12597 __ Mov(w1, 0x10001000);
12620 __ Mov(w0, 0);
12621 __ Mov(w1, 0);
12624 __ Mov(w0, 0x1);
12625 __ Mov(w1, 0x10038);
12628 __ Mov(w0, 0x1);
12629 __ Mov(w1, 0x38);
12632 __ Mov(w0, 0);
12633 __ Mov(w1, 128);
12636 __ Mov(w0, UINT32_MAX);
12637 __ Mov(w1, 255);
12640 __ Mov(w0, 0x00010001);
12641 __ Mov(w1, 0x10001000);
12664 __ Mov(w0, 0);
12665 __ Mov(w1, 0);
12668 __ Mov(w0, 0x1);
12669 __ Mov(w1, 0x80000031);
12672 __ Mov(w0, 0);
12673 __ Mov(w1, 128);
12676 __ Mov(w0, UINT32_MAX);
12677 __ Mov(w1, 255);
12680 __ Mov(w0, 0x00010001);
12681 __ Mov(w1, 0x10001000);
12703 __ Mov(w0, 0);
12704 __ Mov(x1, 0);
12707 __ Mov(w0, 0x1);
12708 __ Mov(x1, UINT64_C(0x0000000800000031));
12711 __ Mov(w0, 0);
12712 __ Mov(x1, 128);
12715 __ Mov(w0, UINT32_MAX);
12716 __ Mov(x1, 255);
12719 __ Mov(w0, 0x00010001);
12720 __ Mov(x1, UINT64_C(0x1000100000000000));
12742 __ Mov(w0, 0);
12743 __ Mov(w1, 0);
12746 __ Mov(w0, 0x1);
12747 __ Mov(w1, 0x138);
12750 __ Mov(w0, 0x1);
12751 __ Mov(w1, 0x38);
12754 __ Mov(w0, 0);
12755 __ Mov(w1, 128);
12758 __ Mov(w0, UINT32_MAX);
12759 __ Mov(w1, 255);
12762 __ Mov(w0, 0x00010001);
12763 __ Mov(w1, 0x10001000);
12786 __ Mov(w0, 0);
12787 __ Mov(w1, 0);
12790 __ Mov(w0, 0x1);
12791 __ Mov(w1, 0x10038);
12794 __ Mov(w0, 0x1);
12795 __ Mov(w1, 0x38);
12798 __ Mov(w0, 0);
12799 __ Mov(w1, 128);
12802 __ Mov(w0, UINT32_MAX);
12803 __ Mov(w1, 255);
12806 __ Mov(w0, 0x00010001);
12807 __ Mov(w1, 0x10001000);
12830 __ Mov(w0, 0);
12831 __ Mov(w1, 0);
12834 __ Mov(w0, 0x1);
12835 __ Mov(w1, 0x80000031);
12838 __ Mov(w0, 0);
12839 __ Mov(w1, 128);
12842 __ Mov(w0, UINT32_MAX);
12843 __ Mov(w1, 255);
12846 __ Mov(w0, 0x00010001);
12847 __ Mov(w1, 0x10001000);
12869 __ Mov(w0, 0);
12870 __ Mov(x1, 0);
12873 __ Mov(w0, 0x1);
12874 __ Mov(x1, UINT64_C(0x0000000800000031));
12877 __ Mov(w0, 0);
12878 __ Mov(x1, 128);
12881 __ Mov(w0, UINT32_MAX);
12882 __ Mov(x1, 255);
12885 __ Mov(w0, 0x00010001);
12886 __ Mov(x1, UINT64_C(0x1000100000000000));
12907 __ Mov(x0, 0x3d720c8d);
12928 __ Mov(base, base_address);
12929 __ Mov(offset, reg_offset);
12989 __ Mov(x0, 0);
12990 __ Mov(x1, 1);
12991 __ Mov(x10, 0);
13032 __ Mov(x1, 0);
13053 __ Mov(x0, 0);
13054 __ Mov(x1, 1);
13055 __ Mov(x10, 0);
13072 __ Mov(x0, 1);
13076 __ Mov(x1, 0);
13105 __ Mov(x0, 0);
13106 __ Mov(x1, 1);
13107 __ Mov(x10, 0);
13141 __ Mov(x1, 0);
13555 __ Mov(data_32, data_32_address);
13556 __ Mov(data_64, data_64_address);
13702 __ Mov(w0, 0);
13704 __ Mov(w20, w0);
13712 __ Mov(x0, 0x123);
13715 __ Mov(x21, x0);
13726 __ Mov(w0, 0);
13728 __ Mov(w0, 0);
13736 __ Mov(x22, 0);
13737 __ Mov(w0, 123);
13740 __ Mov(x22, 0xbad);
13749 __ Mov(w23, w0);
13751 __ Mov(x24, 0);
13764 __ Mov(w0, x);
13769 __ Mov(w0, x);
13774 __ Mov(w0, x);
13779 __ Mov(w0, x);
13788 __ Mov(x0, reinterpret_cast<uint64_t>(&value));
13791 __ Mov(w0, 0);
13793 __ Mov(w25, w0);
13827 __ Mov(x16, reinterpret_cast<uint64_t>(func)); \
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);
13892 __ Mov(x0, x0);
13894 __ Mov(w0, w0, kDiscardForSameWReg);
13896 __ Mov(w0, w0);
13924 __ Mov(x0, 0x5555000055555555);
13943 __ Mov(x20, sp); // Store original sp.
13948 __ Mov(sp, x20); // Restore original sp.
13953 __ Mov(sp, x20); // Restore sp (should be no-op)
13956 __ Mov(sp, x20); // Restore sp.
13981 __ Mov(x0, 0x5555555555555555);
13982 __ Mov(x1, -42);
14006 __ Mov(x2, 0x20); // Exclude tag 5.
14029 __ Mov(x0, 0xaaaa);
14030 __ Mov(x20, 0x12345678);
14066 __ Mov(x10, 8);
14067 __ Mov(x0, 0x5555555555555555);
14084 __ Mov(x1, 1);
14091 __ Mov(x3, 0);
14092 __ Mov(x10, 128);
14093 __ Mov(x11, 0xaaaa);
14104 __ Mov(x3, 0xffffffffffffffff);
14125 __ Mov(x0, dst_addr);
14127 __ Mov(x2, 13);
14128 __ Mov(x3, 0x1234aa);
14142 __ Mov(x2, 1);
14169 __ Mov(x0, dst_addr);
14170 __ Mov(x1, x0);
14171 __ Mov(x2, 16);
14172 __ Mov(x3, 0x42);
14210 __ Mov(x0, reinterpret_cast<uint64_t>(dst_addr));
14213 __ Mov(x2, 16);
14214 __ Mov(x3, 0x42);
14221 __ Mov(x0, reinterpret_cast<uint64_t>(dst_addr));
14251 __ Mov(x0, buf_addr);
14254 __ Mov(x2, x0); // src = &buf[0]
14256 __ Mov(x4, 8); // count = 8
14264 __ Mov(x5, x0); // src = &buf[0]
14266 __ Mov(x7, 8); // count = 8
14303 __ Mov(x0, buf_addr);
14306 __ Mov(x3, x0); // dst = &buf[0]
14307 __ Mov(x4, 15); // count = 15
14312 __ Mov(x6, x0); // dst = &buf[0]
14313 __ Mov(x4, 15); // count = 15
14318 __ Mov(x8, x0); // dst = &buf[0]
14319 __ Mov(x4, 15); // count = 15
14359 __ Mov(x0, buf_addr);
14362 __ Mov(x2, x0); // src = &buf[0]
14364 __ Mov(x4, 8); // count = 8
14370 __ Mov(x5, x0); // src = &buf[0]
14372 __ Mov(x7, 8); // count = 8
14413 __ Mov(x0, buf_addr);
14416 __ Mov(x3, x0); // dst = &buf[0]
14417 __ Mov(x4, 15); // count = 15
14422 __ Mov(x6, x0); // dst = &buf[0]
14423 __ Mov(x4, 15); // count = 15
14428 __ Mov(x8, x0); // dst = &buf[0]
14429 __ Mov(x4, 15); // count = 15
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);
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);
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);
14634 __ Mov(x0, a);
14635 __ Mov(x1, b);
14893 __ Mov(x0, base);
14894 __ Mov(x1, limit);
14895 __ Mov(x2, sp);
14898 __ Mov(x10, 42);
14902 __ Mov(sp, x2);
14918 __ Mov(x1, limit);
14919 __ Mov(x2, sp);
14923 __ Mov(w10, 42);
14926 __ Mov(sp, x2);
14941 __ Mov(x1, limit);
14942 __ Mov(x2, sp);
14946 __ Mov(w10, 42);
14949 __ Mov(sp, x2);
14964 __ Mov(x0, base);
14967 __ Mov(x10, 42);
14983 __ Mov(x0, base);
14986 __ Mov(x10, 42);
15007 __ Mov(x0, v0.V2D(), 1);