1 /* This is a software floating point library which can be used
2 for targets without hardware floating point.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003
4 Free Software Foundation, Inc.
6 This file is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 In addition to the permissions in the GNU General Public License, the
12 Free Software Foundation gives you unlimited permission to link the
13 compiled version of this file with other programs, and to distribute
14 those programs without any restriction coming from the use of this
15 file. (The General Public License restrictions do apply in other
16 respects; for example, they cover modification of the file, and
17 distribution when not linked into another program.)
19 This file is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; see the file COPYING. If not, write to
26 the Free Software Foundation, 59 Temple Place - Suite 330,
27 Boston, MA 02111-1307, USA. */
29 /* As a special exception, if you link this library with other files,
30 some of which are compiled with GCC, to produce an executable,
31 this library does not by itself cause the resulting executable
32 to be covered by the GNU General Public License.
33 This exception does not however invalidate any other reasons why
34 the executable file might be covered by the GNU General Public License. */
36 /* This implements IEEE 754 format arithmetic, but does not provide a
37 mechanism for setting the rounding mode, or for generating or handling
40 The original code by Steve Chamberlain, hacked by Mark Eichin and Jim
41 Wilson, all of Cygnus Support. */
43 /* The intended way to use this file is to make two copies, add `#define FLOAT'
44 to one copy, then compile both copies and add them to libgcc.a. */
47 #include "coretypes.h"
51 /* The following macros can be defined to change the behavior of this file:
52 FLOAT: Implement a `float', aka SFmode, fp library. If this is not
53 defined, then this file implements a `double', aka DFmode, fp library.
54 FLOAT_ONLY: Used with FLOAT, to implement a `float' only library, i.e.
55 don't include float->double conversion which requires the double library.
56 This is useful only for machines which can't support doubles, e.g. some
58 CMPtype: Specify the type that floating point compares should return.
59 This defaults to SItype, aka int.
60 US_SOFTWARE_GOFAST: This makes all entry points use the same names as the
61 US Software goFast library.
62 _DEBUG_BITFLOAT: This makes debugging the code a little easier, by adding
63 two integers to the FLO_union_type.
64 NO_DENORMALS: Disable handling of denormals.
65 NO_NANS: Disable nan and infinity handling
66 SMALL_MACHINE: Useful when operations on QIs and HIs are faster
69 /* We don't currently support extended floats (long doubles) on machines
70 without hardware to deal with them.
72 These stubs are just to keep the linker from complaining about unresolved
73 references which can be pulled in from libio & libstdc++, even if the
74 user isn't using long doubles. However, they may generate an unresolved
75 external to abort if abort is not used by the function, and the stubs
76 are referenced from within libc, since libgcc goes before and after the
79 #ifdef DECLARE_LIBRARY_RENAMES
80 DECLARE_LIBRARY_RENAMES
83 #ifdef EXTENDED_FLOAT_STUBS
84 extern void abort (void);
85 void __extendsfxf2 (void) { abort(); }
86 void __extenddfxf2 (void) { abort(); }
87 void __truncxfdf2 (void) { abort(); }
88 void __truncxfsf2 (void) { abort(); }
89 void __fixxfsi (void) { abort(); }
90 void __floatsixf (void) { abort(); }
91 void __addxf3 (void) { abort(); }
92 void __subxf3 (void) { abort(); }
93 void __mulxf3 (void) { abort(); }
94 void __divxf3 (void) { abort(); }
95 void __negxf2 (void) { abort(); }
96 void __eqxf2 (void) { abort(); }
97 void __nexf2 (void) { abort(); }
98 void __gtxf2 (void) { abort(); }
99 void __gexf2 (void) { abort(); }
100 void __lexf2 (void) { abort(); }
101 void __ltxf2 (void) { abort(); }
103 void __extendsftf2 (void) { abort(); }
104 void __extenddftf2 (void) { abort(); }
105 void __trunctfdf2 (void) { abort(); }
106 void __trunctfsf2 (void) { abort(); }
107 void __fixtfsi (void) { abort(); }
108 void __floatsitf (void) { abort(); }
109 void __addtf3 (void) { abort(); }
110 void __subtf3 (void) { abort(); }
111 void __multf3 (void) { abort(); }
112 void __divtf3 (void) { abort(); }
113 void __negtf2 (void) { abort(); }
114 void __eqtf2 (void) { abort(); }
115 void __netf2 (void) { abort(); }
116 void __gttf2 (void) { abort(); }
117 void __getf2 (void) { abort(); }
118 void __letf2 (void) { abort(); }
119 void __lttf2 (void) { abort(); }
120 #else /* !EXTENDED_FLOAT_STUBS, rest of file */
122 /* IEEE "special" number predicates */
131 #if defined L_thenan_sf
132 const fp_number_type __thenan_sf = { CLASS_SNAN, 0, 0, {(fractype) 0} };
133 #elif defined L_thenan_df
134 const fp_number_type __thenan_df = { CLASS_SNAN, 0, 0, {(fractype) 0} };
135 #elif defined L_thenan_tf
136 const fp_number_type __thenan_tf = { CLASS_SNAN, 0, 0, {(fractype) 0} };
138 extern const fp_number_type __thenan_tf;
140 extern const fp_number_type __thenan_sf;
142 extern const fp_number_type __thenan_df;
146 static fp_number_type *
149 /* Discard the const qualifier... */
151 return (fp_number_type *) (& __thenan_tf);
153 return (fp_number_type *) (& __thenan_sf);
155 return (fp_number_type *) (& __thenan_df);
161 isnan ( fp_number_type * x)
163 return x->class == CLASS_SNAN || x->class == CLASS_QNAN;
168 isinf ( fp_number_type * x)
170 return x->class == CLASS_INFINITY;
177 iszero ( fp_number_type * x)
179 return x->class == CLASS_ZERO;
184 flip_sign ( fp_number_type * x)
189 extern FLO_type pack_d ( fp_number_type * );
191 #if defined(L_pack_df) || defined(L_pack_sf) || defined(L_pack_tf)
193 pack_d ( fp_number_type * src)
196 fractype fraction = src->fraction.ll; /* wasn't unsigned before? */
197 int sign = src->sign;
200 if (LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && (isnan (src) || isinf (src)))
202 /* We can't represent these values accurately. By using the
203 largest possible magnitude, we guarantee that the conversion
204 of infinity is at least as big as any finite number. */
206 fraction = ((fractype) 1 << FRACBITS) - 1;
208 else if (isnan (src))
211 if (src->class == CLASS_QNAN || 1)
213 fraction |= QUIET_NAN;
216 else if (isinf (src))
221 else if (iszero (src))
226 else if (fraction == 0)
232 if (src->normal_exp < NORMAL_EXPMIN)
235 /* Go straight to a zero representation if denormals are not
236 supported. The denormal handling would be harmless but
237 isn't unnecessary. */
240 #else /* NO_DENORMALS */
241 /* This number's exponent is too low to fit into the bits
242 available in the number, so we'll store 0 in the exponent and
243 shift the fraction to the right to make up for it. */
245 int shift = NORMAL_EXPMIN - src->normal_exp;
249 if (shift > FRAC_NBITS - NGARDS)
251 /* No point shifting, since it's more that 64 out. */
256 int lowbit = (fraction & (((fractype)1 << shift) - 1)) ? 1 : 0;
257 fraction = (fraction >> shift) | lowbit;
259 if ((fraction & GARDMASK) == GARDMSB)
261 if ((fraction & (1 << NGARDS)))
262 fraction += GARDROUND + 1;
266 /* Add to the guards to round up. */
267 fraction += GARDROUND;
269 /* Perhaps the rounding means we now need to change the
270 exponent, because the fraction is no longer denormal. */
271 if (fraction >= IMPLICIT_1)
276 #endif /* NO_DENORMALS */
278 else if (!LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS)
279 && src->normal_exp > EXPBIAS)
286 exp = src->normal_exp + EXPBIAS;
287 if (!ROUND_TOWARDS_ZERO)
289 /* IF the gard bits are the all zero, but the first, then we're
290 half way between two numbers, choose the one which makes the
291 lsb of the answer 0. */
292 if ((fraction & GARDMASK) == GARDMSB)
294 if (fraction & (1 << NGARDS))
295 fraction += GARDROUND + 1;
299 /* Add a one to the guards to round up */
300 fraction += GARDROUND;
302 if (fraction >= IMPLICIT_2)
310 if (LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && exp > EXPMAX)
312 /* Saturate on overflow. */
314 fraction = ((fractype) 1 << FRACBITS) - 1;
319 /* We previously used bitfields to store the number, but this doesn't
320 handle little/big endian systems conveniently, so use shifts and
322 #ifdef FLOAT_BIT_ORDER_MISMATCH
323 dst.bits.fraction = fraction;
325 dst.bits.sign = sign;
327 # if defined TFLOAT && defined HALFFRACBITS
329 halffractype high, low;
331 high = (fraction >> (FRACBITS - HALFFRACBITS));
332 high &= (((fractype)1) << HALFFRACBITS) - 1;
333 high |= ((fractype) (exp & ((1 << EXPBITS) - 1))) << HALFFRACBITS;
334 high |= ((fractype) (sign & 1)) << (HALFFRACBITS | EXPBITS);
336 low = (halffractype)fraction &
337 ((((halffractype)1) << (FRACBITS - HALFFRACBITS)) - 1);
339 if (exp == EXPMAX || exp == 0 || low == 0)
343 exp -= HALFFRACBITS + 1;
346 && low < ((halffractype)1 << HALFFRACBITS))
354 halffractype roundmsb, round;
358 roundmsb = (1 << (exp - 1));
359 round = low & ((roundmsb << 1) - 1);
364 if (round > roundmsb || (round == roundmsb && (low & 1)))
367 if (low >= ((halffractype)1 << HALFFRACBITS))
368 /* We don't shift left, since it has just become the
369 smallest normal number, whose implicit 1 bit is
370 now indicated by the non-zero exponent. */
375 low &= ((halffractype)1 << HALFFRACBITS) - 1;
376 low |= ((fractype) (exp & ((1 << EXPBITS) - 1))) << HALFFRACBITS;
377 low |= ((fractype) (sign & 1)) << (HALFFRACBITS | EXPBITS);
380 dst.value_raw = (((fractype) high) << HALFSHIFT) | low;
383 dst.value_raw = fraction & ((((fractype)1) << FRACBITS) - (fractype)1);
384 dst.value_raw |= ((fractype) (exp & ((1 << EXPBITS) - 1))) << FRACBITS;
385 dst.value_raw |= ((fractype) (sign & 1)) << (FRACBITS | EXPBITS);
389 #if defined(FLOAT_WORD_ORDER_MISMATCH) && !defined(FLOAT)
392 qrtrfractype tmp1 = dst.words[0];
393 qrtrfractype tmp2 = dst.words[1];
394 dst.words[0] = dst.words[3];
395 dst.words[1] = dst.words[2];
401 halffractype tmp = dst.words[0];
402 dst.words[0] = dst.words[1];
412 #if defined(L_unpack_df) || defined(L_unpack_sf) || defined(L_unpack_tf)
414 unpack_d (FLO_union_type * src, fp_number_type * dst)
416 /* We previously used bitfields to store the number, but this doesn't
417 handle little/big endian systems conveniently, so use shifts and
423 #if defined(FLOAT_WORD_ORDER_MISMATCH) && !defined(FLOAT)
424 FLO_union_type swapped;
427 swapped.words[0] = src->words[3];
428 swapped.words[1] = src->words[2];
429 swapped.words[2] = src->words[1];
430 swapped.words[3] = src->words[0];
432 swapped.words[0] = src->words[1];
433 swapped.words[1] = src->words[0];
438 #ifdef FLOAT_BIT_ORDER_MISMATCH
439 fraction = src->bits.fraction;
441 sign = src->bits.sign;
443 # if defined TFLOAT && defined HALFFRACBITS
445 halffractype high, low;
447 high = src->value_raw >> HALFSHIFT;
448 low = src->value_raw & (((fractype)1 << HALFSHIFT) - 1);
450 fraction = high & ((((fractype)1) << HALFFRACBITS) - 1);
451 fraction <<= FRACBITS - HALFFRACBITS;
452 exp = ((int)(high >> HALFFRACBITS)) & ((1 << EXPBITS) - 1);
453 sign = ((int)(high >> (((HALFFRACBITS + EXPBITS))))) & 1;
455 if (exp != EXPMAX && exp != 0 && low != 0)
457 int lowexp = ((int)(low >> HALFFRACBITS)) & ((1 << EXPBITS) - 1);
461 xlow = low & ((((fractype)1) << HALFFRACBITS) - 1);
463 xlow |= (((halffractype)1) << HALFFRACBITS);
466 shift = (FRACBITS - HALFFRACBITS) - (exp - lowexp);
475 fraction = src->value_raw & ((((fractype)1) << FRACBITS) - 1);
476 exp = ((int)(src->value_raw >> FRACBITS)) & ((1 << EXPBITS) - 1);
477 sign = ((int)(src->value_raw >> (FRACBITS + EXPBITS))) & 1;
484 /* Hmm. Looks like 0 */
491 /* tastes like zero */
492 dst->class = CLASS_ZERO;
496 /* Zero exponent with nonzero fraction - it's denormalized,
497 so there isn't a leading implicit one - we'll shift it so
499 dst->normal_exp = exp - EXPBIAS + 1;
502 dst->class = CLASS_NUMBER;
504 while (fraction < IMPLICIT_1)
510 dst->fraction.ll = fraction;
513 else if (!LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && exp == EXPMAX)
518 /* Attached to a zero fraction - means infinity */
519 dst->class = CLASS_INFINITY;
523 /* Nonzero fraction, means nan */
524 if (fraction & QUIET_NAN)
526 dst->class = CLASS_QNAN;
530 dst->class = CLASS_SNAN;
532 /* Keep the fraction part as the nan number */
533 dst->fraction.ll = fraction;
538 /* Nothing strange about this number */
539 dst->normal_exp = exp - EXPBIAS;
540 dst->class = CLASS_NUMBER;
541 dst->fraction.ll = (fraction << NGARDS) | IMPLICIT_1;
544 #endif /* L_unpack_df || L_unpack_sf */
546 #if defined(L_addsub_sf) || defined(L_addsub_df) || defined(L_addsub_tf)
547 static fp_number_type *
548 _fpadd_parts (fp_number_type * a,
550 fp_number_type * tmp)
554 /* Put commonly used fields in local variables. */
570 /* Adding infinities with opposite signs yields a NaN. */
571 if (isinf (b) && a->sign != b->sign)
584 tmp->sign = a->sign & b->sign;
594 /* Got two numbers. shift the smaller and increment the exponent till
599 a_normal_exp = a->normal_exp;
600 b_normal_exp = b->normal_exp;
601 a_fraction = a->fraction.ll;
602 b_fraction = b->fraction.ll;
604 diff = a_normal_exp - b_normal_exp;
608 if (diff < FRAC_NBITS)
610 /* ??? This does shifts one bit at a time. Optimize. */
611 while (a_normal_exp > b_normal_exp)
616 while (b_normal_exp > a_normal_exp)
624 /* Somethings's up.. choose the biggest */
625 if (a_normal_exp > b_normal_exp)
627 b_normal_exp = a_normal_exp;
632 a_normal_exp = b_normal_exp;
638 if (a->sign != b->sign)
642 tfraction = -a_fraction + b_fraction;
646 tfraction = a_fraction - b_fraction;
651 tmp->normal_exp = a_normal_exp;
652 tmp->fraction.ll = tfraction;
657 tmp->normal_exp = a_normal_exp;
658 tmp->fraction.ll = -tfraction;
660 /* and renormalize it */
662 while (tmp->fraction.ll < IMPLICIT_1 && tmp->fraction.ll)
664 tmp->fraction.ll <<= 1;
671 tmp->normal_exp = a_normal_exp;
672 tmp->fraction.ll = a_fraction + b_fraction;
674 tmp->class = CLASS_NUMBER;
675 /* Now the fraction is added, we have to shift down to renormalize the
678 if (tmp->fraction.ll >= IMPLICIT_2)
680 LSHIFT (tmp->fraction.ll);
688 add (FLO_type arg_a, FLO_type arg_b)
694 FLO_union_type au, bu;
702 res = _fpadd_parts (&a, &b, &tmp);
708 sub (FLO_type arg_a, FLO_type arg_b)
714 FLO_union_type au, bu;
724 res = _fpadd_parts (&a, &b, &tmp);
728 #endif /* L_addsub_sf || L_addsub_df */
730 #if defined(L_mul_sf) || defined(L_mul_df) || defined(L_mul_tf)
731 static inline __attribute__ ((__always_inline__)) fp_number_type *
732 _fpmul_parts ( fp_number_type * a,
734 fp_number_type * tmp)
741 a->sign = a->sign != b->sign;
746 b->sign = a->sign != b->sign;
753 a->sign = a->sign != b->sign;
762 b->sign = a->sign != b->sign;
767 a->sign = a->sign != b->sign;
772 b->sign = a->sign != b->sign;
776 /* Calculate the mantissa by multiplying both numbers to get a
777 twice-as-wide number. */
779 #if defined(NO_DI_MODE) || defined(TFLOAT)
781 fractype x = a->fraction.ll;
782 fractype ylow = b->fraction.ll;
786 /* ??? This does multiplies one bit at a time. Optimize. */
787 for (bit = 0; bit < FRAC_NBITS; bit++)
793 carry = (low += ylow) < ylow;
794 high += yhigh + carry;
806 /* Multiplying two USIs to get a UDI, we're safe. */
808 UDItype answer = (UDItype)a->fraction.ll * (UDItype)b->fraction.ll;
810 high = answer >> BITS_PER_SI;
814 /* fractype is DImode, but we need the result to be twice as wide.
815 Assuming a widening multiply from DImode to TImode is not
816 available, build one by hand. */
818 USItype nl = a->fraction.ll;
819 USItype nh = a->fraction.ll >> BITS_PER_SI;
820 USItype ml = b->fraction.ll;
821 USItype mh = b->fraction.ll >> BITS_PER_SI;
822 UDItype pp_ll = (UDItype) ml * nl;
823 UDItype pp_hl = (UDItype) mh * nl;
824 UDItype pp_lh = (UDItype) ml * nh;
825 UDItype pp_hh = (UDItype) mh * nh;
828 UDItype ps_hh__ = pp_hl + pp_lh;
830 res2 += (UDItype)1 << BITS_PER_SI;
831 pp_hl = (UDItype)(USItype)ps_hh__ << BITS_PER_SI;
832 res0 = pp_ll + pp_hl;
835 res2 += (ps_hh__ >> BITS_PER_SI) + pp_hh;
842 tmp->normal_exp = a->normal_exp + b->normal_exp
843 + FRAC_NBITS - (FRACBITS + NGARDS);
844 tmp->sign = a->sign != b->sign;
845 while (high >= IMPLICIT_2)
855 while (high < IMPLICIT_1)
864 /* rounding is tricky. if we only round if it won't make us round later. */
868 if (((high & GARDMASK) != GARDMSB)
869 && (((high + 1) & GARDMASK) == GARDMSB))
871 /* don't round, it gets done again later. */
879 if (!ROUND_TOWARDS_ZERO && (high & GARDMASK) == GARDMSB)
881 if (high & (1 << NGARDS))
883 /* half way, so round to even */
884 high += GARDROUND + 1;
888 /* but we really weren't half way */
889 high += GARDROUND + 1;
892 tmp->fraction.ll = high;
893 tmp->class = CLASS_NUMBER;
898 multiply (FLO_type arg_a, FLO_type arg_b)
904 FLO_union_type au, bu;
912 res = _fpmul_parts (&a, &b, &tmp);
916 #endif /* L_mul_sf || L_mul_df */
918 #if defined(L_div_sf) || defined(L_div_df) || defined(L_div_tf)
919 static inline __attribute__ ((__always_inline__)) fp_number_type *
920 _fpdiv_parts (fp_number_type * a,
925 fractype denominator;
937 a->sign = a->sign ^ b->sign;
939 if (isinf (a) || iszero (a))
941 if (a->class == b->class)
954 a->class = CLASS_INFINITY;
958 /* Calculate the mantissa by multiplying both 64bit numbers to get a
962 ( numerator / denominator) * 2^(numerator exponent - denominator exponent)
965 a->normal_exp = a->normal_exp - b->normal_exp;
966 numerator = a->fraction.ll;
967 denominator = b->fraction.ll;
969 if (numerator < denominator)
971 /* Fraction will be less than 1.0 */
977 /* ??? Does divide one bit at a time. Optimize. */
980 if (numerator >= denominator)
983 numerator -= denominator;
989 if (!ROUND_TOWARDS_ZERO && (quotient & GARDMASK) == GARDMSB)
991 if (quotient & (1 << NGARDS))
993 /* half way, so round to even */
994 quotient += GARDROUND + 1;
998 /* but we really weren't half way, more bits exist */
999 quotient += GARDROUND + 1;
1003 a->fraction.ll = quotient;
1009 divide (FLO_type arg_a, FLO_type arg_b)
1013 fp_number_type *res;
1014 FLO_union_type au, bu;
1022 res = _fpdiv_parts (&a, &b);
1024 return pack_d (res);
1026 #endif /* L_div_sf || L_div_df */
1028 #if defined(L_fpcmp_parts_sf) || defined(L_fpcmp_parts_df) \
1029 || defined(L_fpcmp_parts_tf)
1030 /* according to the demo, fpcmp returns a comparison with 0... thus
1037 __fpcmp_parts (fp_number_type * a, fp_number_type * b)
1040 /* either nan -> unordered. Must be checked outside of this routine. */
1041 if (isnan (a) && isnan (b))
1043 return 1; /* still unordered! */
1047 if (isnan (a) || isnan (b))
1049 return 1; /* how to indicate unordered compare? */
1051 if (isinf (a) && isinf (b))
1053 /* +inf > -inf, but +inf != +inf */
1054 /* b \a| +inf(0)| -inf(1)
1055 ______\+--------+--------
1056 +inf(0)| a==b(0)| a<b(-1)
1057 -------+--------+--------
1058 -inf(1)| a>b(1) | a==b(0)
1059 -------+--------+--------
1060 So since unordered must be nonzero, just line up the columns...
1062 return b->sign - a->sign;
1064 /* but not both... */
1067 return a->sign ? -1 : 1;
1071 return b->sign ? 1 : -1;
1073 if (iszero (a) && iszero (b))
1079 return b->sign ? 1 : -1;
1083 return a->sign ? -1 : 1;
1085 /* now both are "normal". */
1086 if (a->sign != b->sign)
1088 /* opposite signs */
1089 return a->sign ? -1 : 1;
1091 /* same sign; exponents? */
1092 if (a->normal_exp > b->normal_exp)
1094 return a->sign ? -1 : 1;
1096 if (a->normal_exp < b->normal_exp)
1098 return a->sign ? 1 : -1;
1100 /* same exponents; check size. */
1101 if (a->fraction.ll > b->fraction.ll)
1103 return a->sign ? -1 : 1;
1105 if (a->fraction.ll < b->fraction.ll)
1107 return a->sign ? 1 : -1;
1109 /* after all that, they're equal. */
1114 #if defined(L_compare_sf) || defined(L_compare_df) || defined(L_compoare_tf)
1116 compare (FLO_type arg_a, FLO_type arg_b)
1120 FLO_union_type au, bu;
1128 return __fpcmp_parts (&a, &b);
1130 #endif /* L_compare_sf || L_compare_df */
1132 #ifndef US_SOFTWARE_GOFAST
1134 /* These should be optimized for their specific tasks someday. */
1136 #if defined(L_eq_sf) || defined(L_eq_df) || defined(L_eq_tf)
1138 _eq_f2 (FLO_type arg_a, FLO_type arg_b)
1142 FLO_union_type au, bu;
1150 if (isnan (&a) || isnan (&b))
1151 return 1; /* false, truth == 0 */
1153 return __fpcmp_parts (&a, &b) ;
1155 #endif /* L_eq_sf || L_eq_df */
1157 #if defined(L_ne_sf) || defined(L_ne_df) || defined(L_ne_tf)
1159 _ne_f2 (FLO_type arg_a, FLO_type arg_b)
1163 FLO_union_type au, bu;
1171 if (isnan (&a) || isnan (&b))
1172 return 1; /* true, truth != 0 */
1174 return __fpcmp_parts (&a, &b) ;
1176 #endif /* L_ne_sf || L_ne_df */
1178 #if defined(L_gt_sf) || defined(L_gt_df) || defined(L_gt_tf)
1180 _gt_f2 (FLO_type arg_a, FLO_type arg_b)
1184 FLO_union_type au, bu;
1192 if (isnan (&a) || isnan (&b))
1193 return -1; /* false, truth > 0 */
1195 return __fpcmp_parts (&a, &b);
1197 #endif /* L_gt_sf || L_gt_df */
1199 #if defined(L_ge_sf) || defined(L_ge_df) || defined(L_ge_tf)
1201 _ge_f2 (FLO_type arg_a, FLO_type arg_b)
1205 FLO_union_type au, bu;
1213 if (isnan (&a) || isnan (&b))
1214 return -1; /* false, truth >= 0 */
1215 return __fpcmp_parts (&a, &b) ;
1217 #endif /* L_ge_sf || L_ge_df */
1219 #if defined(L_lt_sf) || defined(L_lt_df) || defined(L_lt_tf)
1221 _lt_f2 (FLO_type arg_a, FLO_type arg_b)
1225 FLO_union_type au, bu;
1233 if (isnan (&a) || isnan (&b))
1234 return 1; /* false, truth < 0 */
1236 return __fpcmp_parts (&a, &b);
1238 #endif /* L_lt_sf || L_lt_df */
1240 #if defined(L_le_sf) || defined(L_le_df) || defined(L_le_tf)
1242 _le_f2 (FLO_type arg_a, FLO_type arg_b)
1246 FLO_union_type au, bu;
1254 if (isnan (&a) || isnan (&b))
1255 return 1; /* false, truth <= 0 */
1257 return __fpcmp_parts (&a, &b) ;
1259 #endif /* L_le_sf || L_le_df */
1261 #endif /* ! US_SOFTWARE_GOFAST */
1263 #if defined(L_unord_sf) || defined(L_unord_df) || defined(L_unord_tf)
1265 _unord_f2 (FLO_type arg_a, FLO_type arg_b)
1269 FLO_union_type au, bu;
1277 return (isnan (&a) || isnan (&b));
1279 #endif /* L_unord_sf || L_unord_df */
1281 #if defined(L_si_to_sf) || defined(L_si_to_df) || defined(L_si_to_tf)
1283 si_to_float (SItype arg_a)
1287 in.class = CLASS_NUMBER;
1288 in.sign = arg_a < 0;
1291 in.class = CLASS_ZERO;
1295 in.normal_exp = FRACBITS + NGARDS;
1298 /* Special case for minint, since there is no +ve integer
1299 representation for it */
1300 if (arg_a == (- MAX_SI_INT - 1))
1302 return (FLO_type)(- MAX_SI_INT - 1);
1304 in.fraction.ll = (-arg_a);
1307 in.fraction.ll = arg_a;
1309 while (in.fraction.ll < ((fractype)1 << (FRACBITS + NGARDS)))
1311 in.fraction.ll <<= 1;
1315 return pack_d (&in);
1317 #endif /* L_si_to_sf || L_si_to_df */
1319 #if defined(L_usi_to_sf) || defined(L_usi_to_df) || defined(L_usi_to_tf)
1321 usi_to_float (USItype arg_a)
1328 in.class = CLASS_ZERO;
1332 in.class = CLASS_NUMBER;
1333 in.normal_exp = FRACBITS + NGARDS;
1334 in.fraction.ll = arg_a;
1336 while (in.fraction.ll > ((fractype)1 << (FRACBITS + NGARDS)))
1338 in.fraction.ll >>= 1;
1341 while (in.fraction.ll < ((fractype)1 << (FRACBITS + NGARDS)))
1343 in.fraction.ll <<= 1;
1347 return pack_d (&in);
1351 #if defined(L_sf_to_si) || defined(L_df_to_si) || defined(L_tf_to_si)
1353 float_to_si (FLO_type arg_a)
1366 /* get reasonable MAX_SI_INT... */
1368 return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
1369 /* it is a number, but a small one */
1370 if (a.normal_exp < 0)
1372 if (a.normal_exp > BITS_PER_SI - 2)
1373 return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
1374 tmp = a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
1375 return a.sign ? (-tmp) : (tmp);
1377 #endif /* L_sf_to_si || L_df_to_si */
1379 #if defined(L_sf_to_usi) || defined(L_df_to_usi) || defined(L_tf_to_usi)
1380 #if defined US_SOFTWARE_GOFAST || defined(L_tf_to_usi)
1381 /* While libgcc2.c defines its own __fixunssfsi and __fixunsdfsi routines,
1382 we also define them for GOFAST because the ones in libgcc2.c have the
1383 wrong names and I'd rather define these here and keep GOFAST CYG-LOC's
1384 out of libgcc2.c. We can't define these here if not GOFAST because then
1385 there'd be duplicate copies. */
1388 float_to_usi (FLO_type arg_a)
1400 /* it is a negative number */
1403 /* get reasonable MAX_USI_INT... */
1406 /* it is a number, but a small one */
1407 if (a.normal_exp < 0)
1409 if (a.normal_exp > BITS_PER_SI - 1)
1411 else if (a.normal_exp > (FRACBITS + NGARDS))
1412 return a.fraction.ll << (a.normal_exp - (FRACBITS + NGARDS));
1414 return a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
1416 #endif /* US_SOFTWARE_GOFAST */
1417 #endif /* L_sf_to_usi || L_df_to_usi */
1419 #if defined(L_negate_sf) || defined(L_negate_df) || defined(L_negate_tf)
1421 negate (FLO_type arg_a)
1432 #endif /* L_negate_sf || L_negate_df */
1436 #if defined(L_make_sf)
1438 __make_fp(fp_class_type class,
1447 in.normal_exp = exp;
1448 in.fraction.ll = frac;
1449 return pack_d (&in);
1451 #endif /* L_make_sf */
1455 /* This enables one to build an fp library that supports float but not double.
1456 Otherwise, we would get an undefined reference to __make_dp.
1457 This is needed for some 8-bit ports that can't handle well values that
1458 are 8-bytes in size, so we just don't support double for them at all. */
1460 #if defined(L_sf_to_df)
1462 sf_to_df (SFtype arg_a)
1468 unpack_d (&au, &in);
1470 return __make_dp (in.class, in.sign, in.normal_exp,
1471 ((UDItype) in.fraction.ll) << F_D_BITOFF);
1473 #endif /* L_sf_to_df */
1475 #if defined(L_sf_to_tf) && defined(TMODES)
1477 sf_to_tf (SFtype arg_a)
1483 unpack_d (&au, &in);
1485 return __make_tp (in.class, in.sign, in.normal_exp,
1486 ((UTItype) in.fraction.ll) << F_T_BITOFF);
1488 #endif /* L_sf_to_df */
1490 #endif /* ! FLOAT_ONLY */
1495 extern SFtype __make_fp (fp_class_type, unsigned int, int, USItype);
1497 #if defined(L_make_df)
1499 __make_dp (fp_class_type class, unsigned int sign, int exp, UDItype frac)
1505 in.normal_exp = exp;
1506 in.fraction.ll = frac;
1507 return pack_d (&in);
1509 #endif /* L_make_df */
1511 #if defined(L_df_to_sf)
1513 df_to_sf (DFtype arg_a)
1520 unpack_d (&au, &in);
1522 sffrac = in.fraction.ll >> F_D_BITOFF;
1524 /* We set the lowest guard bit in SFFRAC if we discarded any non
1526 if ((in.fraction.ll & (((USItype) 1 << F_D_BITOFF) - 1)) != 0)
1529 return __make_fp (in.class, in.sign, in.normal_exp, sffrac);
1531 #endif /* L_df_to_sf */
1533 #if defined(L_df_to_tf) && defined(TMODES) \
1534 && !defined(FLOAT) && !defined(TFLOAT)
1536 df_to_tf (DFtype arg_a)
1542 unpack_d (&au, &in);
1544 return __make_tp (in.class, in.sign, in.normal_exp,
1545 ((UTItype) in.fraction.ll) << D_T_BITOFF);
1547 #endif /* L_sf_to_df */
1550 #if defined(L_make_tf)
1552 __make_tp(fp_class_type class,
1561 in.normal_exp = exp;
1562 in.fraction.ll = frac;
1563 return pack_d (&in);
1565 #endif /* L_make_tf */
1567 #if defined(L_tf_to_df)
1569 tf_to_df (TFtype arg_a)
1576 unpack_d (&au, &in);
1578 sffrac = in.fraction.ll >> D_T_BITOFF;
1580 /* We set the lowest guard bit in SFFRAC if we discarded any non
1582 if ((in.fraction.ll & (((UTItype) 1 << D_T_BITOFF) - 1)) != 0)
1585 return __make_dp (in.class, in.sign, in.normal_exp, sffrac);
1587 #endif /* L_tf_to_df */
1589 #if defined(L_tf_to_sf)
1591 tf_to_sf (TFtype arg_a)
1598 unpack_d (&au, &in);
1600 sffrac = in.fraction.ll >> F_T_BITOFF;
1602 /* We set the lowest guard bit in SFFRAC if we discarded any non
1604 if ((in.fraction.ll & (((UTItype) 1 << F_T_BITOFF) - 1)) != 0)
1607 return __make_fp (in.class, in.sign, in.normal_exp, sffrac);
1609 #endif /* L_tf_to_sf */
1612 #endif /* ! FLOAT */
1613 #endif /* !EXTENDED_FLOAT_STUBS */