include/fpu/softfloat.h

5  * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and
9  *  the SoftFloat-2a license
11  *  GPL-v2-or-later
14  * taken to be licensed under the Softfloat-2a license unless specifically
20 This C header file is part of the SoftFloat IEC/IEEE Floating-point
26 National Science Foundation under grant MIP-9311980.  The original version
27 of this code was written as part of a project to build a fixed-point vector
79  * version 2 or later. See the COPYING file in the top-level directory.
85 /*----------------------------------------------------------------------------
86 | Software IEC/IEEE floating-point ordering relations
87 *----------------------------------------------------------------------------*/
90     float_relation_less      = -1,
96 #include "fpu/softfloat-types.h"
97 #include "fpu/softfloat-helpers.h"
100 /*----------------------------------------------------------------------------
101 | Routine to raise any or all of the software IEC/IEEE floating-point
103 *----------------------------------------------------------------------------*/
106     status->float_exception_flags |= flags;  in float_raise()
109 /*----------------------------------------------------------------------------
110 | If `a' is denormal and we are in flush-to-zero mode then set the
111 | input-denormal exception and return zero. Otherwise just return the value.
112 *----------------------------------------------------------------------------*/
118 /*----------------------------------------------------------------------------
124 | case to support the ARM fused-sqrt-step instruction FRSQRTS.
125 *----------------------------------------------------------------------------*/
133 /*----------------------------------------------------------------------------
134 | Software IEC/IEEE integer-to-floating-point conversion routines.
135 *----------------------------------------------------------------------------*/
190 /*----------------------------------------------------------------------------
191 | Software half-precision conversion routines.
192 *----------------------------------------------------------------------------*/
232 /*----------------------------------------------------------------------------
233 | Software half-precision operations.
234 *----------------------------------------------------------------------------*/
359 /*----------------------------------------------------------------------------
361 *----------------------------------------------------------------------------*/
425 /*----------------------------------------------------------------------------
427 *----------------------------------------------------------------------------*/
553 /*----------------------------------------------------------------------------
554 | The pattern for a default generated half-precision NaN.
555 *----------------------------------------------------------------------------*/
558 /*----------------------------------------------------------------------------
559 | Software IEC/IEEE single-precision conversion routines.
560 *----------------------------------------------------------------------------*/
590 /*----------------------------------------------------------------------------
591 | Software IEC/IEEE single-precision operations.
592 *----------------------------------------------------------------------------*/
728 /*----------------------------------------------------------------------------
730 | single-precision floating-point value, returning the result.  After being
737 *----------------------------------------------------------------------------*/
745 /*----------------------------------------------------------------------------
746 | The pattern for a default generated single-precision NaN.
747 *----------------------------------------------------------------------------*/
750 /*----------------------------------------------------------------------------
751 | Software IEC/IEEE double-precision conversion routines.
752 *----------------------------------------------------------------------------*/
785 /*----------------------------------------------------------------------------
786 | Software IEC/IEEE double-precision operations.
787 *----------------------------------------------------------------------------*/
924 /*----------------------------------------------------------------------------
925 | The pattern for a default generated double-precision NaN.
926 *----------------------------------------------------------------------------*/
929 /*----------------------------------------------------------------------------
930 | Software IEC/IEEE double-precision operations, rounding to single precision,
931 | returning a result in double precision, with only one rounding step.
932 *----------------------------------------------------------------------------*/
941 /*----------------------------------------------------------------------------
942 | Software IEC/IEEE extended double-precision conversion routines.
943 *----------------------------------------------------------------------------*/
952 /*----------------------------------------------------------------------------
953 | The pattern for an extended double-precision inf.
954 *----------------------------------------------------------------------------*/
957 /*----------------------------------------------------------------------------
958 | Software IEC/IEEE extended double-precision operations.
959 *----------------------------------------------------------------------------*/
993     return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1);  in floatx80_is_infinity()
996                        a.low == floatx80_infinity.low;  in floatx80_is_infinity()
1007     return (a.high & 0x7fff) == 0 && a.low == 0;  in floatx80_is_zero()
1017     return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);  in floatx80_is_any_nan()
1061 /*----------------------------------------------------------------------------
1066 | This includes what the Intel software developer's manual calls pseudo-NaNs,
1067 | pseudo-infinities and un-normal numbers. It does not include
1068 | pseudo-denormals, which must still be correctly handled as inputs even
1070 *----------------------------------------------------------------------------*/
1074     /*-------------------------------------------------------------------------  in floatx80_invalid_encoding()
1076     | - zeros                (exp == 0, mantissa == 0)  in floatx80_invalid_encoding()
1077     | - denormalized numbers (exp == 0, mantissa != 0)  in floatx80_invalid_encoding()
1078     | - unnormalized numbers (exp != 0, exp < 0x7FFF)  in floatx80_invalid_encoding()
1079     | - infinities           (exp == 0x7FFF, mantissa == 0)  in floatx80_invalid_encoding()
1080     | - not-a-numbers        (exp == 0x7FFF, mantissa != 0)  in floatx80_invalid_encoding()
1092     |     "1.6 FLOATING-POINT DATA TYPES"  in floatx80_invalid_encoding()
1093     *------------------------------------------------------------------------*/  in floatx80_invalid_encoding()
1096     return (a.low & (1ULL << 63)) == 0 && (a.high & 0x7FFF) != 0;  in floatx80_invalid_encoding()
1107 /*----------------------------------------------------------------------------
1108 | Returns the fraction bits of the extended double-precision floating-point
1110 *----------------------------------------------------------------------------*/
1114     return a.low;  in extractFloatx80Frac()
1117 /*----------------------------------------------------------------------------
1118 | Returns the exponent bits of the extended double-precision floating-point
1120 *----------------------------------------------------------------------------*/
1127 /*----------------------------------------------------------------------------
1128 | Returns the sign bit of the extended double-precision floating-point value
1130 *----------------------------------------------------------------------------*/
1137 /*----------------------------------------------------------------------------
1139 | extended double-precision floating-point value, returning the result.
1140 *----------------------------------------------------------------------------*/
1146     z.low = zSig;  in packFloatx80()
1151 /*----------------------------------------------------------------------------
1152 | Normalizes the subnormal extended double-precision floating-point value
1156 *----------------------------------------------------------------------------*/
1161 /*----------------------------------------------------------------------------
1162 | Takes two extended double-precision floating-point values `a' and `b', one
1165 *----------------------------------------------------------------------------*/
1169 /*----------------------------------------------------------------------------
1170 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
1172 | and returns the proper extended double-precision floating-point value
1174 | rounded and packed into the extended double-precision format, with the
1181 | double-precision floating-point number.
1183 | number of bits as single or double precision, respectively.  Otherwise, the
1184 | result is rounded to the full precision of the extended double-precision
1190 | Floating-Point Arithmetic.
1191 *----------------------------------------------------------------------------*/
1197 /*----------------------------------------------------------------------------
1198 | Takes an abstract floating-point value having sign `zSign', exponent
1200 | and returns the proper extended double-precision floating-point value
1204 *----------------------------------------------------------------------------*/
1211 /*----------------------------------------------------------------------------
1212 | The pattern for a default generated extended double-precision NaN.
1213 *----------------------------------------------------------------------------*/
1216 /*----------------------------------------------------------------------------
1217 | Software IEC/IEEE quadruple-precision conversion routines.
1218 *----------------------------------------------------------------------------*/
1235 /*----------------------------------------------------------------------------
1236 | Software IEC/IEEE quadruple-precision operations.
1237 *----------------------------------------------------------------------------*/
1276     return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;  in float128_is_infinity()
1286     return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;  in float128_is_zero()
1307         ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));  in float128_is_any_nan()
1353 /*----------------------------------------------------------------------------
1354 | The pattern for a default generated quadruple-precision NaN.
1355 *----------------------------------------------------------------------------*/