Lines Matching refs:__
56 __ Mov(x17, src_base);
57 __ Mov(x18, dst_base);
58 __ Mov(x19, src_base);
59 __ Mov(x20, dst_base);
60 __ Mov(x21, src_base);
61 __ Mov(x22, dst_base);
62 __ Ldr(s0, MemOperand(x17, sizeof(src[0])));
63 __ Str(s0, MemOperand(x18, sizeof(dst[0]), PostIndex));
64 __ Ldr(s1, MemOperand(x19, sizeof(src[0]), PostIndex));
65 __ Str(s1, MemOperand(x20, 2 * sizeof(dst[0]), PreIndex));
66 __ Ldr(s2, MemOperand(x21, 2 * sizeof(src[0]), PreIndex));
67 __ Str(s2, MemOperand(x22, sizeof(dst[0])));
98 __ Mov(x17, src_base);
99 __ Mov(x18, dst_base);
100 __ Mov(x19, src_base);
101 __ Mov(x20, dst_base);
102 __ Mov(x21, src_base);
103 __ Mov(x22, dst_base);
104 __ Ldr(d0, MemOperand(x17, sizeof(src[0])));
105 __ Str(d0, MemOperand(x18, sizeof(dst[0]), PostIndex));
106 __ Ldr(d1, MemOperand(x19, sizeof(src[0]), PostIndex));
107 __ Str(d1, MemOperand(x20, 2 * sizeof(dst[0]), PreIndex));
108 __ Ldr(d2, MemOperand(x21, 2 * sizeof(src[0]), PreIndex));
109 __ Str(d2, MemOperand(x22, sizeof(dst[0])));
139 __ Mov(x16, src_base);
140 __ Mov(x17, dst_base);
141 __ Ldp(s31, s0, MemOperand(x16, 2 * sizeof(src[0]), PostIndex));
142 __ Stp(s0, s31, MemOperand(x17, sizeof(dst[1]), PreIndex));
168 __ Mov(x16, src_base);
169 __ Mov(x17, dst_base);
170 __ Ldp(d31, d0, MemOperand(x16, 2 * sizeof(src[0]), PostIndex));
171 __ Stp(d0, d31, MemOperand(x17, sizeof(dst[1]), PreIndex));
196 __ Mov(x16, src_base);
197 __ Mov(x17, dst_base);
198 __ Mov(x18, src_base + 12);
199 __ Mov(x19, dst_base + 24);
202 __ Dmb(InnerShareable, BarrierAll);
204 __ Ldnp(s0, s1, MemOperand(x16));
205 __ Ldnp(s2, s3, MemOperand(x16, 4));
206 __ Ldnp(s5, s4, MemOperand(x18, -8));
207 __ Stnp(s1, s0, MemOperand(x17));
208 __ Stnp(s3, s2, MemOperand(x17, 8));
209 __ Stnp(s4, s5, MemOperand(x19, -8));
244 __ Mov(x16, src_base);
245 __ Mov(x17, dst_base);
246 __ Mov(x18, src_base + 24);
247 __ Mov(x19, dst_base + 48);
250 __ Dmb(InnerShareable, BarrierAll);
252 __ Ldnp(d0, d1, MemOperand(x16));
253 __ Ldnp(d2, d3, MemOperand(x16, 8));
254 __ Ldnp(d5, d4, MemOperand(x18, -16));
255 __ Stnp(d1, d0, MemOperand(x17));
256 __ Stnp(d3, d2, MemOperand(x17, 16));
257 __ Stnp(d4, d5, MemOperand(x19, -16));
292 __ Mov(x0, 0);
296 __ Mov(tgt1,
298 __ Ldr(fp_tgt, values[i]);
299 __ Fmov(tgt2, fp_tgt);
300 __ Cmp(tgt1, tgt2);
301 __ Cset(x0, ne);
331 __ Fmov(s1, 255.0);
332 __ Fmov(d2, 12.34567);
333 __ Fmov(s3, 0.0);
334 __ Fmov(d4, 0.0);
335 __ Fmov(s5, kFP32PositiveInfinity);
336 __ Fmov(d6, kFP64NegativeInfinity);
337 __ Fmov(h7, RawbitsToFloat16(0x6400U));
338 __ Fmov(h8, kFP16PositiveInfinity);
339 __ Fmov(s11, 1.0);
340 __ Fmov(h12, RawbitsToFloat16(0x7BFF));
341 __ Fmov(h13, RawbitsToFloat16(0x57F2));
342 __ Fmov(d22, -13.0);
343 __ Fmov(h23, RawbitsToFloat16(0xC500U));
344 __ Fmov(h24, Float16(-5.0));
345 __ Fmov(h25, Float16(2049.0));
346 __ Fmov(h21, RawbitsToFloat16(0x6404U));
347 __ Fmov(h26, RawbitsToFloat16(0x0U));
348 __ Fmov(h27, RawbitsToFloat16(0x7e00U));
383 __ Fmov(h3, RawbitsToFloat16(0xCA80U));
384 __ Fmov(h7, h3);
385 __ Fmov(h8, -5.0);
386 __ Fmov(w3, h8);
387 __ Fmov(h9, w3);
388 __ Fmov(h8, Float16(1024.0));
389 __ Fmov(x4, h8);
390 __ Fmov(h10, x4);
391 __ Fmov(s20, 1.0);
392 __ Fmov(w10, s20);
393 __ Fmov(s30, w10);
394 __ Fmov(s5, s20);
395 __ Fmov(d1, -13.0);
396 __ Fmov(x1, d1);
397 __ Fmov(d2, x1);
398 __ Fmov(d4, d1);
399 __ Fmov(d6, RawbitsToDouble(0x0123456789abcdef));
400 __ Fmov(s6, s6);
401 __ Fmov(d0, 0.0);
402 __ Fmov(v0.D(), 1, x1);
403 __ Fmov(x2, v0.D(), 1);
404 __ Fmov(v3.D(), 1, x4);
405 __ Fmov(v3.D(), 0, x1);
406 __ Fmov(x5, v1.D(), 0);
436 __ Fmov(s14, -0.0f);
437 __ Fmov(s15, kFP32PositiveInfinity);
438 __ Fmov(s16, kFP32NegativeInfinity);
439 __ Fmov(s17, 3.25f);
440 __ Fmov(s18, 1.0f);
441 __ Fmov(s19, 0.0f);
443 __ Fmov(d26, -0.0);
444 __ Fmov(d27, kFP64PositiveInfinity);
445 __ Fmov(d28, kFP64NegativeInfinity);
446 __ Fmov(d29, 0.0);
447 __ Fmov(d30, -2.0);
448 __ Fmov(d31, 2.25);
450 __ Fadd(s0, s17, s18);
451 __ Fadd(s1, s18, s19);
452 __ Fadd(s2, s14, s18);
453 __ Fadd(s3, s15, s18);
454 __ Fadd(s4, s16, s18);
455 __ Fadd(s5, s15, s16);
456 __ Fadd(s6, s16, s15);
458 __ Fadd(d7, d30, d31);
459 __ Fadd(d8, d29, d31);
460 __ Fadd(d9, d26, d31);
461 __ Fadd(d10, d27, d31);
462 __ Fadd(d11, d28, d31);
463 __ Fadd(d12, d27, d28);
464 __ Fadd(d13, d28, d27);
492 __ Fmov(h14, -0.0f);
493 __ Fmov(h15, kFP16PositiveInfinity);
494 __ Fmov(h16, kFP16NegativeInfinity);
495 __ Fmov(h17, 3.25f);
496 __ Fmov(h18, 1.0);
497 __ Fmov(h19, 0.0f);
498 __ Fmov(h20, 5.0f);
500 __ Fadd(h0, h17, h18);
501 __ Fadd(h1, h18, h19);
502 __ Fadd(h2, h14, h18);
503 __ Fadd(h3, h15, h18);
504 __ Fadd(h4, h16, h18);
505 __ Fadd(h5, h15, h16);
506 __ Fadd(h6, h16, h15);
507 __ Fadd(h7, h20, h20);
528 __ Fmov(s14, -0.0f);
529 __ Fmov(s15, kFP32PositiveInfinity);
530 __ Fmov(s16, kFP32NegativeInfinity);
531 __ Fmov(s17, 3.25f);
532 __ Fmov(s18, 1.0f);
533 __ Fmov(s19, 0.0f);
535 __ Fmov(d26, -0.0);
536 __ Fmov(d27, kFP64PositiveInfinity);
537 __ Fmov(d28, kFP64NegativeInfinity);
538 __ Fmov(d29, 0.0);
539 __ Fmov(d30, -2.0);
540 __ Fmov(d31, 2.25);
542 __ Fsub(s0, s17, s18);
543 __ Fsub(s1, s18, s19);
544 __ Fsub(s2, s14, s18);
545 __ Fsub(s3, s18, s15);
546 __ Fsub(s4, s18, s16);
547 __ Fsub(s5, s15, s15);
548 __ Fsub(s6, s16, s16);
550 __ Fsub(d7, d30, d31);
551 __ Fsub(d8, d29, d31);
552 __ Fsub(d9, d26, d31);
553 __ Fsub(d10, d31, d27);
554 __ Fsub(d11, d31, d28);
555 __ Fsub(d12, d27, d27);
556 __ Fsub(d13, d28, d28);
584 __ Fmov(h14, -0.0f);
585 __ Fmov(h15, kFP16PositiveInfinity);
586 __ Fmov(h16, kFP16NegativeInfinity);
587 __ Fmov(h17, 3.25f);
588 __ Fmov(h18, 1.0f);
589 __ Fmov(h19, 0.0f);
591 __ Fsub(h0, h17, h18);
592 __ Fsub(h1, h18, h19);
593 __ Fsub(h2, h14, h18);
594 __ Fsub(h3, h18, h15);
595 __ Fsub(h4, h18, h16);
596 __ Fsub(h5, h15, h15);
597 __ Fsub(h6, h16, h16);
618 __ Fmov(s14, -0.0f);
619 __ Fmov(s15, kFP32PositiveInfinity);
620 __ Fmov(s16, kFP32NegativeInfinity);
621 __ Fmov(s17, 3.25f);
622 __ Fmov(s18, 2.0f);
623 __ Fmov(s19, 0.0f);
624 __ Fmov(s20, -2.0f);
626 __ Fmov(d26, -0.0);
627 __ Fmov(d27, kFP64PositiveInfinity);
628 __ Fmov(d28, kFP64NegativeInfinity);
629 __ Fmov(d29, 0.0);
630 __ Fmov(d30, -2.0);
631 __ Fmov(d31, 2.25);
633 __ Fmul(s0, s17, s18);
634 __ Fmul(s1, s18, s19);
635 __ Fmul(s2, s14, s14);
636 __ Fmul(s3, s15, s20);
637 __ Fmul(s4, s16, s20);
638 __ Fmul(s5, s15, s19);
639 __ Fmul(s6, s19, s16);
641 __ Fmul(d7, d30, d31);
642 __ Fmul(d8, d29, d31);
643 __ Fmul(d9, d26, d26);
644 __ Fmul(d10, d27, d30);
645 __ Fmul(d11, d28, d30);
646 __ Fmul(d12, d27, d29);
647 __ Fmul(d13, d29, d28);
675 __ Fmov(h14, -0.0f);
676 __ Fmov(h15, kFP16PositiveInfinity);
677 __ Fmov(h16, kFP16NegativeInfinity);
678 __ Fmov(h17, 3.25f);
679 __ Fmov(h18, 2.0f);
680 __ Fmov(h19, 0.0f);
681 __ Fmov(h20, -2.0f);
683 __ Fmul(h0, h17, h18);
684 __ Fmul(h1, h18, h19);
685 __ Fmul(h2, h14, h14);
686 __ Fmul(h3, h15, h20);
687 __ Fmul(h4, h16, h20);
688 __ Fmul(h5, h15, h19);
689 __ Fmul(h6, h19, h16);
710 __ Fmov(h14, -0.0f);
711 __ Fmov(h15, kFP16PositiveInfinity);
712 __ Fmov(h16, kFP16NegativeInfinity);
713 __ Fmov(h17, 3.25f);
714 __ Fmov(h18, 2.0f);
715 __ Fmov(h19, 0.0f);
716 __ Fmov(h20, -2.0f);
718 __ Fnmul(h0, h17, h18);
719 __ Fnmul(h1, h18, h19);
720 __ Fnmul(h2, h14, h14);
721 __ Fnmul(h3, h15, h20);
722 __ Fnmul(h4, h16, h20);
723 __ Fnmul(h5, h15, h19);
724 __ Fnmul(h6, h19, h16);
752 __ Fmov(d0, n);
753 __ Fmov(d1, m);
754 __ Fmov(d2, a);
755 __ Fmadd(d28, d0, d1, d2);
756 __ Fmsub(d29, d0, d1, d2);
757 __ Fnmadd(d30, d0, d1, d2);
758 __ Fnmsub(d31, d0, d1, d2);
834 __ Fmov(s0, n);
835 __ Fmov(s1, m);
836 __ Fmov(s2, a);
837 __ Fmadd(s28, s0, s1, s2);
838 __ Fmsub(s29, s0, s1, s2);
839 __ Fnmadd(s30, s0, s1, s2);
840 __ Fnmsub(s31, s0, s1, s2);
1333 __ Fmov(s14, -0.0f);
1334 __ Fmov(s15, kFP32PositiveInfinity);
1335 __ Fmov(s16, kFP32NegativeInfinity);
1336 __ Fmov(s17, 3.25f);
1337 __ Fmov(s18, 2.0f);
1338 __ Fmov(s19, 2.0f);
1339 __ Fmov(s20, -2.0f);
1341 __ Fmov(d26, -0.0);
1342 __ Fmov(d27, kFP64PositiveInfinity);
1343 __ Fmov(d28, kFP64NegativeInfinity);
1344 __ Fmov(d29, 0.0);
1345 __ Fmov(d30, -2.0);
1346 __ Fmov(d31, 2.25);
1348 __ Fdiv(s0, s17, s18);
1349 __ Fdiv(s1, s18, s19);
1350 __ Fdiv(s2, s14, s18);
1351 __ Fdiv(s3, s18, s15);
1352 __ Fdiv(s4, s18, s16);
1353 __ Fdiv(s5, s15, s16);
1354 __ Fdiv(s6, s14, s14);
1356 __ Fdiv(d7, d31, d30);
1357 __ Fdiv(d8, d29, d31);
1358 __ Fdiv(d9, d26, d31);
1359 __ Fdiv(d10, d31, d27);
1360 __ Fdiv(d11, d31, d28);
1361 __ Fdiv(d12, d28, d27);
1362 __ Fdiv(d13, d29, d29);
1390 __ Fmov(h14, -0.0f);
1391 __ Fmov(h15, kFP16PositiveInfinity);
1392 __ Fmov(h16, kFP16NegativeInfinity);
1393 __ Fmov(h17, 3.25f);
1394 __ Fmov(h18, 2.0f);
1395 __ Fmov(h19, 2.0f);
1396 __ Fmov(h20, -2.0f);
1398 __ Fdiv(h0, h17, h18);
1399 __ Fdiv(h1, h18, h19);
1400 __ Fdiv(h2, h14, h18);
1401 __ Fdiv(h3, h18, h15);
1402 __ Fdiv(h4, h18, h16);
1403 __ Fdiv(h5, h15, h16);
1404 __ Fdiv(h6, h14, h14);
1507 __ Fmov(d0, n);
1508 __ Fmov(d1, m);
1509 __ Fmin(d28, d0, d1);
1510 __ Fmax(d29, d0, d1);
1511 __ Fminnm(d30, d0, d1);
1512 __ Fmaxnm(d31, d0, d1);
1611 __ Fmov(s0, n);
1612 __ Fmov(s1, m);
1613 __ Fmin(s28, s0, s1);
1614 __ Fmax(s29, s0, s1);
1615 __ Fminnm(s30, s0, s1);
1616 __ Fmaxnm(s31, s0, s1);
1713 __ Fmov(s16, 0.0);
1714 __ Fmov(s17, 0.5);
1715 __ Fmov(d18, -0.5);
1716 __ Fmov(d19, -1.0);
1717 __ Mov(x20, 0);
1718 __ Mov(x21, 0x7ff0000000000001); // Double precision NaN.
1719 __ Fmov(d21, x21);
1720 __ Mov(w22, 0x7f800001); // Single precision NaN.
1721 __ Fmov(s22, w22);
1723 __ Cmp(x20, 0);
1724 __ Fccmp(s16, s16, NoFlag, eq);
1725 __ Mrs(x0, NZCV);
1727 __ Cmp(x20, 0);
1728 __ Fccmp(s16, s16, VFlag, ne);
1729 __ Mrs(x1, NZCV);
1731 __ Cmp(x20, 0);
1732 __ Fccmp(s16, s17, CFlag, ge);
1733 __ Mrs(x2, NZCV);
1735 __ Cmp(x20, 0);
1736 __ Fccmp(s16, s17, CVFlag, lt);
1737 __ Mrs(x3, NZCV);
1739 __ Cmp(x20, 0);
1740 __ Fccmp(d18, d18, ZFlag, le);
1741 __ Mrs(x4, NZCV);
1743 __ Cmp(x20, 0);
1744 __ Fccmp(d18, d18, ZVFlag, gt);
1745 __ Mrs(x5, NZCV);
1747 __ Cmp(x20, 0);
1748 __ Fccmp(d18, d19, ZCVFlag, ls);
1749 __ Mrs(x6, NZCV);
1751 __ Cmp(x20, 0);
1752 __ Fccmp(d18, d19, NFlag, hi);
1753 __ Mrs(x7, NZCV);
1758 __ fccmp(s16, s16, NFlag, al);
1760 __ Mrs(x8, NZCV);
1764 __ fccmp(d18, d18, NFlag, nv);
1766 __ Mrs(x9, NZCV);
1768 __ Cmp(x20, 0);
1769 __ Fccmpe(s16, s16, NoFlag, eq);
1770 __ Mrs(x10, NZCV);
1772 __ Cmp(x20, 0);
1773 __ Fccmpe(d18, d19, ZCVFlag, ls);
1774 __ Mrs(x11, NZCV);
1776 __ Cmp(x20, 0);
1777 __ Fccmpe(d21, d21, NoFlag, eq);
1778 __ Mrs(x12, NZCV);
1780 __ Cmp(x20, 0);
1781 __ Fccmpe(s22, s22, NoFlag, eq);
1782 __ Mrs(x13, NZCV);
1810 __ Fmov(h16, Float16(0.0));
1811 __ Fmov(h17, Float16(0.5));
1812 __ Mov(x20, 0);
1813 __ Fmov(h21, kFP16DefaultNaN);
1815 __ Cmp(x20, 0);
1816 __ Fccmp(h16, h16, NoFlag, eq);
1817 __ Mrs(x0, NZCV);
1819 __ Cmp(x20, 0);
1820 __ Fccmp(h16, h16, VFlag, ne);
1821 __ Mrs(x1, NZCV);
1823 __ Cmp(x20, 0);
1824 __ Fccmp(h16, h17, CFlag, ge);
1825 __ Mrs(x2, NZCV);
1827 __ Cmp(x20, 0);
1828 __ Fccmp(h16, h17, CVFlag, lt);
1829 __ Mrs(x3, NZCV);
1834 __ fccmp(h16, h16, NFlag, al);
1836 __ Mrs(x4, NZCV);
1839 __ fccmp(h16, h16, NFlag, nv);
1841 __ Mrs(x5, NZCV);
1843 __ Cmp(x20, 0);
1844 __ Fccmpe(h16, h16, NoFlag, eq);
1845 __ Mrs(x6, NZCV);
1847 __ Cmp(x20, 0);
1848 __ Fccmpe(h16, h21, NoFlag, eq);
1849 __ Mrs(x7, NZCV);
1851 __ Cmp(x20, 0);
1852 __ Fccmpe(h21, h16, NoFlag, eq);
1853 __ Mrs(x8, NZCV);
1855 __ Cmp(x20, 0);
1856 __ Fccmpe(h21, h21, NoFlag, eq);
1857 __ Mrs(x9, NZCV);
1888 __ Fmov(s8, 0.0);
1889 __ Fmov(s9, 0.5);
1890 __ Mov(w18, 0x7f800001); // Single precision NaN.
1891 __ Fmov(s18, w18);
1893 __ Fcmp(s8, s8);
1894 __ Mrs(x0, NZCV);
1895 __ Fcmp(s8, s9);
1896 __ Mrs(x1, NZCV);
1897 __ Fcmp(s9, s8);
1898 __ Mrs(x2, NZCV);
1899 __ Fcmp(s8, s18);
1900 __ Mrs(x3, NZCV);
1901 __ Fcmp(s18, s18);
1902 __ Mrs(x4, NZCV);
1903 __ Fcmp(s8, 0.0);
1904 __ Mrs(x5, NZCV);
1906 __ Fcmp(s8, 255.0);
1908 __ Mrs(x6, NZCV);
1910 __ Fmov(d19, 0.0);
1911 __ Fmov(d20, 0.5);
1912 __ Mov(x21, 0x7ff0000000000001); // Double precision NaN.
1913 __ Fmov(d21, x21);
1915 __ Fcmp(d19, d19);
1916 __ Mrs(x10, NZCV);
1917 __ Fcmp(d19, d20);
1918 __ Mrs(x11, NZCV);
1919 __ Fcmp(d20, d19);
1920 __ Mrs(x12, NZCV);
1921 __ Fcmp(d19, d21);
1922 __ Mrs(x13, NZCV);
1923 __ Fcmp(d21, d21);
1924 __ Mrs(x14, NZCV);
1925 __ Fcmp(d19, 0.0);
1926 __ Mrs(x15, NZCV);
1928 __ Fcmp(d19, 12.3456);
1930 __ Mrs(x16, NZCV);
1932 __ Fcmpe(s8, s8);
1933 __ Mrs(x22, NZCV);
1934 __ Fcmpe(s8, 0.0);
1935 __ Mrs(x23, NZCV);
1936 __ Fcmpe(d19, d19);
1937 __ Mrs(x24, NZCV);
1938 __ Fcmpe(d19, 0.0);
1939 __ Mrs(x25, NZCV);
1940 __ Fcmpe(s18, s18);
1941 __ Mrs(x26, NZCV);
1942 __ Fcmpe(d21, d21);
1943 __ Mrs(x27, NZCV);
1987 __ Fmov(h8, Float16(0.0));
1988 __ Fmov(h9, Float16(0.5));
1989 __ Fmov(h18, kFP16DefaultNaN);
1991 __ Fcmp(h8, h8);
1992 __ Mrs(x0, NZCV);
1993 __ Fcmp(h8, h9);
1994 __ Mrs(x1, NZCV);
1995 __ Fcmp(h9, h8);
1996 __ Mrs(x2, NZCV);
1997 __ Fcmp(h8, h18);
1998 __ Mrs(x3, NZCV);
1999 __ Fcmp(h18, h18);
2000 __ Mrs(x4, NZCV);
2001 __ Fcmp(h8, 0.0);
2002 __ Mrs(x5, NZCV);
2004 __ Fcmp(h8, 255.0);
2006 __ Mrs(x6, NZCV);
2008 __ Fcmpe(h8, h8);
2009 __ Mrs(x22, NZCV);
2010 __ Fcmpe(h8, 0.0);
2011 __ Mrs(x23, NZCV);
2012 __ Fcmpe(h8, h18);
2013 __ Mrs(x24, NZCV);
2014 __ Fcmpe(h18, h8);
2015 __ Mrs(x25, NZCV);
2016 __ Fcmpe(h18, h18);
2017 __ Mrs(x26, NZCV);
2044 __ Mov(x16, 0);
2045 __ Fmov(s16, 1.0);
2046 __ Fmov(s17, 2.0);
2047 __ Fmov(d18, 3.0);
2048 __ Fmov(d19, 4.0);
2050 __ Cmp(x16, 0);
2051 __ Fcsel(s0, s16, s17, eq);
2052 __ Fcsel(s1, s16, s17, ne);
2053 __ Fcsel(d2, d18, d19, eq);
2054 __ Fcsel(d3, d18, d19, ne);
2058 __ fcsel(s4, s16, s17, al);
2059 __ fcsel(d5, d18, d19, nv);
2080 __ Mov(x16, 0);
2081 __ Fmov(h16, Float16(1.0));
2082 __ Fmov(h17, Float16(2.0));
2084 __ Cmp(x16, 0);
2085 __ Fcsel(h0, h16, h17, eq);
2086 __ Fcsel(h1, h16, h17, ne);
2090 __ fcsel(h4, h16, h17, al);
2091 __ fcsel(h5, h16, h17, nv);
2109 __ Fmov(s16, 1.0);
2110 __ Fmov(s17, 0.0);
2111 __ Fmov(s18, kFP32PositiveInfinity);
2112 __ Fmov(d19, 1.0);
2113 __ Fmov(d20, 0.0);
2114 __ Fmov(d21, kFP64PositiveInfinity);
2116 __ Fneg(s0, s16);
2117 __ Fneg(s1, s0);
2118 __ Fneg(s2, s17);
2119 __ Fneg(s3, s2);
2120 __ Fneg(s4, s18);
2121 __ Fneg(s5, s4);
2122 __ Fneg(d6, d19);
2123 __ Fneg(d7, d6);
2124 __ Fneg(d8, d20);
2125 __ Fneg(d9, d8);
2126 __ Fneg(d10, d21);
2127 __ Fneg(d11, d10);
2153 __ Fmov(s16, -1.0);
2154 __ Fmov(s17, -0.0);
2155 __ Fmov(s18, kFP32NegativeInfinity);
2156 __ Fmov(d19, -1.0);
2157 __ Fmov(d20, -0.0);
2158 __ Fmov(d21, kFP64NegativeInfinity);
2160 __ Fabs(s0, s16);
2161 __ Fabs(s1, s0);
2162 __ Fabs(s2, s17);
2163 __ Fabs(s3, s18);
2164 __ Fabs(d4, d19);
2165 __ Fabs(d5, d4);
2166 __ Fabs(d6, d20);
2167 __ Fabs(d7, d21);
2189 __ Fmov(s16, 0.0);
2190 __ Fmov(s17, 1.0);
2191 __ Fmov(s18, 0.25);
2192 __ Fmov(s19, 65536.0);
2193 __ Fmov(s20, -0.0);
2194 __ Fmov(s21, kFP32PositiveInfinity);
2195 __ Fmov(s22, -1.0);
2196 __ Fmov(d23, 0.0);
2197 __ Fmov(d24, 1.0);
2198 __ Fmov(d25, 0.25);
2199 __ Fmov(d26, 4294967296.0);
2200 __ Fmov(d27, -0.0);
2201 __ Fmov(d28, kFP64PositiveInfinity);
2202 __ Fmov(d29, -1.0);
2204 __ Fsqrt(s0, s16);
2205 __ Fsqrt(s1, s17);
2206 __ Fsqrt(s2, s18);
2207 __ Fsqrt(s3, s19);
2208 __ Fsqrt(s4, s20);
2209 __ Fsqrt(s5, s21);
2210 __ Fsqrt(s6, s22);
2211 __ Fsqrt(d7, d23);
2212 __ Fsqrt(d8, d24);
2213 __ Fsqrt(d9, d25);
2214 __ Fsqrt(d10, d26);
2215 __ Fsqrt(d11, d27);
2216 __ Fsqrt(d12, d28);
2217 __ Fsqrt(d13, d29);
2245 __ Fmov(s13, 1.0);
2246 __ Fmov(s14, 1.1);
2247 __ Fmov(s15, 1.5);
2248 __ Fmov(s16, 1.9);
2249 __ Fmov(s17, 2.5);
2250 __ Fmov(s18, -1.5);
2251 __ Fmov(s19, -2.5);
2252 __ Fmov(s20, kFP32PositiveInfinity);
2253 __ Fmov(s21, kFP32NegativeInfinity);
2254 __ Fmov(s22, 0.0);
2255 __ Fmov(s23, -0.0);
2256 __ Fmov(s24, -0.2);
2257 __ Fmov(s25, kFP32DefaultNaN);
2258 __ Fmov(s26, INT32_MIN);
2259 __ Fmov(s27, INT32_MIN + 0x80); // The next representable FP32.
2260 __ Fmov(s28, 0x80000000);
2261 __ Fmov(s29, 0x7fffff80); // The largest int32_t representable as FP32.
2262 __ Fmov(s30, FLT_MIN);
2263 __ Fmov(s31, FLT_MAX);
2265 __ Frint32x(s0, s13);
2266 __ Frint32x(s1, s14);
2267 __ Frint32x(s2, s15);
2268 __ Frint32x(s3, s16);
2269 __ Frint32x(s4, s17);
2270 __ Frint32x(s5, s18);
2271 __ Frint32x(s6, s19);
2272 __ Frint32x(s7, s20);
2273 __ Frint32x(s8, s21);
2274 __ Frint32x(s9, s22);
2275 __ Frint32x(s10, s23);
2276 __ Frint32x(s11, s24);
2277 __ Frint32x(s12, s25);
2278 __ Frint32x(s13, s26);
2279 __ Frint32x(s14, s27);
2280 __ Frint32x(s15, s28);
2281 __ Frint32x(s16, s29);
2282 __ Frint32x(s17, s30);
2283 __ Frint32x(s18, s31);
2317 __ Fmov(d13, 1.0);
2318 __ Fmov(d14, 1.1);
2319 __ Fmov(d15, 1.5);
2320 __ Fmov(d16, 1.9);
2321 __ Fmov(d17, 2.5);
2322 __ Fmov(d18, -1.5);
2323 __ Fmov(d19, -2.5);
2324 __ Fmov(d20, kFP64PositiveInfinity);
2325 __ Fmov(d21, kFP64NegativeInfinity);
2326 __ Fmov(d22, 0.0);
2327 __ Fmov(d23, -0.0);
2328 __ Fmov(d24, -0.2);
2329 __ Fmov(d25, kFP64DefaultNaN);
2330 __ Fmov(d26, INT32_MIN);
2331 __ Fmov(d27, INT32_MIN + 1);
2332 __ Fmov(d28, INT32_MAX);
2333 __ Fmov(d29, INT32_MAX - 1);
2334 __ Fmov(d30, FLT_MIN);
2335 __ Fmov(d31, FLT_MAX);
2337 __ Frint32x(d0, d13);
2338 __ Frint32x(d1, d14);
2339 __ Frint32x(d2, d15);
2340 __ Frint32x(d3, d16);
2341 __ Frint32x(d4, d17);
2342 __ Frint32x(d5, d18);
2343 __ Frint32x(d6, d19);
2344 __ Frint32x(d7, d20);
2345 __ Frint32x(d8, d21);
2346 __ Frint32x(d9, d22);
2347 __ Frint32x(d10, d23);
2348 __ Frint32x(d11, d24);
2349 __ Frint32x(d12, d25);
2350 __ Frint32x(d13, d26);
2351 __ Frint32x(d14, d27);
2352 __ Frint32x(d15, d28);
2353 __ Frint32x(d16, d29);
2354 __ Frint32x(d17, d30);
2355 __ Frint32x(d18, d31);
2389 __ Fmov(s13, 1.0);
2390 __ Fmov(s14, 1.1);
2391 __ Fmov(s15, 1.5);
2392 __ Fmov(s16, 1.9);
2393 __ Fmov(s17, 2.5);
2394 __ Fmov(s18, -1.5);
2395 __ Fmov(s19, -2.5);
2396 __ Fmov(s20, kFP32PositiveInfinity);
2397 __ Fmov(s21, kFP32NegativeInfinity);
2398 __ Fmov(s22, 0.0);
2399 __ Fmov(s23, -0.0);
2400 __ Fmov(s24, -0.2);
2401 __ Fmov(s25, kFP32DefaultNaN);
2402 __ Fmov(s26, INT32_MIN);
2403 __ Fmov(s27, INT32_MIN + 0x80); // The next representable FP32.
2404 __ Fmov(s28, 0x80000000);
2405 __ Fmov(s29, 0x7fffff80); // The largest int32_t representable as FP32.
2406 __ Fmov(s30, FLT_MIN);
2407 __ Fmov(s31, FLT_MAX);
2409 __ Frint32z(s0, s13);
2410 __ Frint32z(s1, s14);
2411 __ Frint32z(s2, s15);
2412 __ Frint32z(s3, s16);
2413 __ Frint32z(s4, s17);
2414 __ Frint32z(s5, s18);
2415 __ Frint32z(s6, s19);
2416 __ Frint32z(s7, s20);
2417 __ Frint32z(s8, s21);
2418 __ Frint32z(s9, s22);
2419 __ Frint32z(s10, s23);
2420 __ Frint32z(s11, s24);
2421 __ Frint32z(s12, s25);
2422 __ Frint32z(s13, s26);
2423 __ Frint32z(s14, s27);
2424 __ Frint32z(s15, s28);
2425 __ Frint32z(s16, s29);
2426 __ Frint32z(s17, s30);
2427 __ Frint32z(s18, s31);
2461 __ Fmov(d13, 1.0);
2462 __ Fmov(d14, 1.1);
2463 __ Fmov(d15, 1.5);
2464 __ Fmov(d16, 1.9);
2465 __ Fmov(d17, 2.5);
2466 __ Fmov(d18, -1.5);
2467 __ Fmov(d19, -2.5);
2468 __ Fmov(d20, kFP64PositiveInfinity);
2469 __ Fmov(d21, kFP64NegativeInfinity);
2470 __ Fmov(d22, 0.0);
2471 __ Fmov(d23, -0.0);
2472 __ Fmov(d24, -0.2);
2473 __ Fmov(d25, kFP64DefaultNaN);
2474 __ Fmov(d26, INT32_MIN);
2475 __ Fmov(d27, INT32_MIN + 1);
2476 __ Fmov(d28, INT32_MAX);
2477 __ Fmov(d29, INT32_MAX - 1);
2478 __ Fmov(d30, FLT_MIN);
2479 __ Fmov(d31, FLT_MAX);
2481 __ Frint32z(d0, d13);
2482 __ Frint32z(d1, d14);
2483 __ Frint32z(d2, d15);
2484 __ Frint32z(d3, d16);
2485 __ Frint32z(d4, d17);
2486 __ Frint32z(d5, d18);
2487 __ Frint32z(d6, d19);
2488 __ Frint32z(d7, d20);
2489 __ Frint32z(d8, d21);
2490 __ Frint32z(d9, d22);
2491 __ Frint32z(d10, d23);
2492 __ Frint32z(d11, d24);
2493 __ Frint32z(d12, d25);
2494 __ Frint32z(d13, d26);
2495 __ Frint32z(d14, d27);
2496 __ Frint32z(d15, d28);
2497 __ Frint32z(d16, d29);
2498 __ Frint32z(d17, d30);
2499 __ Frint32z(d18, d31);
2533 __ Fmov(s13, 1.0);
2534 __ Fmov(s14, 1.1);
2535 __ Fmov(s15, 1.5);
2536 __ Fmov(s16, 1.9);
2537 __ Fmov(s17, 2.5);
2538 __ Fmov(s18, -1.5);
2539 __ Fmov(s19, -2.5);
2540 __ Fmov(s20, kFP64PositiveInfinity);
2541 __ Fmov(s21, kFP64NegativeInfinity);
2542 __ Fmov(s22, 0.0);
2543 __ Fmov(s23, -0.0);
2544 __ Fmov(s24, -0.2);
2545 __ Fmov(s25, kFP64DefaultNaN);
2546 __ Fmov(s26, INT64_MIN);
2547 __ Fmov(s27, INT64_MIN + 0x80'00000000); // The next representable FP32.
2548 __ Fmov(s28, 0x80000000'00000000);
2550 __ Fmov(s29, 0x7fffff80'00000000);
2551 __ Fmov(s30, FLT_MIN);
2552 __ Fmov(s31, FLT_MAX);
2554 __ Frint64x(s0, s13);
2555 __ Frint64x(s1, s14);
2556 __ Frint64x(s2, s15);
2557 __ Frint64x(s3, s16);
2558 __ Frint64x(s4, s17);
2559 __ Frint64x(s5, s18);
2560 __ Frint64x(s6, s19);
2561 __ Frint64x(s7, s20);
2562 __ Frint64x(s8, s21);
2563 __ Frint64x(s9, s22);
2564 __ Frint64x(s10, s23);
2565 __ Frint64x(s11, s24);
2566 __ Frint64x(s12, s25);
2567 __ Frint64x(s13, s26);
2568 __ Frint64x(s14, s27);
2569 __ Frint64x(s15, s28);
2570 __ Frint64x(s16, s29);
2571 __ Frint64x(s17, s30);
2572 __ Frint64x(s18, s31);
2606 __ Fmov(d13, 1.0);
2607 __ Fmov(d14, 1.1);
2608 __ Fmov(d15, 1.5);
2609 __ Fmov(d16, 1.9);
2610 __ Fmov(d17, 2.5);
2611 __ Fmov(d18, -1.5);
2612 __ Fmov(d19, -2.5);
2613 __ Fmov(d20, kFP64PositiveInfinity);
2614 __ Fmov(d21, kFP64NegativeInfinity);
2615 __ Fmov(d22, 0.0);
2616 __ Fmov(d23, -0.0);
2617 __ Fmov(d24, -0.2);
2618 __ Fmov(d25, kFP64DefaultNaN);
2619 __ Fmov(d26, INT64_MIN);
2620 __ Fmov(d27, INT64_MIN + 0x400); // The next representable FP64.
2621 __ Fmov(d28, 0x80000000'00000000);
2623 __ Fmov(d29, 0x7fffffff'fffffc00);
2624 __ Fmov(d30, FLT_MIN);
2625 __ Fmov(d31, FLT_MAX);
2627 __ Frint64x(d0, d13);
2628 __ Frint64x(d1, d14);
2629 __ Frint64x(d2, d15);
2630 __ Frint64x(d3, d16);
2631 __ Frint64x(d4, d17);
2632 __ Frint64x(d5, d18);
2633 __ Frint64x(d6, d19);
2634 __ Frint64x(d7, d20);
2635 __ Frint64x(d8, d21);
2636 __ Frint64x(d9, d22);
2637 __ Frint64x(d10, d23);
2638 __ Frint64x(d11, d24);
2639 __ Frint64x(d12, d25);
2640 __ Frint64x(d13, d26);
2641 __ Frint64x(d14, d27);
2642 __ Frint64x(d15, d28);
2643 __ Frint64x(d16, d29);
2644 __ Frint64x(d17, d30);
2645 __ Frint64x(d18, d31);
2679 __ Fmov(s13, 1.0);
2680 __ Fmov(s14, 1.1);
2681 __ Fmov(s15, 1.5);
2682 __ Fmov(s16, 1.9);
2683 __ Fmov(s17, 2.5);
2684 __ Fmov(s18, -1.5);
2685 __ Fmov(s19, -2.5);
2686 __ Fmov(s20, kFP64PositiveInfinity);
2687 __ Fmov(s21, kFP64NegativeInfinity);
2688 __ Fmov(s22, 0.0);
2689 __ Fmov(s23, -0.0);
2690 __ Fmov(s24, -0.2);
2691 __ Fmov(s25, kFP64DefaultNaN);
2692 __ Fmov(s26, INT64_MIN);
2693 __ Fmov(s27, INT64_MIN + 0x80'00000000); // The next representable FP32.
2694 __ Fmov(s28, 0x80000000'00000000);
2696 __ Fmov(s29, 0x7fffff80'00000000);
2697 __ Fmov(s30, FLT_MIN);
2698 __ Fmov(s31, FLT_MAX);
2700 __ Frint64z(s0, s13);
2701 __ Frint64z(s1, s14);
2702 __ Frint64z(s2, s15);
2703 __ Frint64z(s3, s16);
2704 __ Frint64z(s4, s17);
2705 __ Frint64z(s5, s18);
2706 __ Frint64z(s6, s19);
2707 __ Frint64z(s7, s20);
2708 __ Frint64z(s8, s21);
2709 __ Frint64z(s9, s22);
2710 __ Frint64z(s10, s23);
2711 __ Frint64z(s11, s24);
2712 __ Frint64z(s12, s25);
2713 __ Frint64z(s13, s26);
2714 __ Frint64z(s14, s27);
2715 __ Frint64z(s15, s28);
2716 __ Frint64z(s16, s29);
2717 __ Frint64z(s17, s30);
2718 __ Frint64z(s18, s31);
2752 __ Fmov(d13, 1.0);
2753 __ Fmov(d14, 1.1);
2754 __ Fmov(d15, 1.5);
2755 __ Fmov(d16, 1.9);
2756 __ Fmov(d17, 2.5);
2757 __ Fmov(d18, -1.5);
2758 __ Fmov(d19, -2.5);
2759 __ Fmov(d20, kFP64PositiveInfinity);
2760 __ Fmov(d21, kFP64NegativeInfinity);
2761 __ Fmov(d22, 0.0);
2762 __ Fmov(d23, -0.0);
2763 __ Fmov(d24, -0.2);
2764 __ Fmov(d25, kFP64DefaultNaN);
2765 __ Fmov(d26, INT64_MIN);
2766 __ Fmov(d27, INT64_MIN + 0x400); // The next representable FP64.
2767 __ Fmov(d28, 0x80000000'00000000);
2769 __ Fmov(d29, 0x7fffffff'fffffc00);
2770 __ Fmov(d30, FLT_MIN);
2771 __ Fmov(d31, FLT_MAX);
2773 __ Frint64z(d0, d13);
2774 __ Frint64z(d1, d14);
2775 __ Frint64z(d2, d15);
2776 __ Frint64z(d3, d16);
2777 __ Frint64z(d4, d17);
2778 __ Frint64z(d5, d18);
2779 __ Frint64z(d6, d19);
2780 __ Frint64z(d7, d20);
2781 __ Frint64z(d8, d21);
2782 __ Frint64z(d9, d22);
2783 __ Frint64z(d10, d23);
2784 __ Frint64z(d11, d24);
2785 __ Frint64z(d12, d25);
2786 __ Frint64z(d13, d26);
2787 __ Frint64z(d14, d27);
2788 __ Frint64z(d15, d28);
2789 __ Frint64z(d16, d29);
2790 __ Frint64z(d17, d30);
2791 __ Frint64z(d18, d31);
2824 __ Fmov(s16, 1.0);
2825 __ Fmov(s17, 1.1);
2826 __ Fmov(s18, 1.5);
2827 __ Fmov(s19, 1.9);
2828 __ Fmov(s20, 2.5);
2829 __ Fmov(s21, -1.5);
2830 __ Fmov(s22, -2.5);
2831 __ Fmov(s23, kFP32PositiveInfinity);
2832 __ Fmov(s24, kFP32NegativeInfinity);
2833 __ Fmov(s25, 0.0);
2834 __ Fmov(s26, -0.0);
2835 __ Fmov(s27, -0.2);
2837 __ Frinta(s0, s16);
2838 __ Frinta(s1, s17);
2839 __ Frinta(s2, s18);
2840 __ Frinta(s3, s19);
2841 __ Frinta(s4, s20);
2842 __ Frinta(s5, s21);
2843 __ Frinta(s6, s22);
2844 __ Frinta(s7, s23);
2845 __ Frinta(s8, s24);
2846 __ Frinta(s9, s25);
2847 __ Frinta(s10, s26);
2848 __ Frinta(s11, s27);
2850 __ Fmov(d16, 1.0);
2851 __ Fmov(d17, 1.1);
2852 __ Fmov(d18, 1.5);
2853 __ Fmov(d19, 1.9);
2854 __ Fmov(d20, 2.5);
2855 __ Fmov(d21, -1.5);
2856 __ Fmov(d22, -2.5);
2857 __ Fmov(d23, kFP32PositiveInfinity);
2858 __ Fmov(d24, kFP32NegativeInfinity);
2859 __ Fmov(d25, 0.0);
2860 __ Fmov(d26, -0.0);
2861 __ Fmov(d27, -0.2);
2863 __ Frinta(d12, d16);
2864 __ Frinta(d13, d17);
2865 __ Frinta(d14, d18);
2866 __ Frinta(d15, d19);
2867 __ Frinta(d16, d20);
2868 __ Frinta(d17, d21);
2869 __ Frinta(d18, d22);
2870 __ Frinta(d19, d23);
2871 __ Frinta(d20, d24);
2872 __ Frinta(d21, d25);
2873 __ Frinta(d22, d26);
2874 __ Frinta(d23, d27);
2914 __ Fmov(s16, 1.0);
2915 __ Fmov(s17, 1.1);
2916 __ Fmov(s18, 1.5);
2917 __ Fmov(s19, 1.9);
2918 __ Fmov(s20, 2.5);
2919 __ Fmov(s21, -1.5);
2920 __ Fmov(s22, -2.5);
2921 __ Fmov(s23, kFP32PositiveInfinity);
2922 __ Fmov(s24, kFP32NegativeInfinity);
2923 __ Fmov(s25, 0.0);
2924 __ Fmov(s26, -0.0);
2925 __ Fmov(s27, -0.2);
2927 __ Frinti(s0, s16);
2928 __ Frinti(s1, s17);
2929 __ Frinti(s2, s18);
2930 __ Frinti(s3, s19);
2931 __ Frinti(s4, s20);
2932 __ Frinti(s5, s21);
2933 __ Frinti(s6, s22);
2934 __ Frinti(s7, s23);
2935 __ Frinti(s8, s24);
2936 __ Frinti(s9, s25);
2937 __ Frinti(s10, s26);
2938 __ Frinti(s11, s27);
2940 __ Fmov(d16, 1.0);
2941 __ Fmov(d17, 1.1);
2942 __ Fmov(d18, 1.5);
2943 __ Fmov(d19, 1.9);
2944 __ Fmov(d20, 2.5);
2945 __ Fmov(d21, -1.5);
2946 __ Fmov(d22, -2.5);
2947 __ Fmov(d23, kFP32PositiveInfinity);
2948 __ Fmov(d24, kFP32NegativeInfinity);
2949 __ Fmov(d25, 0.0);
2950 __ Fmov(d26, -0.0);
2951 __ Fmov(d27, -0.2);
2953 __ Frinti(d12, d16);
2954 __ Frinti(d13, d17);
2955 __ Frinti(d14, d18);
2956 __ Frinti(d15, d19);
2957 __ Frinti(d16, d20);
2958 __ Frinti(d17, d21);
2959 __ Frinti(d18, d22);
2960 __ Frinti(d19, d23);
2961 __ Frinti(d20, d24);
2962 __ Frinti(d21, d25);
2963 __ Frinti(d22, d26);
2964 __ Frinti(d23, d27);
3002 __ Fmov(s16, 1.0);
3003 __ Fmov(s17, 1.1);
3004 __ Fmov(s18, 1.5);
3005 __ Fmov(s19, 1.9);
3006 __ Fmov(s20, 2.5);
3007 __ Fmov(s21, -1.5);
3008 __ Fmov(s22, -2.5);
3009 __ Fmov(s23, kFP32PositiveInfinity);
3010 __ Fmov(s24, kFP32NegativeInfinity);
3011 __ Fmov(s25, 0.0);
3012 __ Fmov(s26, -0.0);
3013 __ Fmov(s27, -0.2);
3015 __ Frintm(s0, s16);
3016 __ Frintm(s1, s17);
3017 __ Frintm(s2, s18);
3018 __ Frintm(s3, s19);
3019 __ Frintm(s4, s20);
3020 __ Frintm(s5, s21);
3021 __ Frintm(s6, s22);
3022 __ Frintm(s7, s23);
3023 __ Frintm(s8, s24);
3024 __ Frintm(s9, s25);
3025 __ Frintm(s10, s26);
3026 __ Frintm(s11, s27);
3028 __ Fmov(d16, 1.0);
3029 __ Fmov(d17, 1.1);
3030 __ Fmov(d18, 1.5);
3031 __ Fmov(d19, 1.9);
3032 __ Fmov(d20, 2.5);
3033 __ Fmov(d21, -1.5);
3034 __ Fmov(d22, -2.5);
3035 __ Fmov(d23, kFP32PositiveInfinity);
3036 __ Fmov(d24, kFP32NegativeInfinity);
3037 __ Fmov(d25, 0.0);
3038 __ Fmov(d26, -0.0);
3039 __ Fmov(d27, -0.2);
3041 __ Frintm(d12, d16);
3042 __ Frintm(d13, d17);
3043 __ Frintm(d14, d18);
3044 __ Frintm(d15, d19);
3045 __ Frintm(d16, d20);
3046 __ Frintm(d17, d21);
3047 __ Frintm(d18, d22);
3048 __ Frintm(d19, d23);
3049 __ Frintm(d20, d24);
3050 __ Frintm(d21, d25);
3051 __ Frintm(d22, d26);
3052 __ Frintm(d23, d27);
3090 __ Fmov(s16, 1.0);
3091 __ Fmov(s17, 1.1);
3092 __ Fmov(s18, 1.5);
3093 __ Fmov(s19, 1.9);
3094 __ Fmov(s20, 2.5);
3095 __ Fmov(s21, -1.5);
3096 __ Fmov(s22, -2.5);
3097 __ Fmov(s23, kFP32PositiveInfinity);
3098 __ Fmov(s24, kFP32NegativeInfinity);
3099 __ Fmov(s25, 0.0);
3100 __ Fmov(s26, -0.0);
3101 __ Fmov(s27, -0.2);
3103 __ Frintn(s0, s16);
3104 __ Frintn(s1, s17);
3105 __ Frintn(s2, s18);
3106 __ Frintn(s3, s19);
3107 __ Frintn(s4, s20);
3108 __ Frintn(s5, s21);
3109 __ Frintn(s6, s22);
3110 __ Frintn(s7, s23);
3111 __ Frintn(s8, s24);
3112 __ Frintn(s9, s25);
3113 __ Frintn(s10, s26);
3114 __ Frintn(s11, s27);
3116 __ Fmov(d16, 1.0);
3117 __ Fmov(d17, 1.1);
3118 __ Fmov(d18, 1.5);
3119 __ Fmov(d19, 1.9);
3120 __ Fmov(d20, 2.5);
3121 __ Fmov(d21, -1.5);
3122 __ Fmov(d22, -2.5);
3123 __ Fmov(d23, kFP32PositiveInfinity);
3124 __ Fmov(d24, kFP32NegativeInfinity);
3125 __ Fmov(d25, 0.0);
3126 __ Fmov(d26, -0.0);
3127 __ Fmov(d27, -0.2);
3129 __ Frintn(d12, d16);
3130 __ Frintn(d13, d17);
3131 __ Frintn(d14, d18);
3132 __ Frintn(d15, d19);
3133 __ Frintn(d16, d20);
3134 __ Frintn(d17, d21);
3135 __ Frintn(d18, d22);
3136 __ Frintn(d19, d23);
3137 __ Frintn(d20, d24);
3138 __ Frintn(d21, d25);
3139 __ Frintn(d22, d26);
3140 __ Frintn(d23, d27);
3178 __ Fmov(s16, 1.0);
3179 __ Fmov(s17, 1.1);
3180 __ Fmov(s18, 1.5);
3181 __ Fmov(s19, 1.9);
3182 __ Fmov(s20, 2.5);
3183 __ Fmov(s21, -1.5);
3184 __ Fmov(s22, -2.5);
3185 __ Fmov(s23, kFP32PositiveInfinity);
3186 __ Fmov(s24, kFP32NegativeInfinity);
3187 __ Fmov(s25, 0.0);
3188 __ Fmov(s26, -0.0);
3189 __ Fmov(s27, -0.2);
3191 __ Frintp(s0, s16);
3192 __ Frintp(s1, s17);
3193 __ Frintp(s2, s18);
3194 __ Frintp(s3, s19);
3195 __ Frintp(s4, s20);
3196 __ Frintp(s5, s21);
3197 __ Frintp(s6, s22);
3198 __ Frintp(s7, s23);
3199 __ Frintp(s8, s24);
3200 __ Frintp(s9, s25);
3201 __ Frintp(s10, s26);
3202 __ Frintp(s11, s27);
3204 __ Fmov(d16, 1.0);
3205 __ Fmov(d17, 1.1);
3206 __ Fmov(d18, 1.5);
3207 __ Fmov(d19, 1.9);
3208 __ Fmov(d20, 2.5);
3209 __ Fmov(d21, -1.5);
3210 __ Fmov(d22, -2.5);
3211 __ Fmov(d23, kFP32PositiveInfinity);
3212 __ Fmov(d24, kFP32NegativeInfinity);
3213 __ Fmov(d25, 0.0);
3214 __ Fmov(d26, -0.0);
3215 __ Fmov(d27, -0.2);
3217 __ Frintp(d12, d16);
3218 __ Frintp(d13, d17);
3219 __ Frintp(d14, d18);
3220 __ Frintp(d15, d19);
3221 __ Frintp(d16, d20);
3222 __ Frintp(d17, d21);
3223 __ Frintp(d18, d22);
3224 __ Frintp(d19, d23);
3225 __ Frintp(d20, d24);
3226 __ Frintp(d21, d25);
3227 __ Frintp(d22, d26);
3228 __ Frintp(d23, d27);
3268 __ Fmov(s16, 1.0);
3269 __ Fmov(s17, 1.1);
3270 __ Fmov(s18, 1.5);
3271 __ Fmov(s19, 1.9);
3272 __ Fmov(s20, 2.5);
3273 __ Fmov(s21, -1.5);
3274 __ Fmov(s22, -2.5);
3275 __ Fmov(s23, kFP32PositiveInfinity);
3276 __ Fmov(s24, kFP32NegativeInfinity);
3277 __ Fmov(s25, 0.0);
3278 __ Fmov(s26, -0.0);
3279 __ Fmov(s27, -0.2);
3281 __ Frintx(s0, s16);
3282 __ Frintx(s1, s17);
3283 __ Frintx(s2, s18);
3284 __ Frintx(s3, s19);
3285 __ Frintx(s4, s20);
3286 __ Frintx(s5, s21);
3287 __ Frintx(s6, s22);
3288 __ Frintx(s7, s23);
3289 __ Frintx(s8, s24);
3290 __ Frintx(s9, s25);
3291 __ Frintx(s10, s26);
3292 __ Frintx(s11, s27);
3294 __ Fmov(d16, 1.0);
3295 __ Fmov(d17, 1.1);
3296 __ Fmov(d18, 1.5);
3297 __ Fmov(d19, 1.9);
3298 __ Fmov(d20, 2.5);
3299 __ Fmov(d21, -1.5);
3300 __ Fmov(d22, -2.5);
3301 __ Fmov(d23, kFP32PositiveInfinity);
3302 __ Fmov(d24, kFP32NegativeInfinity);
3303 __ Fmov(d25, 0.0);
3304 __ Fmov(d26, -0.0);
3305 __ Fmov(d27, -0.2);
3307 __ Frintx(d12, d16);
3308 __ Frintx(d13, d17);
3309 __ Frintx(d14, d18);
3310 __ Frintx(d15, d19);
3311 __ Frintx(d16, d20);
3312 __ Frintx(d17, d21);
3313 __ Frintx(d18, d22);
3314 __ Frintx(d19, d23);
3315 __ Frintx(d20, d24);
3316 __ Frintx(d21, d25);
3317 __ Frintx(d22, d26);
3318 __ Frintx(d23, d27);
3356 __ Fmov(s16, 1.0);
3357 __ Fmov(s17, 1.1);
3358 __ Fmov(s18, 1.5);
3359 __ Fmov(s19, 1.9);
3360 __ Fmov(s20, 2.5);
3361 __ Fmov(s21, -1.5);
3362 __ Fmov(s22, -2.5);
3363 __ Fmov(s23, kFP32PositiveInfinity);
3364 __ Fmov(s24, kFP32NegativeInfinity);
3365 __ Fmov(s25, 0.0);
3366 __ Fmov(s26, -0.0);
3368 __ Frintz(s0, s16);
3369 __ Frintz(s1, s17);
3370 __ Frintz(s2, s18);
3371 __ Frintz(s3, s19);
3372 __ Frintz(s4, s20);
3373 __ Frintz(s5, s21);
3374 __ Frintz(s6, s22);
3375 __ Frintz(s7, s23);
3376 __ Frintz(s8, s24);
3377 __ Frintz(s9, s25);
3378 __ Frintz(s10, s26);
3380 __ Fmov(d16, 1.0);
3381 __ Fmov(d17, 1.1);
3382 __ Fmov(d18, 1.5);
3383 __ Fmov(d19, 1.9);
3384 __ Fmov(d20, 2.5);
3385 __ Fmov(d21, -1.5);
3386 __ Fmov(d22, -2.5);
3387 __ Fmov(d23, kFP32PositiveInfinity);
3388 __ Fmov(d24, kFP32NegativeInfinity);
3389 __ Fmov(d25, 0.0);
3390 __ Fmov(d26, -0.0);
3392 __ Frintz(d11, d16);
3393 __ Frintz(d12, d17);
3394 __ Frintz(d13, d18);
3395 __ Frintz(d14, d19);
3396 __ Frintz(d15, d20);
3397 __ Frintz(d16, d21);
3398 __ Frintz(d17, d22);
3399 __ Frintz(d18, d23);
3400 __ Frintz(d19, d24);
3401 __ Frintz(d20, d25);
3402 __ Frintz(d21, d26);
3438 __ Fmov(s16, 1.0);
3439 __ Fmov(s17, 1.1);
3440 __ Fmov(s18, 1.5);
3441 __ Fmov(s19, 1.9);
3442 __ Fmov(s20, 2.5);
3443 __ Fmov(s21, -1.5);
3444 __ Fmov(s22, -2.5);
3445 __ Fmov(s23, kFP32PositiveInfinity);
3446 __ Fmov(s24, kFP32NegativeInfinity);
3447 __ Fmov(s25, 0.0);
3448 __ Fmov(s26, -0.0);
3449 __ Fmov(s27, FLT_MAX);
3450 __ Fmov(s28, FLT_MIN);
3451 __ Fmov(s29, RawbitsToFloat(0x7fc12345)); // Quiet NaN.
3452 __ Fmov(s30, RawbitsToFloat(0x7f812345)); // Signalling NaN.
3454 __ Fcvt(d0, s16);
3455 __ Fcvt(d1, s17);
3456 __ Fcvt(d2, s18);
3457 __ Fcvt(d3, s19);
3458 __ Fcvt(d4, s20);
3459 __ Fcvt(d5, s21);
3460 __ Fcvt(d6, s22);
3461 __ Fcvt(d7, s23);
3462 __ Fcvt(d8, s24);
3463 __ Fcvt(d9, s25);
3464 __ Fcvt(d10, s26);
3465 __ Fcvt(d11, s27);
3466 __ Fcvt(d12, s28);
3467 __ Fcvt(d13, s29);
3468 __ Fcvt(d14, s30);
3507 __ Fmov(d16, 1.0);
3508 __ Fmov(d17, 1.1);
3509 __ Fmov(d18, 1.5);
3510 __ Fmov(d19, 1.9);
3511 __ Fmov(d20, 2.5);
3512 __ Fmov(d21, -1.5);
3513 __ Fmov(d22, -2.5);
3514 __ Fmov(d23, kFP32PositiveInfinity);
3515 __ Fmov(d24, kFP32NegativeInfinity);
3516 __ Fmov(d25, 0.0);
3517 __ Fmov(d26, -0.0);
3518 __ Fmov(d27, FLT_MAX);
3519 __ Fmov(d28, FLT_MIN);
3520 __ Fmov(d29, RawbitsToDouble(0x7ff82468a0000000)); // Quiet NaN.
3521 __ Fmov(d30, RawbitsToDouble(0x7ff02468a0000000)); // Signalling NaN.
3523 __ Fcvt(s0, d16);
3524 __ Fcvt(s1, d17);
3525 __ Fcvt(s2, d18);
3526 __ Fcvt(s3, d19);
3527 __ Fcvt(s4, d20);
3528 __ Fcvt(s5, d21);
3529 __ Fcvt(s6, d22);
3530 __ Fcvt(s7, d23);
3531 __ Fcvt(s8, d24);
3532 __ Fcvt(s9, d25);
3533 __ Fcvt(s10, d26);
3534 __ Fcvt(s11, d27);
3535 __ Fcvt(s12, d28);
3536 __ Fcvt(s13, d29);
3537 __ Fcvt(s14, d30);
3577 __ Mov(w0, 0);
3580 __ Mov(w1, i);
3581 __ Fmov(s1, w1);
3582 __ Fcvt(s2, h1);
3583 __ Fcvt(h2, s2);
3584 __ Fmov(w2, s2);
3585 __ Cmp(w1, w2);
3586 __ B(&fail, ne);
3588 __ B(&ok);
3589 __ Bind(&fail);
3590 __ Mov(w0, 1);
3591 __ B(&done);
3592 __ Bind(&ok);
3599 __ Mov(w1, i);
3600 __ Fmov(s1, w1);
3601 __ Fcvt(d2, h1);
3602 __ Fcvt(h2, d2);
3603 __ Fmov(w2, s2);
3604 __ Cmp(w1, w2);
3605 __ B(&fail, ne);
3607 __ B(&ok);
3608 __ Bind(&fail);
3609 __ Mov(w0, 2);
3610 __ Bind(&ok);
3612 __ Bind(&done);
3615 __ Fmov(s0, kFP32PositiveInfinity);
3616 __ Fmov(s1, kFP32NegativeInfinity);
3617 __ Fmov(s2, 65504); // Max half precision.
3618 __ Fmov(s3, 6.10352e-5); // Min positive normal.
3619 __ Fmov(s4, 6.09756e-5); // Max subnormal.
3620 __ Fmov(s5, 5.96046e-8); // Min positive subnormal.
3621 __ Fmov(s6, 5e-9); // Not representable -> zero.
3622 __ Fmov(s7, -0.0);
3623 __ Fcvt(h0, s0);
3624 __ Fcvt(h1, s1);
3625 __ Fcvt(h2, s2);
3626 __ Fcvt(h3, s3);
3627 __ Fcvt(h4, s4);
3628 __ Fcvt(h5, s5);
3629 __ Fcvt(h6, s6);
3630 __ Fcvt(h7, s7);
3632 __ Fmov(d20, kFP64PositiveInfinity);
3633 __ Fmov(d21, kFP64NegativeInfinity);
3634 __ Fmov(d22, 65504); // Max half precision.
3635 __ Fmov(d23, 6.10352e-5); // Min positive normal.
3636 __ Fmov(d24, 6.09756e-5); // Max subnormal.
3637 __ Fmov(d25, 5.96046e-8); // Min positive subnormal.
3638 __ Fmov(d26, 5e-9); // Not representable -> zero.
3639 __ Fmov(d27, -0.0);
3640 __ Fcvt(h20, d20);
3641 __ Fcvt(h21, d21);
3642 __ Fcvt(h22, d22);
3643 __ Fcvt(h23, d23);
3644 __ Fcvt(h24, d24);
3645 __ Fcvt(h25, d25);
3646 __ Fcvt(h26, d26);
3647 __ Fcvt(h27, d27);
3678 __ Fmov(s0, 1.0);
3679 __ Fmov(s1, 1.1);
3680 __ Fmov(s2, 2.5);
3681 __ Fmov(s3, -2.5);
3682 __ Fmov(s4, kFP32PositiveInfinity);
3683 __ Fmov(s5, kFP32NegativeInfinity);
3684 __ Fmov(s6, 0x7fffff80); // Largest float < INT32_MAX.
3685 __ Fneg(s7, s6); // Smallest float > INT32_MIN.
3686 __ Fmov(d8, 1.0);
3687 __ Fmov(d9, 1.1);
3688 __ Fmov(d10, 2.5);
3689 __ Fmov(d11, -2.5);
3690 __ Fmov(d12, kFP64PositiveInfinity);
3691 __ Fmov(d13, kFP64NegativeInfinity);
3692 __ Fmov(d14, kWMaxInt - 1);
3693 __ Fmov(d15, kWMinInt + 1);
3694 __ Fmov(s17, 1.1);
3695 __ Fmov(s18, 2.5);
3696 __ Fmov(s19, -2.5);
3697 __ Fmov(s20, kFP32PositiveInfinity);
3698 __ Fmov(s21, kFP32NegativeInfinity);
3699 __ Fmov(s22, 0x7fffff8000000000); // Largest float < INT64_MAX.
3700 __ Fneg(s23, s22); // Smallest float > INT64_MIN.
3701 __ Fmov(d24, 1.1);
3702 __ Fmov(d25, 2.5);
3703 __ Fmov(d26, -2.5);
3704 __ Fmov(d27, kFP64PositiveInfinity);
3705 __ Fmov(d28, kFP64NegativeInfinity);
3706 __ Fmov(d29, 0x7ffffffffffffc00); // Largest double < INT64_MAX.
3707 __ Fneg(d30, d29); // Smallest double > INT64_MIN.
3709 __ Fcvtas(w0, s0);
3710 __ Fcvtas(w1, s1);
3711 __ Fcvtas(w2, s2);
3712 __ Fcvtas(w3, s3);
3713 __ Fcvtas(w4, s4);
3714 __ Fcvtas(w5, s5);
3715 __ Fcvtas(w6, s6);
3716 __ Fcvtas(w7, s7);
3717 __ Fcvtas(w8, d8);
3718 __ Fcvtas(w9, d9);
3719 __ Fcvtas(w10, d10);
3720 __ Fcvtas(w11, d11);
3721 __ Fcvtas(w12, d12);
3722 __ Fcvtas(w13, d13);
3723 __ Fcvtas(w14, d14);
3724 __ Fcvtas(w15, d15);
3725 __ Fcvtas(x17, s17);
3726 __ Fcvtas(x18, s18);
3727 __ Fcvtas(x19, s19);
3728 __ Fcvtas(x20, s20);
3729 __ Fcvtas(x21, s21);
3730 __ Fcvtas(x22, s22);
3731 __ Fcvtas(x23, s23);
3732 __ Fcvtas(x24, d24);
3733 __ Fcvtas(x25, d25);
3734 __ Fcvtas(x26, d26);
3735 __ Fcvtas(x27, d27);
3736 __ Fcvtas(x28, d28);
3737 __ Fcvtas(x29, d29);
3738 __ Fcvtas(x30, d30);
3782 __ Fmov(s0, 1.0);
3783 __ Fmov(s1, 1.1);
3784 __ Fmov(s2, 2.5);
3785 __ Fmov(s3, -2.5);
3786 __ Fmov(s4, kFP32PositiveInfinity);
3787 __ Fmov(s5, kFP32NegativeInfinity);
3788 __ Fmov(s6, 0xffffff00); // Largest float < UINT32_MAX.
3789 __ Fmov(d8, 1.0);
3790 __ Fmov(d9, 1.1);
3791 __ Fmov(d10, 2.5);
3792 __ Fmov(d11, -2.5);
3793 __ Fmov(d12, kFP64PositiveInfinity);
3794 __ Fmov(d13, kFP64NegativeInfinity);
3795 __ Fmov(d14, 0xfffffffe);
3796 __ Fmov(s16, 1.0);
3797 __ Fmov(s17, 1.1);
3798 __ Fmov(s18, 2.5);
3799 __ Fmov(s19, -2.5);
3800 __ Fmov(s20, kFP32PositiveInfinity);
3801 __ Fmov(s21, kFP32NegativeInfinity);
3802 __ Fmov(s22, 0xffffff0000000000); // Largest float < UINT64_MAX.
3803 __ Fmov(d24, 1.1);
3804 __ Fmov(d25, 2.5);
3805 __ Fmov(d26, -2.5);
3806 __ Fmov(d27, kFP64PositiveInfinity);
3807 __ Fmov(d28, kFP64NegativeInfinity);
3808 __ Fmov(d29, 0xfffffffffffff800); // Largest double < UINT64_MAX.
3809 __ Fmov(s30, 0x100000000);
3811 __ Fcvtau(w0, s0);
3812 __ Fcvtau(w1, s1);
3813 __ Fcvtau(w2, s2);
3814 __ Fcvtau(w3, s3);
3815 __ Fcvtau(w4, s4);
3816 __ Fcvtau(w5, s5);
3817 __ Fcvtau(w6, s6);
3818 __ Fcvtau(w8, d8);
3819 __ Fcvtau(w9, d9);
3820 __ Fcvtau(w10, d10);
3821 __ Fcvtau(w11, d11);
3822 __ Fcvtau(w12, d12);
3823 __ Fcvtau(w13, d13);
3824 __ Fcvtau(w14, d14);
3825 __ Fcvtau(w15, d15);
3826 __ Fcvtau(x16, s16);
3827 __ Fcvtau(x17, s17);
3828 __ Fcvtau(x18, s18);
3829 __ Fcvtau(x19, s19);
3830 __ Fcvtau(x20, s20);
3831 __ Fcvtau(x21, s21);
3832 __ Fcvtau(x22, s22);
3833 __ Fcvtau(x24, d24);
3834 __ Fcvtau(x25, d25);
3835 __ Fcvtau(x26, d26);
3836 __ Fcvtau(x27, d27);
3837 __ Fcvtau(x28, d28);
3838 __ Fcvtau(x29, d29);
3839 __ Fcvtau(w30, s30);
3881 __ Fmov(s0, 1.0);
3882 __ Fmov(s1, 1.1);
3883 __ Fmov(s2, 1.5);
3884 __ Fmov(s3, -1.5);
3885 __ Fmov(s4, kFP32PositiveInfinity);
3886 __ Fmov(s5, kFP32NegativeInfinity);
3887 __ Fmov(s6, 0x7fffff80); // Largest float < INT32_MAX.
3888 __ Fneg(s7, s6); // Smallest float > INT32_MIN.
3889 __ Fmov(d8, 1.0);
3890 __ Fmov(d9, 1.1);
3891 __ Fmov(d10, 1.5);
3892 __ Fmov(d11, -1.5);
3893 __ Fmov(d12, kFP64PositiveInfinity);
3894 __ Fmov(d13, kFP64NegativeInfinity);
3895 __ Fmov(d14, kWMaxInt - 1);
3896 __ Fmov(d15, kWMinInt + 1);
3897 __ Fmov(s17, 1.1);
3898 __ Fmov(s18, 1.5);
3899 __ Fmov(s19, -1.5);
3900 __ Fmov(s20, kFP32PositiveInfinity);
3901 __ Fmov(s21, kFP32NegativeInfinity);
3902 __ Fmov(s22, 0x7fffff8000000000); // Largest float < INT64_MAX.
3903 __ Fneg(s23, s22); // Smallest float > INT64_MIN.
3904 __ Fmov(d24, 1.1);
3905 __ Fmov(d25, 1.5);
3906 __ Fmov(d26, -1.5);
3907 __ Fmov(d27, kFP64PositiveInfinity);
3908 __ Fmov(d28, kFP64NegativeInfinity);
3909 __ Fmov(d29, 0x7ffffffffffffc00); // Largest double < INT64_MAX.
3910 __ Fneg(d30, d29); // Smallest double > INT64_MIN.
3912 __ Fcvtms(w0, s0);
3913 __ Fcvtms(w1, s1);
3914 __ Fcvtms(w2, s2);
3915 __ Fcvtms(w3, s3);
3916 __ Fcvtms(w4, s4);
3917 __ Fcvtms(w5, s5);
3918 __ Fcvtms(w6, s6);
3919 __ Fcvtms(w7, s7);
3920 __ Fcvtms(w8, d8);
3921 __ Fcvtms(w9, d9);
3922 __ Fcvtms(w10, d10);
3923 __ Fcvtms(w11, d11);
3924 __ Fcvtms(w12, d12);
3925 __ Fcvtms(w13, d13);
3926 __ Fcvtms(w14, d14);
3927 __ Fcvtms(w15, d15);
3928 __ Fcvtms(x17, s17);
3929 __ Fcvtms(x18, s18);
3930 __ Fcvtms(x19, s19);
3931 __ Fcvtms(x20, s20);
3932 __ Fcvtms(x21, s21);
3933 __ Fcvtms(x22, s22);
3934 __ Fcvtms(x23, s23);
3935 __ Fcvtms(x24, d24);
3936 __ Fcvtms(x25, d25);
3937 __ Fcvtms(x26, d26);
3938 __ Fcvtms(x27, d27);
3939 __ Fcvtms(x28, d28);
3940 __ Fcvtms(x29, d29);
3941 __ Fcvtms(x30, d30);
3985 __ Fmov(s0, 1.0);
3986 __ Fmov(s1, 1.1);
3987 __ Fmov(s2, 1.5);
3988 __ Fmov(s3, -1.5);
3989 __ Fmov(s4, kFP32PositiveInfinity);
3990 __ Fmov(s5, kFP32NegativeInfinity);
3991 __ Fmov(s6, 0x7fffff80); // Largest float < INT32_MAX.
3992 __ Fneg(s7, s6); // Smallest float > INT32_MIN.
3993 __ Fmov(d8, 1.0);
3994 __ Fmov(d9, 1.1);
3995 __ Fmov(d10, 1.5);
3996 __ Fmov(d11, -1.5);
3997 __ Fmov(d12, kFP64PositiveInfinity);
3998 __ Fmov(d13, kFP64NegativeInfinity);
3999 __ Fmov(d14, kWMaxInt - 1);
4000 __ Fmov(d15, kWMinInt + 1);
4001 __ Fmov(s17, 1.1);
4002 __ Fmov(s18, 1.5);
4003 __ Fmov(s19, -1.5);
4004 __ Fmov(s20, kFP32PositiveInfinity);
4005 __ Fmov(s21, kFP32NegativeInfinity);
4006 __ Fmov(s22, 0x7fffff8000000000); // Largest float < INT64_MAX.
4007 __ Fneg(s23, s22); // Smallest float > INT64_MIN.
4008 __ Fmov(d24, 1.1);
4009 __ Fmov(d25, 1.5);
4010 __ Fmov(d26, -1.5);
4011 __ Fmov(d27, kFP64PositiveInfinity);
4012 __ Fmov(d28, kFP64NegativeInfinity);
4013 __ Fmov(d29, 0x7ffffffffffffc00); // Largest double < INT64_MAX.
4014 __ Fneg(d30, d29); // Smallest double > INT64_MIN.
4016 __ Fcvtmu(w0, s0);
4017 __ Fcvtmu(w1, s1);
4018 __ Fcvtmu(w2, s2);
4019 __ Fcvtmu(w3, s3);
4020 __ Fcvtmu(w4, s4);
4021 __ Fcvtmu(w5, s5);
4022 __ Fcvtmu(w6, s6);
4023 __ Fcvtmu(w7, s7);
4024 __ Fcvtmu(w8, d8);
4025 __ Fcvtmu(w9, d9);
4026 __ Fcvtmu(w10, d10);
4027 __ Fcvtmu(w11, d11);
4028 __ Fcvtmu(w12, d12);
4029 __ Fcvtmu(w13, d13);
4030 __ Fcvtmu(w14, d14);
4031 __ Fcvtmu(x17, s17);
4032 __ Fcvtmu(x18, s18);
4033 __ Fcvtmu(x19, s19);
4034 __ Fcvtmu(x20, s20);
4035 __ Fcvtmu(x21, s21);
4036 __ Fcvtmu(x22, s22);
4037 __ Fcvtmu(x23, s23);
4038 __ Fcvtmu(x24, d24);
4039 __ Fcvtmu(x25, d25);
4040 __ Fcvtmu(x26, d26);
4041 __ Fcvtmu(x27, d27);
4042 __ Fcvtmu(x28, d28);
4043 __ Fcvtmu(x29, d29);
4044 __ Fcvtmu(x30, d30);
4087 __ Fmov(s0, 1.0);
4088 __ Fmov(s1, 1.1);
4089 __ Fmov(s2, 1.5);
4090 __ Fmov(s3, -1.5);
4091 __ Fmov(s4, kFP32PositiveInfinity);
4092 __ Fmov(s5, kFP32NegativeInfinity);
4093 __ Fmov(s6, 0x7fffff80); // Largest float < INT32_MAX.
4094 __ Fneg(s7, s6); // Smallest float > INT32_MIN.
4095 __ Fmov(d8, 1.0);
4096 __ Fmov(d9, 1.1);
4097 __ Fmov(d10, 1.5);
4098 __ Fmov(d11, -1.5);
4099 __ Fmov(d12, kFP64PositiveInfinity);
4100 __ Fmov(d13, kFP64NegativeInfinity);
4101 __ Fmov(d14, kWMaxInt - 1);
4102 __ Fmov(d15, kWMinInt + 1);
4103 __ Fmov(s17, 1.1);
4104 __ Fmov(s18, 1.5);
4105 __ Fmov(s19, -1.5);
4106 __ Fmov(s20, kFP32PositiveInfinity);
4107 __ Fmov(s21, kFP32NegativeInfinity);
4108 __ Fmov(s22, 0x7fffff8000000000); // Largest float < INT64_MAX.
4109 __ Fneg(s23, s22); // Smallest float > INT64_MIN.
4110 __ Fmov(d24, 1.1);
4111 __ Fmov(d25, 1.5);
4112 __ Fmov(d26, -1.5);
4113 __ Fmov(d27, kFP64PositiveInfinity);
4114 __ Fmov(d28, kFP64NegativeInfinity);
4115 __ Fmov(d29, 0x7ffffffffffffc00); // Largest double < INT64_MAX.
4116 __ Fneg(d30, d29); // Smallest double > INT64_MIN.
4118 __ Fcvtns(w0, s0);
4119 __ Fcvtns(w1, s1);
4120 __ Fcvtns(w2, s2);
4121 __ Fcvtns(w3, s3);
4122 __ Fcvtns(w4, s4);
4123 __ Fcvtns(w5, s5);
4124 __ Fcvtns(w6, s6);
4125 __ Fcvtns(w7, s7);
4126 __ Fcvtns(w8, d8);
4127 __ Fcvtns(w9, d9);
4128 __ Fcvtns(w10, d10);
4129 __ Fcvtns(w11, d11);
4130 __ Fcvtns(w12, d12);
4131 __ Fcvtns(w13, d13);
4132 __ Fcvtns(w14, d14);
4133 __ Fcvtns(w15, d15);
4134 __ Fcvtns(x17, s17);
4135 __ Fcvtns(x18, s18);
4136 __ Fcvtns(x19, s19);
4137 __ Fcvtns(x20, s20);
4138 __ Fcvtns(x21, s21);
4139 __ Fcvtns(x22, s22);
4140 __ Fcvtns(x23, s23);
4141 __ Fcvtns(x24, d24);
4142 __ Fcvtns(x25, d25);
4143 __ Fcvtns(x26, d26);
4144 __ Fcvtns(x27, d27);
4145 __ Fcvtns(x28, d28);
4146 __ Fcvtns(x29, d29);
4147 __ Fcvtns(x30, d30);
4191 __ Fmov(s0, 1.0);
4192 __ Fmov(s1, 1.1);
4193 __ Fmov(s2, 1.5);
4194 __ Fmov(s3, -1.5);
4195 __ Fmov(s4, kFP32PositiveInfinity);
4196 __ Fmov(s5, kFP32NegativeInfinity);
4197 __ Fmov(s6, 0xffffff00); // Largest float < UINT32_MAX.
4198 __ Fmov(d8, 1.0);
4199 __ Fmov(d9, 1.1);
4200 __ Fmov(d10, 1.5);
4201 __ Fmov(d11, -1.5);
4202 __ Fmov(d12, kFP64PositiveInfinity);
4203 __ Fmov(d13, kFP64NegativeInfinity);
4204 __ Fmov(d14, 0xfffffffe);
4205 __ Fmov(s16, 1.0);
4206 __ Fmov(s17, 1.1);
4207 __ Fmov(s18, 1.5);
4208 __ Fmov(s19, -1.5);
4209 __ Fmov(s20, kFP32PositiveInfinity);
4210 __ Fmov(s21, kFP32NegativeInfinity);
4211 __ Fmov(s22, 0xffffff0000000000); // Largest float < UINT64_MAX.
4212 __ Fmov(d24, 1.1);
4213 __ Fmov(d25, 1.5);
4214 __ Fmov(d26, -1.5);
4215 __ Fmov(d27, kFP64PositiveInfinity);
4216 __ Fmov(d28, kFP64NegativeInfinity);
4217 __ Fmov(d29, 0xfffffffffffff800); // Largest double < UINT64_MAX.
4218 __ Fmov(s30, 0x100000000);
4220 __ Fcvtnu(w0, s0);
4221 __ Fcvtnu(w1, s1);
4222 __ Fcvtnu(w2, s2);
4223 __ Fcvtnu(w3, s3);
4224 __ Fcvtnu(w4, s4);
4225 __ Fcvtnu(w5, s5);
4226 __ Fcvtnu(w6, s6);
4227 __ Fcvtnu(w8, d8);
4228 __ Fcvtnu(w9, d9);
4229 __ Fcvtnu(w10, d10);
4230 __ Fcvtnu(w11, d11);
4231 __ Fcvtnu(w12, d12);
4232 __ Fcvtnu(w13, d13);
4233 __ Fcvtnu(w14, d14);
4234 __ Fcvtnu(w15, d15);
4235 __ Fcvtnu(x16, s16);
4236 __ Fcvtnu(x17, s17);
4237 __ Fcvtnu(x18, s18);
4238 __ Fcvtnu(x19, s19);
4239 __ Fcvtnu(x20, s20);
4240 __ Fcvtnu(x21, s21);
4241 __ Fcvtnu(x22, s22);
4242 __ Fcvtnu(x24, d24);
4243 __ Fcvtnu(x25, d25);
4244 __ Fcvtnu(x26, d26);
4245 __ Fcvtnu(x27, d27);
4246 __ Fcvtnu(x28, d28);
4247 __ Fcvtnu(x29, d29);
4248 __ Fcvtnu(w30, s30);
4290 __ Fmov(s0, 1.0);
4291 __ Fmov(s1, 1.1);
4292 __ Fmov(s2, 1.5);
4293 __ Fmov(s3, -1.5);
4294 __ Fmov(s4, kFP32PositiveInfinity);
4295 __ Fmov(s5, kFP32NegativeInfinity);
4296 __ Fmov(s6, 0x7fffff80); // Largest float < INT32_MAX.
4297 __ Fneg(s7, s6); // Smallest float > INT32_MIN.
4298 __ Fmov(d8, 1.0);
4299 __ Fmov(d9, 1.1);
4300 __ Fmov(d10, 1.5);
4301 __ Fmov(d11, -1.5);
4302 __ Fmov(d12, kFP64PositiveInfinity);
4303 __ Fmov(d13, kFP64NegativeInfinity);
4304 __ Fmov(d14, kWMaxInt - 1);
4305 __ Fmov(d15, kWMinInt + 1);
4306 __ Fmov(s17, 1.1);
4307 __ Fmov(s18, 1.5);
4308 __ Fmov(s19, -1.5);
4309 __ Fmov(s20, kFP32PositiveInfinity);
4310 __ Fmov(s21, kFP32NegativeInfinity);
4311 __ Fmov(s22, 0x7fffff8000000000); // Largest float < INT64_MAX.
4312 __ Fneg(s23, s22); // Smallest float > INT64_MIN.
4313 __ Fmov(d24, 1.1);
4314 __ Fmov(d25, 1.5);
4315 __ Fmov(d26, -1.5);
4316 __ Fmov(d27, kFP64PositiveInfinity);
4317 __ Fmov(d28, kFP64NegativeInfinity);
4318 __ Fmov(d29, 0x7ffffffffffffc00); // Largest double < INT64_MAX.
4319 __ Fneg(d30, d29); // Smallest double > INT64_MIN.
4321 __ Fcvtzs(w0, s0);
4322 __ Fcvtzs(w1, s1);
4323 __ Fcvtzs(w2, s2);
4324 __ Fcvtzs(w3, s3);
4325 __ Fcvtzs(w4, s4);
4326 __ Fcvtzs(w5, s5);
4327 __ Fcvtzs(w6, s6);
4328 __ Fcvtzs(w7, s7);
4329 __ Fcvtzs(w8, d8);
4330 __ Fcvtzs(w9, d9);
4331 __ Fcvtzs(w10, d10);
4332 __ Fcvtzs(w11, d11);
4333 __ Fcvtzs(w12, d12);
4334 __ Fcvtzs(w13, d13);
4335 __ Fcvtzs(w14, d14);
4336 __ Fcvtzs(w15, d15);
4337 __ Fcvtzs(x17, s17);
4338 __ Fcvtzs(x18, s18);
4339 __ Fcvtzs(x19, s19);
4340 __ Fcvtzs(x20, s20);
4341 __ Fcvtzs(x21, s21);
4342 __ Fcvtzs(x22, s22);
4343 __ Fcvtzs(x23, s23);
4344 __ Fcvtzs(x24, d24);
4345 __ Fcvtzs(x25, d25);
4346 __ Fcvtzs(x26, d26);
4347 __ Fcvtzs(x27, d27);
4348 __ Fcvtzs(x28, d28);
4349 __ Fcvtzs(x29, d29);
4350 __ Fcvtzs(x30, d30);
4392 __ Fmov(d0, RawbitsToDouble(value));
4393 __ Fjcvtzs(w0, d0);
4394 __ Mrs(x1, NZCV);
4496 __ Fmov(s0, 1.0);
4497 __ Fmov(s1, 1.1);
4498 __ Fmov(s2, 1.5);
4499 __ Fmov(s3, -1.5);
4500 __ Fmov(s4, kFP32PositiveInfinity);
4501 __ Fmov(s5, kFP32NegativeInfinity);
4502 __ Fmov(s6, 0x7fffff80); // Largest float < INT32_MAX.
4503 __ Fneg(s7, s6); // Smallest float > INT32_MIN.
4504 __ Fmov(d8, 1.0);
4505 __ Fmov(d9, 1.1);
4506 __ Fmov(d10, 1.5);
4507 __ Fmov(d11, -1.5);
4508 __ Fmov(d12, kFP64PositiveInfinity);
4509 __ Fmov(d13, kFP64NegativeInfinity);
4510 __ Fmov(d14, kWMaxInt - 1);
4511 __ Fmov(d15, kWMinInt + 1);
4512 __ Fmov(s17, 1.1);
4513 __ Fmov(s18, 1.5);
4514 __ Fmov(s19, -1.5);
4515 __ Fmov(s20, kFP32PositiveInfinity);
4516 __ Fmov(s21, kFP32NegativeInfinity);
4517 __ Fmov(s22, 0x7fffff8000000000); // Largest float < INT64_MAX.
4518 __ Fneg(s23, s22); // Smallest float > INT64_MIN.
4519 __ Fmov(d24, 1.1);
4520 __ Fmov(d25, 1.5);
4521 __ Fmov(d26, -1.5);
4522 __ Fmov(d27, kFP64PositiveInfinity);
4523 __ Fmov(d28, kFP64NegativeInfinity);
4524 __ Fmov(d29, 0x7ffffffffffffc00); // Largest double < INT64_MAX.
4525 __ Fneg(d30, d29); // Smallest double > INT64_MIN.
4527 __ Fcvtzu(w0, s0);
4528 __ Fcvtzu(w1, s1);
4529 __ Fcvtzu(w2, s2);
4530 __ Fcvtzu(w3, s3);
4531 __ Fcvtzu(w4, s4);
4532 __ Fcvtzu(w5, s5);
4533 __ Fcvtzu(w6, s6);
4534 __ Fcvtzu(w7, s7);
4535 __ Fcvtzu(w8, d8);
4536 __ Fcvtzu(w9, d9);
4537 __ Fcvtzu(w10, d10);
4538 __ Fcvtzu(w11, d11);
4539 __ Fcvtzu(w12, d12);
4540 __ Fcvtzu(w13, d13);
4541 __ Fcvtzu(w14, d14);
4542 __ Fcvtzu(x17, s17);
4543 __ Fcvtzu(x18, s18);
4544 __ Fcvtzu(x19, s19);
4545 __ Fcvtzu(x20, s20);
4546 __ Fcvtzu(x21, s21);
4547 __ Fcvtzu(x22, s22);
4548 __ Fcvtzu(x23, s23);
4549 __ Fcvtzu(x24, d24);
4550 __ Fcvtzu(x25, d25);
4551 __ Fcvtzu(x26, d26);
4552 __ Fcvtzu(x27, d27);
4553 __ Fcvtzu(x28, d28);
4554 __ Fcvtzu(x29, d29);
4555 __ Fcvtzu(x30, d30);
4623 __ Mov(x0, reinterpret_cast<uintptr_t>(results_scvtf_x));
4624 __ Mov(x1, reinterpret_cast<uintptr_t>(results_ucvtf_x));
4625 __ Mov(x2, reinterpret_cast<uintptr_t>(results_scvtf_w));
4626 __ Mov(x3, reinterpret_cast<uintptr_t>(results_ucvtf_w));
4628 __ Mov(x10, s64);
4632 __ Mov(x11, 0x5555555555555555);
4633 __ Bfi(x11, x10, 0, kWRegSize);
4636 __ Scvtf(d0, x10);
4637 __ Ucvtf(d1, x10);
4638 __ Scvtf(d2, w11);
4639 __ Ucvtf(d3, w11);
4640 __ Str(d0, MemOperand(x0));
4641 __ Str(d1, MemOperand(x1));
4642 __ Str(d2, MemOperand(x2));
4643 __ Str(d3, MemOperand(x3));
4647 __ Scvtf(d0, x10, fbits);
4648 __ Ucvtf(d1, x10, fbits);
4649 __ Scvtf(d2, w11, fbits);
4650 __ Ucvtf(d3, w11, fbits);
4651 __ Str(d0, MemOperand(x0, fbits * kDRegSizeInBytes));
4652 __ Str(d1, MemOperand(x1, fbits * kDRegSizeInBytes));
4653 __ Str(d2, MemOperand(x2, fbits * kDRegSizeInBytes));
4654 __ Str(d3, MemOperand(x3, fbits * kDRegSizeInBytes));
4660 __ Scvtf(d0, x10, fbits);
4661 __ Ucvtf(d1, x10, fbits);
4662 __ Str(d0, MemOperand(x0, fbits * kDRegSizeInBytes));
4663 __ Str(d1, MemOperand(x1, fbits * kDRegSizeInBytes));
4778 __ Mov(x0, reinterpret_cast<uintptr_t>(results_scvtf_x));
4779 __ Mov(x1, reinterpret_cast<uintptr_t>(results_ucvtf_x));
4780 __ Mov(x2, reinterpret_cast<uintptr_t>(results_scvtf_w));
4781 __ Mov(x3, reinterpret_cast<uintptr_t>(results_ucvtf_w));
4783 __ Mov(x10, s64);
4787 __ Mov(x11, 0x5555555555555555);
4788 __ Bfi(x11, x10, 0, kWRegSize);
4791 __ Scvtf(s0, x10);
4792 __ Ucvtf(s1, x10);
4793 __ Scvtf(s2, w11);
4794 __ Ucvtf(s3, w11);
4795 __ Str(s0, MemOperand(x0));
4796 __ Str(s1, MemOperand(x1));
4797 __ Str(s2, MemOperand(x2));
4798 __ Str(s3, MemOperand(x3));
4802 __ Scvtf(s0, x10, fbits);
4803 __ Ucvtf(s1, x10, fbits);
4804 __ Scvtf(s2, w11, fbits);
4805 __ Ucvtf(s3, w11, fbits);
4806 __ Str(s0, MemOperand(x0, fbits * kSRegSizeInBytes));
4807 __ Str(s1, MemOperand(x1, fbits * kSRegSizeInBytes));
4808 __ Str(s2, MemOperand(x2, fbits * kSRegSizeInBytes));
4809 __ Str(s3, MemOperand(x3, fbits * kSRegSizeInBytes));
4815 __ Scvtf(s0, x10, fbits);
4816 __ Ucvtf(s1, x10, fbits);
4817 __ Str(s0, MemOperand(x0, fbits * kSRegSizeInBytes));
4818 __ Str(s1, MemOperand(x1, fbits * kSRegSizeInBytes));
4933 __ Fmov(d0, sn);
4934 __ Fmov(d10, qn);
4938 __ Fmov(d1, d0);
4939 __ Fabs(d2, d0);
4940 __ Fneg(d3, d0);
4942 __ Fmov(d11, d10);
4943 __ Fabs(d12, d10);
4944 __ Fneg(d13, d10);
4948 __ Fsqrt(d4, d0);
4949 __ Frinta(d5, d0);
4950 __ Frintn(d6, d0);
4951 __ Frintz(d7, d0);
4953 __ Fsqrt(d14, d10);
4954 __ Frinta(d15, d10);
4955 __ Frintn(d16, d10);
4956 __ Frintz(d17, d10);
5009 __ Fmov(s0, sn);
5010 __ Fmov(s10, qn);
5014 __ Fmov(s1, s0);
5015 __ Fabs(s2, s0);
5016 __ Fneg(s3, s0);
5018 __ Fmov(s11, s10);
5019 __ Fabs(s12, s10);
5020 __ Fneg(s13, s10);
5024 __ Fsqrt(s4, s0);
5025 __ Frinta(s5, s0);
5026 __ Frintn(s6, s0);
5027 __ Frintz(s7, s0);
5029 __ Fsqrt(s14, s10);
5030 __ Frinta(s15, s10);
5031 __ Frintn(s16, s10);
5032 __ Frintz(s17, s10);
5077 __ Fmov(d0, n);
5078 __ Fmov(d1, m);
5080 __ Fadd(d2, d0, d1);
5081 __ Fsub(d3, d0, d1);
5082 __ Fmul(d4, d0, d1);
5083 __ Fdiv(d5, d0, d1);
5084 __ Fmax(d6, d0, d1);
5085 __ Fmin(d7, d0, d1);
5149 __ Fmov(s0, n);
5150 __ Fmov(s1, m);
5152 __ Fadd(s2, s0, s1);
5153 __ Fsub(s3, s0, s1);
5154 __ Fmul(s4, s0, s1);
5155 __ Fdiv(s5, s0, s1);
5156 __ Fmax(s6, s0, s1);
5157 __ Fmin(s7, s0, s1);
5221 __ Fmov(h0, n);
5222 __ Fmov(h1, m);
5224 __ Fadd(h2, h0, h1);
5225 __ Fsub(h3, h0, h1);
5226 __ Fmul(h4, h0, h1);
5227 __ Fdiv(h5, h0, h1);
5228 __ Fmax(h6, h0, h1);
5229 __ Fmin(h7, h0, h1);
5293 __ Mrs(x0, FPCR);
5294 __ Orr(x1, x0, DN_mask);
5295 __ Msr(FPCR, x1);
5299 __ Fmov(s0, n);
5300 __ Fmov(s1, m);
5301 __ Fmov(s2, a);
5305 __ Fmov(s10, s0);
5306 __ Fabs(s11, s0);
5307 __ Fneg(s12, s0);
5310 __ Fsqrt(s13, s0);
5311 __ Frinta(s14, s0);
5312 __ Frintn(s15, s0);
5313 __ Frintz(s16, s0);
5316 __ Fcvt(d17, s0);
5320 __ Fadd(s18, s0, s1);
5321 __ Fsub(s19, s0, s1);
5322 __ Fmul(s20, s0, s1);
5323 __ Fdiv(s21, s0, s1);
5324 __ Fmax(s22, s0, s1);
5325 __ Fmin(s23, s0, s1);
5328 __ Fmadd(s24, s0, s1, s2);
5329 __ Fmsub(s25, s0, s1, s2);
5330 __ Fnmadd(s26, s0, s1, s2);
5331 __ Fnmsub(s27, s0, s1, s2);
5334 __ Msr(FPCR, x0);
5421 __ Mrs(x0, FPCR);
5422 __ Orr(x1, x0, DN_mask);
5423 __ Msr(FPCR, x1);
5427 __ Fmov(d0, n);
5428 __ Fmov(d1, m);
5429 __ Fmov(d2, a);
5433 __ Fmov(d10, d0);
5434 __ Fabs(d11, d0);
5435 __ Fneg(d12, d0);
5438 __ Fsqrt(d13, d0);
5439 __ Frinta(d14, d0);
5440 __ Frintn(d15, d0);
5441 __ Frintz(d16, d0);
5444 __ Fcvt(s17, d0);
5448 __ Fadd(d18, d0, d1);
5449 __ Fsub(d19, d0, d1);
5450 __ Fmul(d20, d0, d1);
5451 __ Fdiv(d21, d0, d1);
5452 __ Fmax(d22, d0, d1);
5453 __ Fmin(d23, d0, d1);
5456 __ Fmadd(d24, d0, d1, d2);
5457 __ Fmsub(d25, d0, d1, d2);
5458 __ Fnmadd(d26, d0, d1, d2);
5459 __ Fnmsub(d27, d0, d1, d2);
5462 __ Msr(FPCR, x0);