Lines Matching defs:Test
39 #include "test/cctest/cctest.h"
53 TEST(MIPS0) {
76 TEST(MIPS1) {
112 TEST(MIPS2) {
121 // ----- Test all instructions.
123 // Test lui, ori, and addiu, used in the li pseudo-instruction.
259 TEST(MIPS3) {
260 // Test floating point instructions.
355 // Double test values.
364 // Single test values.
395 TEST(MIPS4) {
396 // Test moves between floating point and integer registers.
433 // Test sign extension of move operations from coprocessor.
464 TEST(MIPS5) {
465 // Test conversions between doubles and integers.
529 TEST(MIPS6) {
530 // Test simple memory loads and stores.
607 TEST(MIPS7) {
608 // Test floating point compare and branch instructions.
661 // This test-case should have additional tests.
688 TEST(MIPS8) {
690 // Test ROTR and ROTRV instructions.
793 TEST(MIPS9) {
794 // Test BRANCH improvements.
819 TEST(MIPS10) {
820 // Test conversions between doubles and long integers.
821 // Test hos the long ints map to FP regs pairs.
914 TEST(MIPS11) {
915 // Do not run test on MIPS64r6, as these instructions are removed.
917 // Test LWL, LWR, SWL and SWR instructions.
946 // Test all combinations of LWL and vAddr.
963 // Test all combinations of LWR and vAddr.
980 // Test all combinations of SWL and vAddr.
1001 // Test all combinations of SWR and vAddr.
1081 TEST(MIPS12) {
1169 TEST(MIPS13) {
1170 // Test Cvt_d_uw and Trunc_uw_d macros.
1225 TEST(MIPS14) {
1226 // Test round, floor, ceil, trunc, cvt.
1363 TEST(MIPS15) {
1364 // Test chaining of label usages within instructions (issue 1644).
1382 TEST(MIPS16) {
1383 // Test 64-bit memory loads and stores.
1535 TEST(seleqz_selnez) {
1543 typedef struct test {
1556 } Test;
1558 Test test;
1559 // Integer part of test.
1562 __ sw(t3, MemOperand(a0, offsetof(Test, a))); // a = 1
1564 __ sw(t2, MemOperand(a0, offsetof(Test, b))); // b = 0
1566 __ sw(t3, MemOperand(a0, offsetof(Test, c))); // c = 0
1568 __ sw(t3, MemOperand(a0, offsetof(Test, d))); // d = 1
1569 // Floating point part of test.
1570 __ ldc1(f0, MemOperand(a0, offsetof(Test, e)) ); // src
1571 __ ldc1(f2, MemOperand(a0, offsetof(Test, f)) ); // test
1572 __ lwc1(f8, MemOperand(a0, offsetof(Test, i)) ); // src
1573 __ lwc1(f10, MemOperand(a0, offsetof(Test, j)) ); // test
1578 __ sdc1(f4, MemOperand(a0, offsetof(Test, g)) ); // src
1579 __ sdc1(f6, MemOperand(a0, offsetof(Test, h)) ); // src
1580 __ swc1(f12, MemOperand(a0, offsetof(Test, k)) ); // src
1581 __ swc1(f14, MemOperand(a0, offsetof(Test, l)) ); // src
1590 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
1592 CHECK_EQ(test.a, 1);
1593 CHECK_EQ(test.b, 0);
1594 CHECK_EQ(test.c, 0);
1595 CHECK_EQ(test.d, 1);
1614 test.e = inputs_D[i];
1615 test.f = tests_D[j];
1616 test.i = inputs_S[i];
1617 test.j = tests_S[j];
1618 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
1619 CHECK_EQ(test.g, outputs_D[i]);
1620 CHECK_EQ(test.h, 0);
1621 CHECK_EQ(test.k, outputs_S[i]);
1622 CHECK_EQ(test.l, 0);
1624 test.f = tests_D[j+1];
1625 test.j = tests_S[j+1];
1626 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
1627 CHECK_EQ(test.g, 0);
1628 CHECK_EQ(test.h, outputs_D[i]);
1629 CHECK_EQ(test.k, 0);
1630 CHECK_EQ(test.l, outputs_S[i]);
1638 TEST(min_max) {
1657 TestFloat test;
1706 test.a = inputsa[i];
1707 test.b = inputsb[i];
1708 test.e = inputse[i];
1709 test.f = inputsf[i];
1711 CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0);
1713 CHECK_EQ(0, memcmp(&test.c, &outputsdmin[i], sizeof(test.c)));
1714 CHECK_EQ(0, memcmp(&test.d, &outputsdmax[i], sizeof(test.d)));
1715 CHECK_EQ(0, memcmp(&test.g, &outputsfmin[i], sizeof(test.g)));
1716 CHECK_EQ(0, memcmp(&test.h, &outputsfmax[i], sizeof(test.h)));
1722 TEST(rint_d) {
1737 TestFloat test;
1816 test.fcsr = fcsr_inputs[j];
1818 test.a = inputs[i];
1819 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
1820 CHECK_EQ(test.b, outputs[j][i]);
1827 TEST(sel) {
1835 typedef struct test {
1842 } Test;
1844 Test test;
1845 __ ldc1(f0, MemOperand(a0, offsetof(Test, dd)) ); // test
1846 __ ldc1(f2, MemOperand(a0, offsetof(Test, ds)) ); // src1
1847 __ ldc1(f4, MemOperand(a0, offsetof(Test, dt)) ); // src2
1848 __ lwc1(f6, MemOperand(a0, offsetof(Test, fd)) ); // test
1849 __ lwc1(f8, MemOperand(a0, offsetof(Test, fs)) ); // src1
1850 __ lwc1(f10, MemOperand(a0, offsetof(Test, ft)) ); // src2
1853 __ sdc1(f0, MemOperand(a0, offsetof(Test, dd)) );
1854 __ swc1(f6, MemOperand(a0, offsetof(Test, fd)) );
1880 test.dt = inputs_dt[i];
1881 test.dd = tests_D[j];
1882 test.ds = inputs_ds[i];
1883 test.ft = inputs_ft[i];
1884 test.fd = tests_S[j];
1885 test.fs = inputs_fs[i];
1886 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
1887 CHECK_EQ(test.dd, inputs_ds[i]);
1888 CHECK_EQ(test.fd, inputs_fs[i]);
1890 test.dd = tests_D[j+1];
1891 test.fd = tests_S[j+1];
1892 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
1893 CHECK_EQ(test.dd, inputs_dt[i]);
1894 CHECK_EQ(test.fd, inputs_ft[i]);
1901 TEST(rint_s) {
1916 TestFloat test;
1997 test.fcsr = fcsr_inputs[j];
1999 test.a = inputs[i];
2000 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2001 CHECK_EQ(test.b, outputs[j][i]);
2008 TEST(mina_maxa) {
2034 TestFloat test;
2082 test.a = inputsa[i];
2083 test.b = inputsb[i];
2084 test.c = inputsc[i];
2085 test.d = inputsd[i];
2086 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2089 CHECK_EQ(test.resd, resd[i]);
2090 CHECK_EQ(test.resf, resf[i]);
2091 CHECK_EQ(test.resd1, resd1[i]);
2092 CHECK_EQ(test.resf1, resf1[i]);
2094 CHECK(std::isnan(test.resd));
2095 CHECK(std::isnan(test.resf));
2096 CHECK(std::isnan(test.resd1));
2097 CHECK(std::isnan(test.resf1));
2106 TEST(trunc_l) {
2120 }Test;
2148 __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
2149 __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
2150 __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
2153 __ sdc1(f8, MemOperand(a0, offsetof(Test, c)) );
2154 __ sdc1(f10, MemOperand(a0, offsetof(Test, d)) );
2157 Test test;
2164 test.a = inputs_D[i];
2165 test.b = inputs_S[i];
2166 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2167 if ((test.isNaN2008 & kFCSRNaN2008FlagMask) &&
2169 CHECK_EQ(test.c, outputsNaN2008[i]);
2171 CHECK_EQ(test.c, outputs[i]);
2173 CHECK_EQ(test.d, test.c);
2179 TEST(movz_movn) {
2202 TestFloat test;
2245 test.a = inputs_D[i];
2246 test.c = inputs_S[i];
2248 test.rt = 1;
2249 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2250 CHECK_EQ(test.b, test.bold);
2251 CHECK_EQ(test.d, test.dold);
2252 CHECK_EQ(test.b1, outputs_D[i]);
2253 CHECK_EQ(test.d1, outputs_S[i]);
2255 test.rt = 0;
2256 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2257 CHECK_EQ(test.b, outputs_D[i]);
2258 CHECK_EQ(test.d, outputs_S[i]);
2259 CHECK_EQ(test.b1, test.bold1);
2260 CHECK_EQ(test.d1, test.dold1);
2266 TEST(movt_movd) {
2286 TestFloat test;
2303 test.srcd = inputs_D[i];
2304 test.srcf = inputs_S[i];
2307 test.cc = condition_flags[j];
2308 if (test.cc == 0) {
2309 test.fcsr = 1 << 23;
2311 test.fcsr = 1 << (24+condition_flags[j]);
2326 __ movt_s(f12, f4, test.cc);
2327 __ movt_d(f10, f2, test.cc);
2332 __ movf_s(f12, f4, test.cc);
2333 __ movf_d(f10, f2, test.cc);
2346 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2347 CHECK_EQ(test.dstf, outputs_S[i]);
2348 CHECK_EQ(test.dstd, outputs_D[i]);
2349 CHECK_EQ(test.dstf1, test.dstfold1);
2350 CHECK_EQ(test.dstd1, test.dstdold1);
2351 test.fcsr = 0;
2352 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2353 CHECK_EQ(test.dstf, test.dstfold);
2354 CHECK_EQ(test.dstd, test.dstdold);
2355 CHECK_EQ(test.dstf1, outputs_S[i]);
2356 CHECK_EQ(test.dstd1, outputs_D[i]);
2365 TEST(cvt_w_d) {
2375 }Test;
2416 __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
2417 __ lw(t0, MemOperand(a0, offsetof(Test, fcsr)) );
2421 __ swc1(f8, MemOperand(a0, offsetof(Test, b)) );
2425 Test test;
2432 test.fcsr = fcsr_inputs[j];
2434 test.a = inputs[i];
2435 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2436 CHECK_EQ(test.b, outputs[j][i]);
2442 TEST(trunc_w) {
2454 }Test;
2483 __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
2484 __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
2485 __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
2488 __ swc1(f8, MemOperand(a0, offsetof(Test, c)) );
2489 __ swc1(f10, MemOperand(a0, offsetof(Test, d)) );
2492 Test test;
2499 test.a = inputs_D[i];
2500 test.b = inputs_S[i];
2501 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2502 if ((test.isNaN2008 & kFCSRNaN2008FlagMask) && kArchVariant == kMips64r6) {
2503 CHECK_EQ(test.c, outputsNaN2008[i]);
2505 CHECK_EQ(test.c, outputs[i]);
2507 CHECK_EQ(test.d, test.c);
2512 TEST(round_w) {
2524 }Test;
2552 __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
2553 __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
2554 __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
2557 __ swc1(f8, MemOperand(a0, offsetof(Test, c)) );
2558 __ swc1(f10, MemOperand(a0, offsetof(Test, d)) );
2561 Test test;
2568 test.a = inputs_D[i];
2569 test.b = inputs_S[i];
2570 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2571 if ((test.isNaN2008 & kFCSRNaN2008FlagMask) && kArchVariant == kMips64r6) {
2572 CHECK_EQ(test.c, outputsNaN2008[i]);
2574 CHECK_EQ(test.c, outputs[i]);
2576 CHECK_EQ(test.d, test.c);
2581 TEST(round_l) {
2594 }Test;
2623 __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
2624 __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
2625 __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
2628 __ sdc1(f8, MemOperand(a0, offsetof(Test, c)) );
2629 __ sdc1(f10, MemOperand(a0, offsetof(Test, d)) );
2632 Test test;
2639 test.a = inputs_D[i];
2640 test.b = inputs_S[i];
2641 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2642 if ((test.isNaN2008 & kFCSRNaN2008FlagMask) &&
2644 CHECK_EQ(test.c, outputsNaN2008[i]);
2646 CHECK_EQ(test.c, outputs[i]);
2648 CHECK_EQ(test.d, test.c);
2653 TEST(sub) {
2669 TestFloat test;
2711 test.a = inputfs_S[i];
2712 test.b = inputft_S[i];
2713 test.c = inputfs_D[i];
2714 test.d = inputft_D[i];
2715 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2716 CHECK_EQ(test.resultS, outputs_S[i]);
2717 CHECK_EQ(test.resultD, outputs_D[i]);
2722 TEST(sqrt_rsqrt_recip) {
2743 TestFloat test;
2787 test.a = inputs_S[i];
2788 test.c = inputs_D[i];
2790 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2792 CHECK_EQ(test.resultS, outputs_S[i]);
2793 CHECK_EQ(test.resultD, outputs_D[i]);
2796 f1 = test.resultS1 - 1.0F/outputs_S[i];
2799 d1 = test.resultD1 - 1.0L/outputs_D[i];
2802 f1 = test.resultS2 - 1.0F/inputs_S[i];
2805 d1 = test.resultD2 - 1.0L/inputs_D[i];
2809 CHECK_EQ(test.resultS1, 1.0F/outputs_S[i]);
2810 CHECK_EQ(test.resultD1, 1.0L/outputs_D[i]);
2811 CHECK_EQ(test.resultS2, 1.0F/inputs_S[i]);
2812 CHECK_EQ(test.resultD2, 1.0L/inputs_D[i]);
2818 TEST(neg) {
2832 TestFloat test;
2862 test.a = inputs_S[i];
2863 test.c = inputs_D[i];
2864 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2865 CHECK_EQ(test.resultS, outputs_S[i]);
2866 CHECK_EQ(test.resultD, outputs_D[i]);
2872 TEST(mul) {
2888 TestFloat test;
2920 test.a = inputfs_S[i];
2921 test.b = inputft_S[i];
2922 test.c = inputfs_D[i];
2923 test.d = inputft_D[i];
2924 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2925 CHECK_EQ(test.resultS, inputfs_S[i]*inputft_S[i]);
2926 CHECK_EQ(test.resultD, inputfs_D[i]*inputft_D[i]);
2931 TEST(mov) {
2945 TestFloat test;
2975 test.a = inputs_D[i];
2976 test.c = inputs_S[i];
2978 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
2979 CHECK_EQ(test.b, outputs_D[i]);
2980 CHECK_EQ(test.d, outputs_S[i]);
2985 TEST(floor_w) {
2997 }Test;
3026 __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
3027 __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
3028 __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
3031 __ swc1(f8, MemOperand(a0, offsetof(Test, c)) );
3032 __ swc1(f10, MemOperand(a0, offsetof(Test, d)) );
3035 Test test;
3042 test.a = inputs_D[i];
3043 test.b = inputs_S[i];
3044 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3045 if ((test.isNaN2008 & kFCSRNaN2008FlagMask) && kArchVariant == kMips64r6) {
3046 CHECK_EQ(test.c, outputsNaN2008[i]);
3048 CHECK_EQ(test.c, outputs[i]);
3050 CHECK_EQ(test.d, test.c);
3055 TEST(floor_l) {
3068 }Test;
3097 __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
3098 __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
3099 __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
3102 __ sdc1(f8, MemOperand(a0, offsetof(Test, c)) );
3103 __ sdc1(f10, MemOperand(a0, offsetof(Test, d)) );
3106 Test test;
3113 test.a = inputs_D[i];
3114 test.b = inputs_S[i];
3115 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3116 if ((test.isNaN2008 & kFCSRNaN2008FlagMask) &&
3118 CHECK_EQ(test.c, outputsNaN2008[i]);
3120 CHECK_EQ(test.c, outputs[i]);
3122 CHECK_EQ(test.d, test.c);
3127 TEST(ceil_w) {
3139 }Test;
3168 __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
3169 __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
3170 __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
3173 __ swc1(f8, MemOperand(a0, offsetof(Test, c)) );
3174 __ swc1(f10, MemOperand(a0, offsetof(Test, d)) );
3177 Test test;
3184 test.a = inputs_D[i];
3185 test.b = inputs_S[i];
3186 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3187 if ((test.isNaN2008 & kFCSRNaN2008FlagMask) && kArchVariant == kMips64r6) {
3188 CHECK_EQ(test.c, outputsNaN2008[i]);
3190 CHECK_EQ(test.c, outputs[i]);
3192 CHECK_EQ(test.d, test.c);
3197 TEST(ceil_l) {
3210 }Test;
3239 __ sw(t1, MemOperand(a0, offsetof(Test, isNaN2008)));
3240 __ ldc1(f4, MemOperand(a0, offsetof(Test, a)) );
3241 __ lwc1(f6, MemOperand(a0, offsetof(Test, b)) );
3244 __ sdc1(f8, MemOperand(a0, offsetof(Test, c)) );
3245 __ sdc1(f10, MemOperand(a0, offsetof(Test, d)) );
3248 Test test;
3255 test.a = inputs_D[i];
3256 test.b = inputs_S[i];
3257 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3258 if ((test.isNaN2008 & kFCSRNaN2008FlagMask) &&
3260 CHECK_EQ(test.c, outputsNaN2008[i]);
3262 CHECK_EQ(test.c, outputs[i]);
3264 CHECK_EQ(test.d, test.c);
3269 TEST(jump_tables1) {
3270 // Test jump tables with forward jumps.
3337 TEST(jump_tables2) {
3338 // Test jump tables with backward jumps.
3407 TEST(jump_tables3) {
3408 // Test jump tables with backward jumps and embedded heap objects.
3491 TEST(BITSWAP) {
3492 // Test BITSWAP
3567 TEST(class_fmt) {
3569 // Test CLASS.fmt instruction.
3692 // Double test values.
3703 // Float test values
3745 TEST(ABS) {
3758 TestFloat test;
3785 test.a = -2.0;
3786 test.b = -2.0;
3787 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3788 CHECK_EQ(test.a, 2.0);
3789 CHECK_EQ(test.b, 2.0);
3791 test.a = 2.0;
3792 test.b = 2.0;
3793 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3794 CHECK_EQ(test.a, 2.0);
3795 CHECK_EQ(test.b, 2.0);
3798 test.a = std::numeric_limits<double>::max();
3799 test.b = std::numeric_limits<float>::max();
3800 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3801 CHECK_EQ(test.a, std::numeric_limits<double>::max());
3802 CHECK_EQ(test.b, std::numeric_limits<float>::max());
3805 test.a = -std::numeric_limits<double>::max(); // lowest()
3806 test.b = -std::numeric_limits<float>::max(); // lowest()
3807 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3808 CHECK_EQ(test.a, std::numeric_limits<double>::max());
3809 CHECK_EQ(test.b, std::numeric_limits<float>::max());
3812 test.a = -std::numeric_limits<double>::min();
3813 test.b = -std::numeric_limits<float>::min();
3814 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3815 CHECK_EQ(test.a, std::numeric_limits<double>::min());
3816 CHECK_EQ(test.b, std::numeric_limits<float>::min());
3819 test.a = -std::numeric_limits<double>::max()
3821 test.b = -std::numeric_limits<float>::max()
3823 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3824 CHECK_EQ(test.a, std::numeric_limits<double>::max()
3826 CHECK_EQ(test.b, std::numeric_limits<float>::max()
3829 test.a = std::numeric_limits<double>::quiet_NaN();
3830 test.b = std::numeric_limits<float>::quiet_NaN();
3831 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3832 CHECK_EQ(std::isnan(test.a), true);
3833 CHECK_EQ(std::isnan(test.b), true);
3835 test.a = std::numeric_limits<double>::signaling_NaN();
3836 test.b = std::numeric_limits<float>::signaling_NaN();
3837 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3838 CHECK_EQ(std::isnan(test.a), true);
3839 CHECK_EQ(std::isnan(test.b), true);
3843 TEST(ADD_FMT) {
3858 TestFloat test;
3878 test.a = 2.0;
3879 test.b = 3.0;
3880 test.fa = 2.0;
3881 test.fb = 3.0;
3882 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3883 CHECK_EQ(test.c, 5.0);
3884 CHECK_EQ(test.fc, 5.0);
3886 test.a = std::numeric_limits<double>::max();
3887 test.b = -std::numeric_limits<double>::max(); // lowest()
3888 test.fa = std::numeric_limits<float>::max();
3889 test.fb = -std::numeric_limits<float>::max(); // lowest()
3890 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3891 CHECK_EQ(test.c, 0.0);
3892 CHECK_EQ(test.fc, 0.0);
3894 test.a = std::numeric_limits<double>::max();
3895 test.b = std::numeric_limits<double>::max();
3896 test.fa = std::numeric_limits<float>::max();
3897 test.fb = std::numeric_limits<float>::max();
3898 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3899 CHECK_EQ(std::isfinite(test.c), false);
3900 CHECK_EQ(std::isfinite(test.fc), false);
3902 test.a = 5.0;
3903 test.b = std::numeric_limits<double>::signaling_NaN();
3904 test.fa = 5.0;
3905 test.fb = std::numeric_limits<float>::signaling_NaN();
3906 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
3907 CHECK_EQ(std::isnan(test.c), true);
3908 CHECK_EQ(std::isnan(test.fc), true);
3912 TEST(C_COND_FMT) {
3943 TestFloat test;
4033 test.dOp1 = 2.0;
4034 test.dOp2 = 3.0;
4035 test.fOp1 = 2.0;
4036 test.fOp2 = 3.0;
4037 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4038 CHECK_EQ(test.dF, 0U);
4039 CHECK_EQ(test.dUn, 0U);
4040 CHECK_EQ(test.dEq, 0U);
4041 CHECK_EQ(test.dUeq, 0U);
4042 CHECK_EQ(test.dOlt, 1U);
4043 CHECK_EQ(test.dUlt, 1U);
4044 CHECK_EQ(test.dOle, 1U);
4045 CHECK_EQ(test.dUle, 1U);
4046 CHECK_EQ(test.fF, 0U);
4047 CHECK_EQ(test.fUn, 0U);
4048 CHECK_EQ(test.fEq, 0U);
4049 CHECK_EQ(test.fUeq, 0U);
4050 CHECK_EQ(test.fOlt, 1U);
4051 CHECK_EQ(test.fUlt, 1U);
4052 CHECK_EQ(test.fOle, 1U);
4053 CHECK_EQ(test.fUle, 1U);
4055 test.dOp1 = std::numeric_limits<double>::max();
4056 test.dOp2 = std::numeric_limits<double>::min();
4057 test.fOp1 = std::numeric_limits<float>::min();
4058 test.fOp2 = -std::numeric_limits<float>::max(); // lowest()
4059 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4060 CHECK_EQ(test.dF, 0U);
4061 CHECK_EQ(test.dUn, 0U);
4062 CHECK_EQ(test.dEq, 0U);
4063 CHECK_EQ(test.dUeq, 0U);
4064 CHECK_EQ(test.dOlt, 0U);
4065 CHECK_EQ(test.dUlt, 0U);
4066 CHECK_EQ(test.dOle, 0U);
4067 CHECK_EQ(test.dUle, 0U);
4068 CHECK_EQ(test.fF, 0U);
4069 CHECK_EQ(test.fUn, 0U);
4070 CHECK_EQ(test.fEq, 0U);
4071 CHECK_EQ(test.fUeq, 0U);
4072 CHECK_EQ(test.fOlt, 0U);
4073 CHECK_EQ(test.fUlt, 0U);
4074 CHECK_EQ(test.fOle, 0U);
4075 CHECK_EQ(test.fUle, 0U);
4077 test.dOp1 = -std::numeric_limits<double>::max(); // lowest()
4078 test.dOp2 = -std::numeric_limits<double>::max(); // lowest()
4079 test.fOp1 = std::numeric_limits<float>::max();
4080 test.fOp2 = std::numeric_limits<float>::max();
4081 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4082 CHECK_EQ(test.dF, 0U);
4083 CHECK_EQ(test.dUn, 0U);
4084 CHECK_EQ(test.dEq, 1U);
4085 CHECK_EQ(test.dUeq, 1U);
4086 CHECK_EQ(test.dOlt, 0U);
4087 CHECK_EQ(test.dUlt, 0U);
4088 CHECK_EQ(test.dOle, 1U);
4089 CHECK_EQ(test.dUle, 1U);
4090 CHECK_EQ(test.fF, 0U);
4091 CHECK_EQ(test.fUn, 0U);
4092 CHECK_EQ(test.fEq, 1U);
4093 CHECK_EQ(test.fUeq, 1U);
4094 CHECK_EQ(test.fOlt, 0U);
4095 CHECK_EQ(test.fUlt, 0U);
4096 CHECK_EQ(test.fOle, 1U);
4097 CHECK_EQ(test.fUle, 1U);
4099 test.dOp1 = std::numeric_limits<double>::quiet_NaN();
4100 test.dOp2 = 0.0;
4101 test.fOp1 = std::numeric_limits<float>::quiet_NaN();
4102 test.fOp2 = 0.0;
4103 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4104 CHECK_EQ(test.dF, 0U);
4105 CHECK_EQ(test.dUn, 1U);
4106 CHECK_EQ(test.dEq, 0U);
4107 CHECK_EQ(test.dUeq, 1U);
4108 CHECK_EQ(test.dOlt, 0U);
4109 CHECK_EQ(test.dUlt, 1U);
4110 CHECK_EQ(test.dOle, 0U);
4111 CHECK_EQ(test.dUle, 1U);
4112 CHECK_EQ(test.fF, 0U);
4113 CHECK_EQ(test.fUn, 1U);
4114 CHECK_EQ(test.fEq, 0U);
4115 CHECK_EQ(test.fUeq, 1U);
4116 CHECK_EQ(test.fOlt, 0U);
4117 CHECK_EQ(test.fUlt, 1U);
4118 CHECK_EQ(test.fOle, 0U);
4119 CHECK_EQ(test.fUle, 1U);
4124 TEST(CMP_COND_FMT) {
4161 TestFloat test;
4239 test.dOp1 = 2.0;
4240 test.dOp2 = 3.0;
4241 test.fOp1 = 2.0;
4242 test.fOp2 = 3.0;
4243 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4244 CHECK_EQ(bit_cast<uint64_t>(test.dF), dFalse);
4245 CHECK_EQ(bit_cast<uint64_t>(test.dUn), dFalse);
4246 CHECK_EQ(bit_cast<uint64_t>(test.dEq), dFalse);
4247 CHECK_EQ(bit_cast<uint64_t>(test.dUeq), dFalse);
4248 CHECK_EQ(bit_cast<uint64_t>(test.dOlt), dTrue);
4249 CHECK_EQ(bit_cast<uint64_t>(test.dUlt), dTrue);
4250 CHECK_EQ(bit_cast<uint64_t>(test.dOle), dTrue);
4251 CHECK_EQ(bit_cast<uint64_t>(test.dUle), dTrue);
4252 CHECK_EQ(bit_cast<uint64_t>(test.dOr), dTrue);
4253 CHECK_EQ(bit_cast<uint64_t>(test.dUne), dTrue);
4254 CHECK_EQ(bit_cast<uint64_t>(test.dNe), dTrue);
4255 CHECK_EQ(bit_cast<uint32_t>(test.fF), fFalse);
4256 CHECK_EQ(bit_cast<uint32_t>(test.fUn), fFalse);
4257 CHECK_EQ(bit_cast<uint32_t>(test.fEq), fFalse);
4258 CHECK_EQ(bit_cast<uint32_t>(test.fUeq), fFalse);
4259 CHECK_EQ(bit_cast<uint32_t>(test.fOlt), fTrue);
4260 CHECK_EQ(bit_cast<uint32_t>(test.fUlt), fTrue);
4261 CHECK_EQ(bit_cast<uint32_t>(test.fOle), fTrue);
4262 CHECK_EQ(bit_cast<uint32_t>(test.fUle), fTrue);
4264 test.dOp1 = std::numeric_limits<double>::max();
4265 test.dOp2 = std::numeric_limits<double>::min();
4266 test.fOp1 = std::numeric_limits<float>::min();
4267 test.fOp2 = -std::numeric_limits<float>::max(); // lowest()
4268 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4269 CHECK_EQ(bit_cast<uint64_t>(test.dF), dFalse);
4270 CHECK_EQ(bit_cast<uint64_t>(test.dUn), dFalse);
4271 CHECK_EQ(bit_cast<uint64_t>(test.dEq), dFalse);
4272 CHECK_EQ(bit_cast<uint64_t>(test.dUeq), dFalse);
4273 CHECK_EQ(bit_cast<uint64_t>(test.dOlt), dFalse);
4274 CHECK_EQ(bit_cast<uint64_t>(test.dUlt), dFalse);
4275 CHECK_EQ(bit_cast<uint64_t>(test.dOle), dFalse);
4276 CHECK_EQ(bit_cast<uint64_t>(test.dUle), dFalse);
4277 CHECK_EQ(bit_cast<uint64_t>(test.dOr), dTrue);
4278 CHECK_EQ(bit_cast<uint64_t>(test.dUne), dTrue);
4279 CHECK_EQ(bit_cast<uint64_t>(test.dNe), dTrue);
4280 CHECK_EQ(bit_cast<uint32_t>(test.fF), fFalse);
4281 CHECK_EQ(bit_cast<uint32_t>(test.fUn), fFalse);
4282 CHECK_EQ(bit_cast<uint32_t>(test.fEq), fFalse);
4283 CHECK_EQ(bit_cast<uint32_t>(test.fUeq), fFalse);
4284 CHECK_EQ(bit_cast<uint32_t>(test.fOlt), fFalse);
4285 CHECK_EQ(bit_cast<uint32_t>(test.fUlt), fFalse);
4286 CHECK_EQ(bit_cast<uint32_t>(test.fOle), fFalse);
4287 CHECK_EQ(bit_cast<uint32_t>(test.fUle), fFalse);
4289 test.dOp1 = -std::numeric_limits<double>::max(); // lowest()
4290 test.dOp2 = -std::numeric_limits<double>::max(); // lowest()
4291 test.fOp1 = std::numeric_limits<float>::max();
4292 test.fOp2 = std::numeric_limits<float>::max();
4293 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4294 CHECK_EQ(bit_cast<uint64_t>(test.dF), dFalse);
4295 CHECK_EQ(bit_cast<uint64_t>(test.dUn), dFalse);
4296 CHECK_EQ(bit_cast<uint64_t>(test.dEq), dTrue);
4297 CHECK_EQ(bit_cast<uint64_t>(test.dUeq), dTrue);
4298 CHECK_EQ(bit_cast<uint64_t>(test.dOlt), dFalse);
4299 CHECK_EQ(bit_cast<uint64_t>(test.dUlt), dFalse);
4300 CHECK_EQ(bit_cast<uint64_t>(test.dOle), dTrue);
4301 CHECK_EQ(bit_cast<uint64_t>(test.dUle), dTrue);
4302 CHECK_EQ(bit_cast<uint64_t>(test.dOr), dTrue);
4303 CHECK_EQ(bit_cast<uint64_t>(test.dUne), dFalse);
4304 CHECK_EQ(bit_cast<uint64_t>(test.dNe), dFalse);
4305 CHECK_EQ(bit_cast<uint32_t>(test.fF), fFalse);
4306 CHECK_EQ(bit_cast<uint32_t>(test.fUn), fFalse);
4307 CHECK_EQ(bit_cast<uint32_t>(test.fEq), fTrue);
4308 CHECK_EQ(bit_cast<uint32_t>(test.fUeq), fTrue);
4309 CHECK_EQ(bit_cast<uint32_t>(test.fOlt), fFalse);
4310 CHECK_EQ(bit_cast<uint32_t>(test.fUlt), fFalse);
4311 CHECK_EQ(bit_cast<uint32_t>(test.fOle), fTrue);
4312 CHECK_EQ(bit_cast<uint32_t>(test.fUle), fTrue);
4314 test.dOp1 = std::numeric_limits<double>::quiet_NaN();
4315 test.dOp2 = 0.0;
4316 test.fOp1 = std::numeric_limits<float>::quiet_NaN();
4317 test.fOp2 = 0.0;
4318 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4319 CHECK_EQ(bit_cast<uint64_t>(test.dF), dFalse);
4320 CHECK_EQ(bit_cast<uint64_t>(test.dUn), dTrue);
4321 CHECK_EQ(bit_cast<uint64_t>(test.dEq), dFalse);
4322 CHECK_EQ(bit_cast<uint64_t>(test.dUeq), dTrue);
4323 CHECK_EQ(bit_cast<uint64_t>(test.dOlt), dFalse);
4324 CHECK_EQ(bit_cast<uint64_t>(test.dUlt), dTrue);
4325 CHECK_EQ(bit_cast<uint64_t>(test.dOle), dFalse);
4326 CHECK_EQ(bit_cast<uint64_t>(test.dUle), dTrue);
4327 CHECK_EQ(bit_cast<uint64_t>(test.dOr), dFalse);
4328 CHECK_EQ(bit_cast<uint64_t>(test.dUne), dTrue);
4329 CHECK_EQ(bit_cast<uint64_t>(test.dNe), dFalse);
4330 CHECK_EQ(bit_cast<uint32_t>(test.fF), fFalse);
4331 CHECK_EQ(bit_cast<uint32_t>(test.fUn), fTrue);
4332 CHECK_EQ(bit_cast<uint32_t>(test.fEq), fFalse);
4333 CHECK_EQ(bit_cast<uint32_t>(test.fUeq), fTrue);
4334 CHECK_EQ(bit_cast<uint32_t>(test.fOlt), fFalse);
4335 CHECK_EQ(bit_cast<uint32_t>(test.fUlt), fTrue);
4336 CHECK_EQ(bit_cast<uint32_t>(test.fOle), fFalse);
4337 CHECK_EQ(bit_cast<uint32_t>(test.fUle), fTrue);
4342 TEST(CVT) {
4374 TestFloat test;
4413 test.cvt_d_s_in = -0.51;
4414 test.cvt_d_w_in = -1;
4415 test.cvt_d_l_in = -1;
4416 test.cvt_l_s_in = -0.51;
4417 test.cvt_l_d_in = -0.51;
4418 test.cvt_s_d_in = -0.51;
4419 test.cvt_s_w_in = -1;
4420 test.cvt_s_l_in = -1;
4421 test.cvt_w_s_in = -0.51;
4422 test.cvt_w_d_in = -0.51;
4424 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4425 CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
4426 CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
4427 CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
4428 CHECK_EQ(test.cvt_l_s_out, -1);
4429 CHECK_EQ(test.cvt_l_d_out, -1);
4430 CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
4431 CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
4432 CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
4433 CHECK_EQ(test.cvt_w_s_out, -1);
4434 CHECK_EQ(test.cvt_w_d_out, -1);
4437 test.cvt_d_s_in = 0.49;
4438 test.cvt_d_w_in = 1;
4439 test.cvt_d_l_in = 1;
4440 test.cvt_l_s_in = 0.49;
4441 test.cvt_l_d_in = 0.49;
4442 test.cvt_s_d_in = 0.49;
4443 test.cvt_s_w_in = 1;
4444 test.cvt_s_l_in = 1;
4445 test.cvt_w_s_in = 0.49;
4446 test.cvt_w_d_in = 0.49;
4448 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4449 CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
4450 CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
4451 CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
4452 CHECK_EQ(test.cvt_l_s_out, 0);
4453 CHECK_EQ(test.cvt_l_d_out, 0);
4454 CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
4455 CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
4456 CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
4457 CHECK_EQ(test.cvt_w_s_out, 0);
4458 CHECK_EQ(test.cvt_w_d_out, 0);
4460 test.cvt_d_s_in = std::numeric_limits<float>::max();
4461 test.cvt_d_w_in = std::numeric_limits<int32_t>::max();
4462 test.cvt_d_l_in = std::numeric_limits<int64_t>::max();
4463 test.cvt_l_s_in = std::numeric_limits<float>::max();
4464 test.cvt_l_d_in = std::numeric_limits<double>::max();
4465 test.cvt_s_d_in = std::numeric_limits<double>::max();
4466 test.cvt_s_w_in = std::numeric_limits<int32_t>::max();
4467 test.cvt_s_l_in = std::numeric_limits<int64_t>::max();
4468 test.cvt_w_s_in = std::numeric_limits<float>::max();
4469 test.cvt_w_d_in = std::numeric_limits<double>::max();
4471 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4472 CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
4473 CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
4474 CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
4475 CHECK_EQ(test.cvt_l_s_out, std::numeric_limits<int64_t>::max());
4476 CHECK_EQ(test.cvt_l_d_out, std::numeric_limits<int64_t>::max());
4477 CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
4478 CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
4479 CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
4480 CHECK_EQ(test.cvt_w_s_out, std::numeric_limits<int32_t>::max());
4481 CHECK_EQ(test.cvt_w_d_out, std::numeric_limits<int32_t>::max());
4484 test.cvt_d_s_in = -std::numeric_limits<float>::max(); // lowest()
4485 test.cvt_d_w_in = std::numeric_limits<int32_t>::min(); // lowest()
4486 test.cvt_d_l_in = std::numeric_limits<int64_t>::min(); // lowest()
4487 test.cvt_l_s_in = -std::numeric_limits<float>::max(); // lowest()
4488 test.cvt_l_d_in = -std::numeric_limits<double>::max(); // lowest()
4489 test.cvt_s_d_in = -std::numeric_limits<double>::max(); // lowest()
4490 test.cvt_s_w_in = std::numeric_limits<int32_t>::min(); // lowest()
4491 test.cvt_s_l_in = std::numeric_limits<int64_t>::min(); // lowest()
4492 test.cvt_w_s_in = -std::numeric_limits<float>::max(); // lowest()
4493 test.cvt_w_d_in = -std::numeric_limits<double>::max(); // lowest()
4495 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4496 CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
4497 CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
4498 CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
4501 // in this test case, therefore modifying the test
4502 CHECK(test.cvt_l_s_out == std::numeric_limits<int64_t>::min() ||
4503 test.cvt_l_s_out == std::numeric_limits<int64_t>::max());
4504 CHECK(test.cvt_l_d_out == std::numeric_limits<int64_t>::min() ||
4505 test.cvt_l_d_out == std::numeric_limits<int64_t>::max());
4506 CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
4507 CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
4508 CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
4509 CHECK(test.cvt_w_s_out == std::numeric_limits<int32_t>::min() ||
4510 test.cvt_w_s_out == std::numeric_limits<int32_t>::max());
4511 CHECK(test.cvt_w_d_out == std::numeric_limits<int32_t>::min() ||
4512 test.cvt_w_d_out == std::numeric_limits<int32_t>::max());
4515 test.cvt_d_s_in = std::numeric_limits<float>::min();
4516 test.cvt_d_w_in = std::numeric_limits<int32_t>::min();
4517 test.cvt_d_l_in = std::numeric_limits<int64_t>::min();
4518 test.cvt_l_s_in = std::numeric_limits<float>::min();
4519 test.cvt_l_d_in = std::numeric_limits<double>::min();
4520 test.cvt_s_d_in = std::numeric_limits<double>::min();
4521 test.cvt_s_w_in = std::numeric_limits<int32_t>::min();
4522 test.cvt_s_l_in = std::numeric_limits<int64_t>::min();
4523 test.cvt_w_s_in = std::numeric_limits<float>::min();
4524 test.cvt_w_d_in = std::numeric_limits<double>::min();
4526 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4527 CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
4528 CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
4529 CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
4530 CHECK_EQ(test.cvt_l_s_out, 0);
4531 CHECK_EQ(test.cvt_l_d_out, 0);
4532 CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
4533 CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
4534 CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
4535 CHECK_EQ(test.cvt_w_s_out, 0);
4536 CHECK_EQ(test.cvt_w_d_out, 0);
4540 TEST(DIV_FMT) {
4546 typedef struct test {
4553 } Test;
4555 Test test;
4562 __ ldc1(f4, MemOperand(a0, offsetof(Test, dOp1)) );
4563 __ ldc1(f2, MemOperand(a0, offsetof(Test, dOp2)) );
4566 __ sdc1(f6, MemOperand(a0, offsetof(Test, dRes)) );
4568 __ lwc1(f4, MemOperand(a0, offsetof(Test, fOp1)) );
4569 __ lwc1(f2, MemOperand(a0, offsetof(Test, fOp2)) );
4572 __ swc1(f6, MemOperand(a0, offsetof(Test, fRes)) );
4585 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4621 test.dOp1 = dOp1[i];
4622 test.dOp2 = dOp2[i];
4623 test.fOp1 = fOp1[i];
4624 test.fOp2 = fOp2[i];
4626 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4627 CHECK_EQ(test.dRes, dRes[i]);
4628 CHECK_EQ(test.fRes, fRes[i]);
4631 test.dOp1 = DBL_MAX;
4632 test.dOp2 = -0.0;
4633 test.fOp1 = FLT_MAX;
4634 test.fOp2 = -0.0;
4636 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4637 CHECK_EQ(false, std::isfinite(test.dRes));
4638 CHECK_EQ(false, std::isfinite(test.fRes));
4640 test.dOp1 = 0.0;
4641 test.dOp2 = -0.0;
4642 test.fOp1 = 0.0;
4643 test.fOp2 = -0.0;
4645 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4646 CHECK_EQ(true, std::isnan(test.dRes));
4647 CHECK_EQ(true, std::isnan(test.fRes));
4649 test
4650 test.dOp2 = -5.0;
4651 test.fOp1 = std::numeric_limits<float>::quiet_NaN();
4652 test.fOp2 = -5.0;
4654 (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
4655 CHECK_EQ(true, std::isnan(test.dRes));
4656 CHECK_EQ(true, std::isnan(test.fRes));
4684 TEST(r6_align) {
4736 TEST(r6_dalign) {
4796 TEST(r6_aluipc) {
4850 TEST(r6_auipc) {
4983 TEST(r6_aui_family) {
4993 // AUI test cases.
5010 // DAUI test cases.
5027 // DATI test cases.
5044 // DAHI test cases.
5084 TEST(li_macro) {
5155 TEST(r6_lwpc) {
5231 TEST(r6_lwupc) {
5315 TEST(r6_jic) {
5387 TEST(r6_beqzc) {
5481 TEST(r6_jialc) {
5534 TEST(r6_addiupc) {
5609 TEST(r6_ldpc) {
5698 TEST(r6_bc) {
5780 TEST(r6_balc) {
5830 TEST(dsll) {
5886 TEST(bal) {
5906 TEST(Trampoline) {
