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 dst.value_raw = fraction & ((((fractype)1) << FRACBITS) - (fractype)1);
328 dst.value_raw |= ((fractype) (exp & ((1 << EXPBITS) - 1))) << FRACBITS;
329 dst.value_raw |= ((fractype) (sign & 1)) << (FRACBITS | EXPBITS);
332 #if defined(FLOAT_WORD_ORDER_MISMATCH) && !defined(FLOAT)
335 qrtrfractype tmp1 = dst.words[0];
336 qrtrfractype tmp2 = dst.words[1];
337 dst.words[0] = dst.words[3];
338 dst.words[1] = dst.words[2];
344 halffractype tmp = dst.words[0];
345 dst.words[0] = dst.words[1];
355 #if defined(L_unpack_df) || defined(L_unpack_sf) || defined(L_unpack_tf)
357 unpack_d (FLO_union_type * src, fp_number_type * dst)
359 /* We previously used bitfields to store the number, but this doesn't
360 handle little/big endian systems conveniently, so use shifts and
366 #if defined(FLOAT_WORD_ORDER_MISMATCH) && !defined(FLOAT)
367 FLO_union_type swapped;
370 swapped.words[0] = src->words[3];
371 swapped.words[1] = src->words[2];
372 swapped.words[2] = src->words[1];
373 swapped.words[3] = src->words[0];
375 swapped.words[0] = src->words[1];
376 swapped.words[1] = src->words[0];
381 #ifdef FLOAT_BIT_ORDER_MISMATCH
382 fraction = src->bits.fraction;
384 sign = src->bits.sign;
386 fraction = src->value_raw & ((((fractype)1) << FRACBITS) - 1);
387 exp = ((int)(src->value_raw >> FRACBITS)) & ((1 << EXPBITS) - 1);
388 sign = ((int)(src->value_raw >> (FRACBITS + EXPBITS))) & 1;
394 /* Hmm. Looks like 0 */
401 /* tastes like zero */
402 dst->class = CLASS_ZERO;
406 /* Zero exponent with nonzero fraction - it's denormalized,
407 so there isn't a leading implicit one - we'll shift it so
409 dst->normal_exp = exp - EXPBIAS + 1;
412 dst->class = CLASS_NUMBER;
414 while (fraction < IMPLICIT_1)
420 dst->fraction.ll = fraction;
423 else if (!LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && exp == EXPMAX)
428 /* Attached to a zero fraction - means infinity */
429 dst->class = CLASS_INFINITY;
433 /* Nonzero fraction, means nan */
434 if (fraction & QUIET_NAN)
436 dst->class = CLASS_QNAN;
440 dst->class = CLASS_SNAN;
442 /* Keep the fraction part as the nan number */
443 dst->fraction.ll = fraction;
448 /* Nothing strange about this number */
449 dst->normal_exp = exp - EXPBIAS;
450 dst->class = CLASS_NUMBER;
451 dst->fraction.ll = (fraction << NGARDS) | IMPLICIT_1;
454 #endif /* L_unpack_df || L_unpack_sf */
456 #if defined(L_addsub_sf) || defined(L_addsub_df) || defined(L_addsub_tf)
457 static fp_number_type *
458 _fpadd_parts (fp_number_type * a,
460 fp_number_type * tmp)
464 /* Put commonly used fields in local variables. */
480 /* Adding infinities with opposite signs yields a NaN. */
481 if (isinf (b) && a->sign != b->sign)
494 tmp->sign = a->sign & b->sign;
504 /* Got two numbers. shift the smaller and increment the exponent till
509 a_normal_exp = a->normal_exp;
510 b_normal_exp = b->normal_exp;
511 a_fraction = a->fraction.ll;
512 b_fraction = b->fraction.ll;
514 diff = a_normal_exp - b_normal_exp;
518 if (diff < FRAC_NBITS)
520 /* ??? This does shifts one bit at a time. Optimize. */
521 while (a_normal_exp > b_normal_exp)
526 while (b_normal_exp > a_normal_exp)
534 /* Somethings's up.. choose the biggest */
535 if (a_normal_exp > b_normal_exp)
537 b_normal_exp = a_normal_exp;
542 a_normal_exp = b_normal_exp;
548 if (a->sign != b->sign)
552 tfraction = -a_fraction + b_fraction;
556 tfraction = a_fraction - b_fraction;
561 tmp->normal_exp = a_normal_exp;
562 tmp->fraction.ll = tfraction;
567 tmp->normal_exp = a_normal_exp;
568 tmp->fraction.ll = -tfraction;
570 /* and renormalize it */
572 while (tmp->fraction.ll < IMPLICIT_1 && tmp->fraction.ll)
574 tmp->fraction.ll <<= 1;
581 tmp->normal_exp = a_normal_exp;
582 tmp->fraction.ll = a_fraction + b_fraction;
584 tmp->class = CLASS_NUMBER;
585 /* Now the fraction is added, we have to shift down to renormalize the
588 if (tmp->fraction.ll >= IMPLICIT_2)
590 LSHIFT (tmp->fraction.ll);
598 add (FLO_type arg_a, FLO_type arg_b)
604 FLO_union_type au, bu;
612 res = _fpadd_parts (&a, &b, &tmp);
618 sub (FLO_type arg_a, FLO_type arg_b)
624 FLO_union_type au, bu;
634 res = _fpadd_parts (&a, &b, &tmp);
638 #endif /* L_addsub_sf || L_addsub_df */
640 #if defined(L_mul_sf) || defined(L_mul_df) || defined(L_mul_tf)
641 static inline __attribute__ ((__always_inline__)) fp_number_type *
642 _fpmul_parts ( fp_number_type * a,
644 fp_number_type * tmp)
651 a->sign = a->sign != b->sign;
656 b->sign = a->sign != b->sign;
663 a->sign = a->sign != b->sign;
672 b->sign = a->sign != b->sign;
677 a->sign = a->sign != b->sign;
682 b->sign = a->sign != b->sign;
686 /* Calculate the mantissa by multiplying both numbers to get a
687 twice-as-wide number. */
689 #if defined(NO_DI_MODE) || defined(TFLOAT)
691 fractype x = a->fraction.ll;
692 fractype ylow = b->fraction.ll;
696 /* ??? This does multiplies one bit at a time. Optimize. */
697 for (bit = 0; bit < FRAC_NBITS; bit++)
703 carry = (low += ylow) < ylow;
704 high += yhigh + carry;
716 /* Multiplying two USIs to get a UDI, we're safe. */
718 UDItype answer = (UDItype)a->fraction.ll * (UDItype)b->fraction.ll;
720 high = answer >> BITS_PER_SI;
724 /* fractype is DImode, but we need the result to be twice as wide.
725 Assuming a widening multiply from DImode to TImode is not
726 available, build one by hand. */
728 USItype nl = a->fraction.ll;
729 USItype nh = a->fraction.ll >> BITS_PER_SI;
730 USItype ml = b->fraction.ll;
731 USItype mh = b->fraction.ll >> BITS_PER_SI;
732 UDItype pp_ll = (UDItype) ml * nl;
733 UDItype pp_hl = (UDItype) mh * nl;
734 UDItype pp_lh = (UDItype) ml * nh;
735 UDItype pp_hh = (UDItype) mh * nh;
738 UDItype ps_hh__ = pp_hl + pp_lh;
740 res2 += (UDItype)1 << BITS_PER_SI;
741 pp_hl = (UDItype)(USItype)ps_hh__ << BITS_PER_SI;
742 res0 = pp_ll + pp_hl;
745 res2 += (ps_hh__ >> BITS_PER_SI) + pp_hh;
752 tmp->normal_exp = a->normal_exp + b->normal_exp
753 + FRAC_NBITS - (FRACBITS + NGARDS);
754 tmp->sign = a->sign != b->sign;
755 while (high >= IMPLICIT_2)
765 while (high < IMPLICIT_1)
774 /* rounding is tricky. if we only round if it won't make us round later. */
778 if (((high & GARDMASK) != GARDMSB)
779 && (((high + 1) & GARDMASK) == GARDMSB))
781 /* don't round, it gets done again later. */
789 if (!ROUND_TOWARDS_ZERO && (high & GARDMASK) == GARDMSB)
791 if (high & (1 << NGARDS))
793 /* half way, so round to even */
794 high += GARDROUND + 1;
798 /* but we really weren't half way */
799 high += GARDROUND + 1;
802 tmp->fraction.ll = high;
803 tmp->class = CLASS_NUMBER;
808 multiply (FLO_type arg_a, FLO_type arg_b)
814 FLO_union_type au, bu;
822 res = _fpmul_parts (&a, &b, &tmp);
826 #endif /* L_mul_sf || L_mul_df */
828 #if defined(L_div_sf) || defined(L_div_df) || defined(L_div_tf)
829 static inline __attribute__ ((__always_inline__)) fp_number_type *
830 _fpdiv_parts (fp_number_type * a,
835 fractype denominator;
847 a->sign = a->sign ^ b->sign;
849 if (isinf (a) || iszero (a))
851 if (a->class == b->class)
864 a->class = CLASS_INFINITY;
868 /* Calculate the mantissa by multiplying both 64bit numbers to get a
872 ( numerator / denominator) * 2^(numerator exponent - denominator exponent)
875 a->normal_exp = a->normal_exp - b->normal_exp;
876 numerator = a->fraction.ll;
877 denominator = b->fraction.ll;
879 if (numerator < denominator)
881 /* Fraction will be less than 1.0 */
887 /* ??? Does divide one bit at a time. Optimize. */
890 if (numerator >= denominator)
893 numerator -= denominator;
899 if (!ROUND_TOWARDS_ZERO && (quotient & GARDMASK) == GARDMSB)
901 if (quotient & (1 << NGARDS))
903 /* half way, so round to even */
904 quotient += GARDROUND + 1;
908 /* but we really weren't half way, more bits exist */
909 quotient += GARDROUND + 1;
913 a->fraction.ll = quotient;
919 divide (FLO_type arg_a, FLO_type arg_b)
924 FLO_union_type au, bu;
932 res = _fpdiv_parts (&a, &b);
936 #endif /* L_div_sf || L_div_df */
938 #if defined(L_fpcmp_parts_sf) || defined(L_fpcmp_parts_df) \
939 || defined(L_fpcmp_parts_tf)
940 /* according to the demo, fpcmp returns a comparison with 0... thus
947 __fpcmp_parts (fp_number_type * a, fp_number_type * b)
950 /* either nan -> unordered. Must be checked outside of this routine. */
951 if (isnan (a) && isnan (b))
953 return 1; /* still unordered! */
957 if (isnan (a) || isnan (b))
959 return 1; /* how to indicate unordered compare? */
961 if (isinf (a) && isinf (b))
963 /* +inf > -inf, but +inf != +inf */
964 /* b \a| +inf(0)| -inf(1)
965 ______\+--------+--------
966 +inf(0)| a==b(0)| a<b(-1)
967 -------+--------+--------
968 -inf(1)| a>b(1) | a==b(0)
969 -------+--------+--------
970 So since unordered must be nonzero, just line up the columns...
972 return b->sign - a->sign;
974 /* but not both... */
977 return a->sign ? -1 : 1;
981 return b->sign ? 1 : -1;
983 if (iszero (a) && iszero (b))
989 return b->sign ? 1 : -1;
993 return a->sign ? -1 : 1;
995 /* now both are "normal". */
996 if (a->sign != b->sign)
999 return a->sign ? -1 : 1;
1001 /* same sign; exponents? */
1002 if (a->normal_exp > b->normal_exp)
1004 return a->sign ? -1 : 1;
1006 if (a->normal_exp < b->normal_exp)
1008 return a->sign ? 1 : -1;
1010 /* same exponents; check size. */
1011 if (a->fraction.ll > b->fraction.ll)
1013 return a->sign ? -1 : 1;
1015 if (a->fraction.ll < b->fraction.ll)
1017 return a->sign ? 1 : -1;
1019 /* after all that, they're equal. */
1024 #if defined(L_compare_sf) || defined(L_compare_df) || defined(L_compoare_tf)
1026 compare (FLO_type arg_a, FLO_type arg_b)
1030 FLO_union_type au, bu;
1038 return __fpcmp_parts (&a, &b);
1040 #endif /* L_compare_sf || L_compare_df */
1042 #ifndef US_SOFTWARE_GOFAST
1044 /* These should be optimized for their specific tasks someday. */
1046 #if defined(L_eq_sf) || defined(L_eq_df) || defined(L_eq_tf)
1048 _eq_f2 (FLO_type arg_a, FLO_type arg_b)
1052 FLO_union_type au, bu;
1060 if (isnan (&a) || isnan (&b))
1061 return 1; /* false, truth == 0 */
1063 return __fpcmp_parts (&a, &b) ;
1065 #endif /* L_eq_sf || L_eq_df */
1067 #if defined(L_ne_sf) || defined(L_ne_df) || defined(L_ne_tf)
1069 _ne_f2 (FLO_type arg_a, FLO_type arg_b)
1073 FLO_union_type au, bu;
1081 if (isnan (&a) || isnan (&b))
1082 return 1; /* true, truth != 0 */
1084 return __fpcmp_parts (&a, &b) ;
1086 #endif /* L_ne_sf || L_ne_df */
1088 #if defined(L_gt_sf) || defined(L_gt_df) || defined(L_gt_tf)
1090 _gt_f2 (FLO_type arg_a, FLO_type arg_b)
1094 FLO_union_type au, bu;
1102 if (isnan (&a) || isnan (&b))
1103 return -1; /* false, truth > 0 */
1105 return __fpcmp_parts (&a, &b);
1107 #endif /* L_gt_sf || L_gt_df */
1109 #if defined(L_ge_sf) || defined(L_ge_df) || defined(L_ge_tf)
1111 _ge_f2 (FLO_type arg_a, FLO_type arg_b)
1115 FLO_union_type au, bu;
1123 if (isnan (&a) || isnan (&b))
1124 return -1; /* false, truth >= 0 */
1125 return __fpcmp_parts (&a, &b) ;
1127 #endif /* L_ge_sf || L_ge_df */
1129 #if defined(L_lt_sf) || defined(L_lt_df) || defined(L_lt_tf)
1131 _lt_f2 (FLO_type arg_a, FLO_type arg_b)
1135 FLO_union_type au, bu;
1143 if (isnan (&a) || isnan (&b))
1144 return 1; /* false, truth < 0 */
1146 return __fpcmp_parts (&a, &b);
1148 #endif /* L_lt_sf || L_lt_df */
1150 #if defined(L_le_sf) || defined(L_le_df) || defined(L_le_tf)
1152 _le_f2 (FLO_type arg_a, FLO_type arg_b)
1156 FLO_union_type au, bu;
1164 if (isnan (&a) || isnan (&b))
1165 return 1; /* false, truth <= 0 */
1167 return __fpcmp_parts (&a, &b) ;
1169 #endif /* L_le_sf || L_le_df */
1171 #endif /* ! US_SOFTWARE_GOFAST */
1173 #if defined(L_unord_sf) || defined(L_unord_df) || defined(L_unord_tf)
1175 _unord_f2 (FLO_type arg_a, FLO_type arg_b)
1179 FLO_union_type au, bu;
1187 return (isnan (&a) || isnan (&b));
1189 #endif /* L_unord_sf || L_unord_df */
1191 #if defined(L_si_to_sf) || defined(L_si_to_df) || defined(L_si_to_tf)
1193 si_to_float (SItype arg_a)
1197 in.class = CLASS_NUMBER;
1198 in.sign = arg_a < 0;
1201 in.class = CLASS_ZERO;
1205 in.normal_exp = FRACBITS + NGARDS;
1208 /* Special case for minint, since there is no +ve integer
1209 representation for it */
1210 if (arg_a == (- MAX_SI_INT - 1))
1212 return (FLO_type)(- MAX_SI_INT - 1);
1214 in.fraction.ll = (-arg_a);
1217 in.fraction.ll = arg_a;
1219 while (in.fraction.ll < ((fractype)1 << (FRACBITS + NGARDS)))
1221 in.fraction.ll <<= 1;
1225 return pack_d (&in);
1227 #endif /* L_si_to_sf || L_si_to_df */
1229 #if defined(L_usi_to_sf) || defined(L_usi_to_df) || defined(L_usi_to_tf)
1231 usi_to_float (USItype arg_a)
1238 in.class = CLASS_ZERO;
1242 in.class = CLASS_NUMBER;
1243 in.normal_exp = FRACBITS + NGARDS;
1244 in.fraction.ll = arg_a;
1246 while (in.fraction.ll > ((fractype)1 << (FRACBITS + NGARDS)))
1248 in.fraction.ll >>= 1;
1251 while (in.fraction.ll < ((fractype)1 << (FRACBITS + NGARDS)))
1253 in.fraction.ll <<= 1;
1257 return pack_d (&in);
1261 #if defined(L_sf_to_si) || defined(L_df_to_si) || defined(L_tf_to_si)
1263 float_to_si (FLO_type arg_a)
1276 /* get reasonable MAX_SI_INT... */
1278 return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
1279 /* it is a number, but a small one */
1280 if (a.normal_exp < 0)
1282 if (a.normal_exp > BITS_PER_SI - 2)
1283 return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
1284 tmp = a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
1285 return a.sign ? (-tmp) : (tmp);
1287 #endif /* L_sf_to_si || L_df_to_si */
1289 #if defined(L_sf_to_usi) || defined(L_df_to_usi) || defined(L_tf_to_usi)
1290 #if defined US_SOFTWARE_GOFAST || defined(L_tf_to_usi)
1291 /* While libgcc2.c defines its own __fixunssfsi and __fixunsdfsi routines,
1292 we also define them for GOFAST because the ones in libgcc2.c have the
1293 wrong names and I'd rather define these here and keep GOFAST CYG-LOC's
1294 out of libgcc2.c. We can't define these here if not GOFAST because then
1295 there'd be duplicate copies. */
1298 float_to_usi (FLO_type arg_a)
1310 /* it is a negative number */
1313 /* get reasonable MAX_USI_INT... */
1316 /* it is a number, but a small one */
1317 if (a.normal_exp < 0)
1319 if (a.normal_exp > BITS_PER_SI - 1)
1321 else if (a.normal_exp > (FRACBITS + NGARDS))
1322 return a.fraction.ll << (a.normal_exp - (FRACBITS + NGARDS));
1324 return a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
1326 #endif /* US_SOFTWARE_GOFAST */
1327 #endif /* L_sf_to_usi || L_df_to_usi */
1329 #if defined(L_negate_sf) || defined(L_negate_df) || defined(L_negate_tf)
1331 negate (FLO_type arg_a)
1342 #endif /* L_negate_sf || L_negate_df */
1346 #if defined(L_make_sf)
1348 __make_fp(fp_class_type class,
1357 in.normal_exp = exp;
1358 in.fraction.ll = frac;
1359 return pack_d (&in);
1361 #endif /* L_make_sf */
1365 /* This enables one to build an fp library that supports float but not double.
1366 Otherwise, we would get an undefined reference to __make_dp.
1367 This is needed for some 8-bit ports that can't handle well values that
1368 are 8-bytes in size, so we just don't support double for them at all. */
1370 #if defined(L_sf_to_df)
1372 sf_to_df (SFtype arg_a)
1378 unpack_d (&au, &in);
1380 return __make_dp (in.class, in.sign, in.normal_exp,
1381 ((UDItype) in.fraction.ll) << F_D_BITOFF);
1383 #endif /* L_sf_to_df */
1385 #if defined(L_sf_to_tf) && defined(TMODES)
1387 sf_to_tf (SFtype arg_a)
1393 unpack_d (&au, &in);
1395 return __make_tp (in.class, in.sign, in.normal_exp,
1396 ((UTItype) in.fraction.ll) << F_T_BITOFF);
1398 #endif /* L_sf_to_df */
1400 #endif /* ! FLOAT_ONLY */
1405 extern SFtype __make_fp (fp_class_type, unsigned int, int, USItype);
1407 #if defined(L_make_df)
1409 __make_dp (fp_class_type class, unsigned int sign, int exp, UDItype frac)
1415 in.normal_exp = exp;
1416 in.fraction.ll = frac;
1417 return pack_d (&in);
1419 #endif /* L_make_df */
1421 #if defined(L_df_to_sf)
1423 df_to_sf (DFtype arg_a)
1430 unpack_d (&au, &in);
1432 sffrac = in.fraction.ll >> F_D_BITOFF;
1434 /* We set the lowest guard bit in SFFRAC if we discarded any non
1436 if ((in.fraction.ll & (((USItype) 1 << F_D_BITOFF) - 1)) != 0)
1439 return __make_fp (in.class, in.sign, in.normal_exp, sffrac);
1441 #endif /* L_df_to_sf */
1443 #if defined(L_df_to_tf) && defined(TMODES) \
1444 && !defined(FLOAT) && !defined(TFLOAT)
1446 df_to_tf (DFtype arg_a)
1452 unpack_d (&au, &in);
1454 return __make_tp (in.class, in.sign, in.normal_exp,
1455 ((UTItype) in.fraction.ll) << D_T_BITOFF);
1457 #endif /* L_sf_to_df */
1460 #if defined(L_make_tf)
1462 __make_tp(fp_class_type class,
1471 in.normal_exp = exp;
1472 in.fraction.ll = frac;
1473 return pack_d (&in);
1475 #endif /* L_make_tf */
1477 #if defined(L_tf_to_df)
1479 tf_to_df (TFtype arg_a)
1486 unpack_d (&au, &in);
1488 sffrac = in.fraction.ll >> D_T_BITOFF;
1490 /* We set the lowest guard bit in SFFRAC if we discarded any non
1492 if ((in.fraction.ll & (((UTItype) 1 << D_T_BITOFF) - 1)) != 0)
1495 return __make_dp (in.class, in.sign, in.normal_exp, sffrac);
1497 #endif /* L_tf_to_df */
1499 #if defined(L_tf_to_sf)
1501 tf_to_sf (TFtype arg_a)
1508 unpack_d (&au, &in);
1510 sffrac = in.fraction.ll >> F_T_BITOFF;
1512 /* We set the lowest guard bit in SFFRAC if we discarded any non
1514 if ((in.fraction.ll & (((UTItype) 1 << F_T_BITOFF) - 1)) != 0)
1517 return __make_fp (in.class, in.sign, in.normal_exp, sffrac);
1519 #endif /* L_tf_to_sf */
1522 #endif /* ! FLOAT */
1523 #endif /* !EXTENDED_FLOAT_STUBS */