3 ===============================================================================
5 This C source file is part of TestFloat, Release 2a, a package of programs
6 for testing the correctness of floating-point arithmetic complying to the
7 IEC/IEEE Standard for Floating-Point.
9 Written by John R. Hauser. More information is available through the Web
10 page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
12 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
13 has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
14 TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
15 PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
16 AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
18 Derivative works are acceptable, even for commercial purposes, so long as
19 (1) they include prominent notice that the work is derivative, and (2) they
20 include prominent notice akin to these four paragraphs for those parts of
21 this code that are retained.
23 ===============================================================================
27 #include "softfloat.h"
28 #include "testCases.h"
29 #include "testLoops.h"
30 #include "systmodes.h"
31 #include "systflags.h"
32 #include "systfloat.h"
33 #include "testFunction.h"
35 const functionT functions[ NUM_FUNCTIONS ] = {
37 { "int32_to_float32", 1, FALSE, TRUE },
38 { "int32_to_float64", 1, FALSE, FALSE },
39 { "int32_to_floatx80", 1, FALSE, FALSE },
40 { "int32_to_float128", 1, FALSE, FALSE },
41 { "int64_to_float32", 1, FALSE, TRUE },
42 { "int64_to_float64", 1, FALSE, TRUE },
43 { "int64_to_floatx80", 1, FALSE, FALSE },
44 { "int64_to_float128", 1, FALSE, FALSE },
45 { "float32_to_int32", 1, FALSE, TRUE },
46 { "float32_to_int32_round_to_zero", 1, FALSE, FALSE },
47 { "float32_to_int64", 1, FALSE, TRUE },
48 { "float32_to_int64_round_to_zero", 1, FALSE, FALSE },
49 { "float32_to_float64", 1, FALSE, FALSE },
50 { "float32_to_floatx80", 1, FALSE, FALSE },
51 { "float32_to_float128", 1, FALSE, FALSE },
52 { "float32_round_to_int", 1, FALSE, TRUE },
53 { "float32_add", 2, FALSE, TRUE },
54 { "float32_sub", 2, FALSE, TRUE },
55 { "float32_mul", 2, FALSE, TRUE },
56 { "float32_div", 2, FALSE, TRUE },
57 { "float32_rem", 2, FALSE, FALSE },
58 { "float32_sqrt", 1, FALSE, TRUE },
59 { "float32_eq", 2, FALSE, FALSE },
60 { "float32_le", 2, FALSE, FALSE },
61 { "float32_lt", 2, FALSE, FALSE },
62 { "float32_eq_signaling", 2, FALSE, FALSE },
63 { "float32_le_quiet", 2, FALSE, FALSE },
64 { "float32_lt_quiet", 2, FALSE, FALSE },
65 { "float64_to_int32", 1, FALSE, TRUE },
66 { "float64_to_int32_round_to_zero", 1, FALSE, FALSE },
67 { "float64_to_int64", 1, FALSE, TRUE },
68 { "float64_to_int64_round_to_zero", 1, FALSE, FALSE },
69 { "float64_to_float32", 1, FALSE, TRUE },
70 { "float64_to_floatx80", 1, FALSE, FALSE },
71 { "float64_to_float128", 1, FALSE, FALSE },
72 { "float64_round_to_int", 1, FALSE, TRUE },
73 { "float64_add", 2, FALSE, TRUE },
74 { "float64_sub", 2, FALSE, TRUE },
75 { "float64_mul", 2, FALSE, TRUE },
76 { "float64_div", 2, FALSE, TRUE },
77 { "float64_rem", 2, FALSE, FALSE },
78 { "float64_sqrt", 1, FALSE, TRUE },
79 { "float64_eq", 2, FALSE, FALSE },
80 { "float64_le", 2, FALSE, FALSE },
81 { "float64_lt", 2, FALSE, FALSE },
82 { "float64_eq_signaling", 2, FALSE, FALSE },
83 { "float64_le_quiet", 2, FALSE, FALSE },
84 { "float64_lt_quiet", 2, FALSE, FALSE },
85 { "floatx80_to_int32", 1, FALSE, TRUE },
86 { "floatx80_to_int32_round_to_zero", 1, FALSE, FALSE },
87 { "floatx80_to_int64", 1, FALSE, TRUE },
88 { "floatx80_to_int64_round_to_zero", 1, FALSE, FALSE },
89 { "floatx80_to_float32", 1, FALSE, TRUE },
90 { "floatx80_to_float64", 1, FALSE, TRUE },
91 { "floatx80_to_float128", 1, FALSE, FALSE },
92 { "floatx80_round_to_int", 1, FALSE, TRUE },
93 { "floatx80_add", 2, TRUE, TRUE },
94 { "floatx80_sub", 2, TRUE, TRUE },
95 { "floatx80_mul", 2, TRUE, TRUE },
96 { "floatx80_div", 2, TRUE, TRUE },
97 { "floatx80_rem", 2, FALSE, FALSE },
98 { "floatx80_sqrt", 1, TRUE, TRUE },
99 { "floatx80_eq", 2, FALSE, FALSE },
100 { "floatx80_le", 2, FALSE, FALSE },
101 { "floatx80_lt", 2, FALSE, FALSE },
102 { "floatx80_eq_signaling", 2, FALSE, FALSE },
103 { "floatx80_le_quiet", 2, FALSE, FALSE },
104 { "floatx80_lt_quiet", 2, FALSE, FALSE },
105 { "float128_to_int32", 1, FALSE, TRUE },
106 { "float128_to_int32_round_to_zero", 1, FALSE, FALSE },
107 { "float128_to_int64", 1, FALSE, TRUE },
108 { "float128_to_int64_round_to_zero", 1, FALSE, FALSE },
109 { "float128_to_float32", 1, FALSE, TRUE },
110 { "float128_to_float64", 1, FALSE, TRUE },
111 { "float128_to_floatx80", 1, FALSE, TRUE },
112 { "float128_round_to_int", 1, FALSE, TRUE },
113 { "float128_add", 2, FALSE, TRUE },
114 { "float128_sub", 2, FALSE, TRUE },
115 { "float128_mul", 2, FALSE, TRUE },
116 { "float128_div", 2, FALSE, TRUE },
117 { "float128_rem", 2, FALSE, FALSE },
118 { "float128_sqrt", 1, FALSE, TRUE },
119 { "float128_eq", 2, FALSE, FALSE },
120 { "float128_le", 2, FALSE, FALSE },
121 { "float128_lt", 2, FALSE, FALSE },
122 { "float128_eq_signaling", 2, FALSE, FALSE },
123 { "float128_le_quiet", 2, FALSE, FALSE },
124 { "float128_lt_quiet", 2, FALSE, FALSE },
127 const flag functionExists[ NUM_FUNCTIONS ] = {
129 #ifdef SYST_INT32_TO_FLOAT32
134 #ifdef SYST_INT32_TO_FLOAT64
139 #ifdef SYST_INT32_TO_FLOATX80
144 #ifdef SYST_INT32_TO_FLOAT128
149 #ifdef SYST_INT64_TO_FLOAT32
154 #ifdef SYST_INT64_TO_FLOAT64
159 #ifdef SYST_INT64_TO_FLOATX80
164 #ifdef SYST_INT64_TO_FLOAT128
169 #ifdef SYST_FLOAT32_TO_INT32
174 #ifdef SYST_FLOAT32_TO_INT32_ROUND_TO_ZERO
179 #ifdef SYST_FLOAT32_TO_INT64
184 #ifdef SYST_FLOAT32_TO_INT64_ROUND_TO_ZERO
189 #ifdef SYST_FLOAT32_TO_FLOAT64
194 #ifdef SYST_FLOAT32_TO_FLOATX80
199 #ifdef SYST_FLOAT32_TO_FLOAT128
204 #ifdef SYST_FLOAT32_ROUND_TO_INT
209 #ifdef SYST_FLOAT32_ADD
214 #ifdef SYST_FLOAT32_SUB
219 #ifdef SYST_FLOAT32_MUL
224 #ifdef SYST_FLOAT32_DIV
229 #ifdef SYST_FLOAT32_REM
234 #ifdef SYST_FLOAT32_SQRT
239 #ifdef SYST_FLOAT32_EQ
244 #ifdef SYST_FLOAT32_LE
249 #ifdef SYST_FLOAT32_LT
254 #ifdef SYST_FLOAT32_EQ_SIGNALING
259 #ifdef SYST_FLOAT32_LE_QUIET
264 #ifdef SYST_FLOAT32_LT_QUIET
269 #ifdef SYST_FLOAT64_TO_INT32
274 #ifdef SYST_FLOAT64_TO_INT32_ROUND_TO_ZERO
279 #ifdef SYST_FLOAT64_TO_INT64
284 #ifdef SYST_FLOAT64_TO_INT64_ROUND_TO_ZERO
289 #ifdef SYST_FLOAT64_TO_FLOAT32
294 #ifdef SYST_FLOAT64_TO_FLOATX80
299 #ifdef SYST_FLOAT64_TO_FLOAT128
304 #ifdef SYST_FLOAT64_ROUND_TO_INT
309 #ifdef SYST_FLOAT64_ADD
314 #ifdef SYST_FLOAT64_SUB
319 #ifdef SYST_FLOAT64_MUL
324 #ifdef SYST_FLOAT64_DIV
329 #ifdef SYST_FLOAT64_REM
334 #ifdef SYST_FLOAT64_SQRT
339 #ifdef SYST_FLOAT64_EQ
344 #ifdef SYST_FLOAT64_LE
349 #ifdef SYST_FLOAT64_LT
354 #ifdef SYST_FLOAT64_EQ_SIGNALING
359 #ifdef SYST_FLOAT64_LE_QUIET
364 #ifdef SYST_FLOAT64_LT_QUIET
369 #ifdef SYST_FLOATX80_TO_INT32
374 #ifdef SYST_FLOATX80_TO_INT32_ROUND_TO_ZERO
379 #ifdef SYST_FLOATX80_TO_INT64
384 #ifdef SYST_FLOATX80_TO_INT64_ROUND_TO_ZERO
389 #ifdef SYST_FLOATX80_TO_FLOAT32
394 #ifdef SYST_FLOATX80_TO_FLOAT64
399 #ifdef SYST_FLOATX80_TO_FLOAT128
404 #ifdef SYST_FLOATX80_ROUND_TO_INT
409 #ifdef SYST_FLOATX80_ADD
414 #ifdef SYST_FLOATX80_SUB
419 #ifdef SYST_FLOATX80_MUL
424 #ifdef SYST_FLOATX80_DIV
429 #ifdef SYST_FLOATX80_REM
434 #ifdef SYST_FLOATX80_SQRT
439 #ifdef SYST_FLOATX80_EQ
444 #ifdef SYST_FLOATX80_LE
449 #ifdef SYST_FLOATX80_LT
454 #ifdef SYST_FLOATX80_EQ_SIGNALING
459 #ifdef SYST_FLOATX80_LE_QUIET
464 #ifdef SYST_FLOATX80_LT_QUIET
469 #ifdef SYST_FLOAT128_TO_INT32
474 #ifdef SYST_FLOAT128_TO_INT32_ROUND_TO_ZERO
479 #ifdef SYST_FLOAT128_TO_INT64
484 #ifdef SYST_FLOAT128_TO_INT64_ROUND_TO_ZERO
489 #ifdef SYST_FLOAT128_TO_FLOAT32
494 #ifdef SYST_FLOAT128_TO_FLOAT64
499 #ifdef SYST_FLOAT128_TO_FLOATX80
504 #ifdef SYST_FLOAT128_ROUND_TO_INT
509 #ifdef SYST_FLOAT128_ADD
514 #ifdef SYST_FLOAT128_SUB
519 #ifdef SYST_FLOAT128_MUL
524 #ifdef SYST_FLOAT128_DIV
529 #ifdef SYST_FLOAT128_REM
534 #ifdef SYST_FLOAT128_SQRT
539 #ifdef SYST_FLOAT128_EQ
544 #ifdef SYST_FLOAT128_LE
549 #ifdef SYST_FLOAT128_LT
554 #ifdef SYST_FLOAT128_EQ_SIGNALING
559 #ifdef SYST_FLOAT128_LE_QUIET
564 #ifdef SYST_FLOAT128_LT_QUIET
573 uint8 functionCode, int8 roundingPrecision, int8 roundingMode )
577 functionName = functions[ functionCode ].name;
579 if ( roundingPrecision == 32 ) {
580 roundingPrecisionName = "32";
582 else if ( roundingPrecision == 64 ) {
583 roundingPrecisionName = "64";
585 else if ( roundingPrecision == 80 ) {
586 roundingPrecisionName = "80";
589 roundingPrecision = 80;
590 roundingPrecisionName = 0;
592 floatx80_rounding_precision = roundingPrecision;
593 syst_float_set_rounding_precision( roundingPrecision );
595 switch ( roundingMode ) {
597 roundingModeName = 0;
598 roundingCode = float_round_nearest_even;
600 case ROUND_NEAREST_EVEN:
601 roundingModeName = "nearest_even";
602 roundingCode = float_round_nearest_even;
605 roundingModeName = "to_zero";
606 roundingCode = float_round_to_zero;
609 roundingModeName = "down";
610 roundingCode = float_round_down;
613 roundingModeName = "up";
614 roundingCode = float_round_up;
617 float_rounding_mode = roundingCode;
618 syst_float_set_rounding_mode( roundingCode );
619 fputs( "Testing ", stderr );
620 writeFunctionName( stderr );
621 fputs( ".\n", stderr );
622 switch ( functionCode ) {
623 #ifdef SYST_INT32_TO_FLOAT32
624 case INT32_TO_FLOAT32:
625 test_a_int32_z_float32( int32_to_float32, syst_int32_to_float32 );
628 #ifdef SYST_INT32_TO_FLOAT64
629 case INT32_TO_FLOAT64:
630 test_a_int32_z_float64( int32_to_float64, syst_int32_to_float64 );
633 #ifdef SYST_INT32_TO_FLOATX80
634 case INT32_TO_FLOATX80:
635 test_a_int32_z_floatx80( int32_to_floatx80, syst_int32_to_floatx80 );
638 #ifdef SYST_INT32_TO_FLOAT128
639 case INT32_TO_FLOAT128:
640 test_a_int32_z_float128( int32_to_float128, syst_int32_to_float128 );
643 #ifdef SYST_INT64_TO_FLOAT32
644 case INT64_TO_FLOAT32:
645 test_a_int64_z_float32( int64_to_float32, syst_int64_to_float32 );
648 #ifdef SYST_INT64_TO_FLOAT64
649 case INT64_TO_FLOAT64:
650 test_a_int64_z_float64( int64_to_float64, syst_int64_to_float64 );
653 #ifdef SYST_INT64_TO_FLOATX80
654 case INT64_TO_FLOATX80:
655 test_a_int64_z_floatx80( int64_to_floatx80, syst_int64_to_floatx80 );
658 #ifdef SYST_INT64_TO_FLOAT128
659 case INT64_TO_FLOAT128:
660 test_a_int64_z_float128( int64_to_float128, syst_int64_to_float128 );
663 #ifdef SYST_FLOAT32_TO_INT32
664 case FLOAT32_TO_INT32:
665 test_a_float32_z_int32( float32_to_int32, syst_float32_to_int32 );
668 #ifdef SYST_FLOAT32_TO_INT32_ROUND_TO_ZERO
669 case FLOAT32_TO_INT32_ROUND_TO_ZERO:
670 test_a_float32_z_int32(
671 float32_to_int32_round_to_zero,
672 syst_float32_to_int32_round_to_zero
676 #ifdef SYST_FLOAT32_TO_INT64
677 case FLOAT32_TO_INT64:
678 test_a_float32_z_int64( float32_to_int64, syst_float32_to_int64 );
681 #ifdef SYST_FLOAT32_TO_INT64_ROUND_TO_ZERO
682 case FLOAT32_TO_INT64_ROUND_TO_ZERO:
683 test_a_float32_z_int64(
684 float32_to_int64_round_to_zero,
685 syst_float32_to_int64_round_to_zero
689 #ifdef SYST_FLOAT32_TO_FLOAT64
690 case FLOAT32_TO_FLOAT64:
691 test_a_float32_z_float64(
692 float32_to_float64, syst_float32_to_float64 );
695 #ifdef SYST_FLOAT32_TO_FLOATX80
696 case FLOAT32_TO_FLOATX80:
697 test_a_float32_z_floatx80(
698 float32_to_floatx80, syst_float32_to_floatx80 );
701 #ifdef SYST_FLOAT32_TO_FLOAT128
702 case FLOAT32_TO_FLOAT128:
703 test_a_float32_z_float128(
704 float32_to_float128, syst_float32_to_float128 );
707 #ifdef SYST_FLOAT32_ROUND_TO_INT
708 case FLOAT32_ROUND_TO_INT:
709 test_az_float32( float32_round_to_int, syst_float32_round_to_int );
712 #ifdef SYST_FLOAT32_ADD
714 test_abz_float32( float32_add, syst_float32_add );
717 #ifdef SYST_FLOAT32_SUB
719 test_abz_float32( float32_sub, syst_float32_sub );
722 #ifdef SYST_FLOAT32_MUL
724 test_abz_float32( float32_mul, syst_float32_mul );
727 #ifdef SYST_FLOAT32_DIV
729 test_abz_float32( float32_div, syst_float32_div );
732 #ifdef SYST_FLOAT32_REM
734 test_abz_float32( float32_rem, syst_float32_rem );
737 #ifdef SYST_FLOAT32_SQRT
739 test_az_float32( float32_sqrt, syst_float32_sqrt );
742 #ifdef SYST_FLOAT32_EQ
744 test_ab_float32_z_flag( float32_eq, syst_float32_eq );
747 #ifdef SYST_FLOAT32_LE
749 test_ab_float32_z_flag( float32_le, syst_float32_le );
752 #ifdef SYST_FLOAT32_LT
754 test_ab_float32_z_flag( float32_lt, syst_float32_lt );
757 #ifdef SYST_FLOAT32_EQ_SIGNALING
758 case FLOAT32_EQ_SIGNALING:
759 test_ab_float32_z_flag(
760 float32_eq_signaling, syst_float32_eq_signaling );
763 #ifdef SYST_FLOAT32_LE_QUIET
764 case FLOAT32_LE_QUIET:
765 test_ab_float32_z_flag( float32_le_quiet, syst_float32_le_quiet );
768 #ifdef SYST_FLOAT32_LT_QUIET
769 case FLOAT32_LT_QUIET:
770 test_ab_float32_z_flag( float32_lt_quiet, syst_float32_lt_quiet );
773 #ifdef SYST_FLOAT64_TO_INT32
774 case FLOAT64_TO_INT32:
775 test_a_float64_z_int32( float64_to_int32, syst_float64_to_int32 );
778 #ifdef SYST_FLOAT64_TO_INT32_ROUND_TO_ZERO
779 case FLOAT64_TO_INT32_ROUND_TO_ZERO:
780 test_a_float64_z_int32(
781 float64_to_int32_round_to_zero,
782 syst_float64_to_int32_round_to_zero
786 #ifdef SYST_FLOAT64_TO_INT64
787 case FLOAT64_TO_INT64:
788 test_a_float64_z_int64( float64_to_int64, syst_float64_to_int64 );
791 #ifdef SYST_FLOAT64_TO_INT64_ROUND_TO_ZERO
792 case FLOAT64_TO_INT64_ROUND_TO_ZERO:
793 test_a_float64_z_int64(
794 float64_to_int64_round_to_zero,
795 syst_float64_to_int64_round_to_zero
799 #ifdef SYST_FLOAT64_TO_FLOAT32
800 case FLOAT64_TO_FLOAT32:
801 test_a_float64_z_float32(
802 float64_to_float32, syst_float64_to_float32 );
805 #ifdef SYST_FLOAT64_TO_FLOATX80
806 case FLOAT64_TO_FLOATX80:
807 test_a_float64_z_floatx80(
808 float64_to_floatx80, syst_float64_to_floatx80 );
811 #ifdef SYST_FLOAT64_TO_FLOAT128
812 case FLOAT64_TO_FLOAT128:
813 test_a_float64_z_float128(
814 float64_to_float128, syst_float64_to_float128 );
817 #ifdef SYST_FLOAT64_ROUND_TO_INT
818 case FLOAT64_ROUND_TO_INT:
819 test_az_float64( float64_round_to_int, syst_float64_round_to_int );
822 #ifdef SYST_FLOAT64_ADD
824 test_abz_float64( float64_add, syst_float64_add );
827 #ifdef SYST_FLOAT64_SUB
829 test_abz_float64( float64_sub, syst_float64_sub );
832 #ifdef SYST_FLOAT64_MUL
834 test_abz_float64( float64_mul, syst_float64_mul );
837 #ifdef SYST_FLOAT64_DIV
839 test_abz_float64( float64_div, syst_float64_div );
842 #ifdef SYST_FLOAT64_REM
844 test_abz_float64( float64_rem, syst_float64_rem );
847 #ifdef SYST_FLOAT64_SQRT
849 test_az_float64( float64_sqrt, syst_float64_sqrt );
852 #ifdef SYST_FLOAT64_EQ
854 test_ab_float64_z_flag( float64_eq, syst_float64_eq );
857 #ifdef SYST_FLOAT64_LE
859 test_ab_float64_z_flag( float64_le, syst_float64_le );
862 #ifdef SYST_FLOAT64_LT
864 test_ab_float64_z_flag( float64_lt, syst_float64_lt );
867 #ifdef SYST_FLOAT64_EQ_SIGNALING
868 case FLOAT64_EQ_SIGNALING:
869 test_ab_float64_z_flag(
870 float64_eq_signaling, syst_float64_eq_signaling );
873 #ifdef SYST_FLOAT64_LE_QUIET
874 case FLOAT64_LE_QUIET:
875 test_ab_float64_z_flag( float64_le_quiet, syst_float64_le_quiet );
878 #ifdef SYST_FLOAT64_LT_QUIET
879 case FLOAT64_LT_QUIET:
880 test_ab_float64_z_flag( float64_lt_quiet, syst_float64_lt_quiet );
883 #ifdef SYST_FLOATX80_TO_INT32
884 case FLOATX80_TO_INT32:
885 test_a_floatx80_z_int32( floatx80_to_int32, syst_floatx80_to_int32 );
888 #ifdef SYST_FLOATX80_TO_INT32_ROUND_TO_ZERO
889 case FLOATX80_TO_INT32_ROUND_TO_ZERO:
890 test_a_floatx80_z_int32(
891 floatx80_to_int32_round_to_zero,
892 syst_floatx80_to_int32_round_to_zero
896 #ifdef SYST_FLOATX80_TO_INT64
897 case FLOATX80_TO_INT64:
898 test_a_floatx80_z_int64( floatx80_to_int64, syst_floatx80_to_int64 );
901 #ifdef SYST_FLOATX80_TO_INT64_ROUND_TO_ZERO
902 case FLOATX80_TO_INT64_ROUND_TO_ZERO:
903 test_a_floatx80_z_int64(
904 floatx80_to_int64_round_to_zero,
905 syst_floatx80_to_int64_round_to_zero
909 #ifdef SYST_FLOATX80_TO_FLOAT32
910 case FLOATX80_TO_FLOAT32:
911 test_a_floatx80_z_float32(
912 floatx80_to_float32, syst_floatx80_to_float32 );
915 #ifdef SYST_FLOATX80_TO_FLOAT64
916 case FLOATX80_TO_FLOAT64:
917 test_a_floatx80_z_float64(
918 floatx80_to_float64, syst_floatx80_to_float64 );
921 #ifdef SYST_FLOATX80_TO_FLOAT128
922 case FLOATX80_TO_FLOAT128:
923 test_a_floatx80_z_float128(
924 floatx80_to_float128, syst_floatx80_to_float128 );
927 #ifdef SYST_FLOATX80_ROUND_TO_INT
928 case FLOATX80_ROUND_TO_INT:
929 test_az_floatx80( floatx80_round_to_int, syst_floatx80_round_to_int );
932 #ifdef SYST_FLOATX80_ADD
934 test_abz_floatx80( floatx80_add, syst_floatx80_add );
937 #ifdef SYST_FLOATX80_SUB
939 test_abz_floatx80( floatx80_sub, syst_floatx80_sub );
942 #ifdef SYST_FLOATX80_MUL
944 test_abz_floatx80( floatx80_mul, syst_floatx80_mul );
947 #ifdef SYST_FLOATX80_DIV
949 test_abz_floatx80( floatx80_div, syst_floatx80_div );
952 #ifdef SYST_FLOATX80_REM
954 test_abz_floatx80( floatx80_rem, syst_floatx80_rem );
957 #ifdef SYST_FLOATX80_SQRT
959 test_az_floatx80( floatx80_sqrt, syst_floatx80_sqrt );
962 #ifdef SYST_FLOATX80_EQ
964 test_ab_floatx80_z_flag( floatx80_eq, syst_floatx80_eq );
967 #ifdef SYST_FLOATX80_LE
969 test_ab_floatx80_z_flag( floatx80_le, syst_floatx80_le );
972 #ifdef SYST_FLOATX80_LT
974 test_ab_floatx80_z_flag( floatx80_lt, syst_floatx80_lt );
977 #ifdef SYST_FLOATX80_EQ_SIGNALING
978 case FLOATX80_EQ_SIGNALING:
979 test_ab_floatx80_z_flag(
980 floatx80_eq_signaling, syst_floatx80_eq_signaling );
983 #ifdef SYST_FLOATX80_LE_QUIET
984 case FLOATX80_LE_QUIET:
985 test_ab_floatx80_z_flag( floatx80_le_quiet, syst_floatx80_le_quiet );
988 #ifdef SYST_FLOATX80_LT_QUIET
989 case FLOATX80_LT_QUIET:
990 test_ab_floatx80_z_flag( floatx80_lt_quiet, syst_floatx80_lt_quiet );
993 #ifdef SYST_FLOAT128_TO_INT32
994 case FLOAT128_TO_INT32:
995 test_a_float128_z_int32( float128_to_int32, syst_float128_to_int32 );
998 #ifdef SYST_FLOAT128_TO_INT32_ROUND_TO_ZERO
999 case FLOAT128_TO_INT32_ROUND_TO_ZERO:
1000 test_a_float128_z_int32(
1001 float128_to_int32_round_to_zero,
1002 syst_float128_to_int32_round_to_zero
1006 #ifdef SYST_FLOAT128_TO_INT64
1007 case FLOAT128_TO_INT64:
1008 test_a_float128_z_int64( float128_to_int64, syst_float128_to_int64 );
1011 #ifdef SYST_FLOAT128_TO_INT64_ROUND_TO_ZERO
1012 case FLOAT128_TO_INT64_ROUND_TO_ZERO:
1013 test_a_float128_z_int64(
1014 float128_to_int64_round_to_zero,
1015 syst_float128_to_int64_round_to_zero
1019 #ifdef SYST_FLOAT128_TO_FLOAT32
1020 case FLOAT128_TO_FLOAT32:
1021 test_a_float128_z_float32(
1022 float128_to_float32, syst_float128_to_float32 );
1025 #ifdef SYST_FLOAT128_TO_FLOAT64
1026 case FLOAT128_TO_FLOAT64:
1027 test_a_float128_z_float64(
1028 float128_to_float64, syst_float128_to_float64 );
1031 #ifdef SYST_FLOAT128_TO_FLOATX80
1032 case FLOAT128_TO_FLOATX80:
1033 test_a_float128_z_floatx80(
1034 float128_to_floatx80, syst_float128_to_floatx80 );
1037 #ifdef SYST_FLOAT128_ROUND_TO_INT
1038 case FLOAT128_ROUND_TO_INT:
1039 test_az_float128( float128_round_to_int, syst_float128_round_to_int );
1042 #ifdef SYST_FLOAT128_ADD
1044 test_abz_float128( float128_add, syst_float128_add );
1047 #ifdef SYST_FLOAT128_SUB
1049 test_abz_float128( float128_sub, syst_float128_sub );
1052 #ifdef SYST_FLOAT128_MUL
1054 test_abz_float128( float128_mul, syst_float128_mul );
1057 #ifdef SYST_FLOAT128_DIV
1059 test_abz_float128( float128_div, syst_float128_div );
1062 #ifdef SYST_FLOAT128_REM
1064 test_abz_float128( float128_rem, syst_float128_rem );
1067 #ifdef SYST_FLOAT128_SQRT
1069 test_az_float128( float128_sqrt, syst_float128_sqrt );
1072 #ifdef SYST_FLOAT128_EQ
1074 test_ab_float128_z_flag( float128_eq, syst_float128_eq );
1077 #ifdef SYST_FLOAT128_LE
1079 test_ab_float128_z_flag( float128_le, syst_float128_le );
1082 #ifdef SYST_FLOAT128_LT
1084 test_ab_float128_z_flag( float128_lt, syst_float128_lt );
1087 #ifdef SYST_FLOAT128_EQ_SIGNALING
1088 case FLOAT128_EQ_SIGNALING:
1089 test_ab_float128_z_flag(
1090 float128_eq_signaling, syst_float128_eq_signaling );
1093 #ifdef SYST_FLOAT128_LE_QUIET
1094 case FLOAT128_LE_QUIET:
1095 test_ab_float128_z_flag( float128_le_quiet, syst_float128_le_quiet );
1098 #ifdef SYST_FLOAT128_LT_QUIET
1099 case FLOAT128_LT_QUIET:
1100 test_ab_float128_z_flag( float128_lt_quiet, syst_float128_lt_quiet );
1104 if ( ( errorStop && anyErrors ) || stop ) exitWithStatus();
1110 uint8 functionCode, int8 roundingPrecisionIn, int8 roundingModeIn )
1112 int8 roundingPrecision, roundingMode;
1114 roundingPrecision = 32;
1116 if ( ! functions[ functionCode ].roundingPrecision ) {
1117 roundingPrecision = 0;
1119 else if ( roundingPrecisionIn ) {
1120 roundingPrecision = roundingPrecisionIn;
1122 for ( roundingMode = 1;
1123 roundingMode < NUM_ROUNDINGMODES;
1126 if ( ! functions[ functionCode ].roundingMode ) {
1129 else if ( roundingModeIn ) {
1130 roundingMode = roundingModeIn;
1132 testFunctionVariety(
1133 functionCode, roundingPrecision, roundingMode );
1134 if ( roundingModeIn || ! roundingMode ) break;
1136 if ( roundingPrecisionIn || ! roundingPrecision ) break;
1137 if ( roundingPrecision == 80 ) {
1140 else if ( roundingPrecision == 64 ) {
1141 roundingPrecision = 80;
1143 else if ( roundingPrecision == 32 ) {
1144 roundingPrecision = 64;