1 /* This is a software floating point library which can be used instead of
2 the floating point routines in libgcc1.c for targets without hardware
5 /* Copyright (C) 1994 Free Software Foundation, Inc.
7 This file is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file with other programs, and to distribute
15 those programs without any restriction coming from the use of this
16 file. (The General Public License restrictions do apply in other
17 respects; for example, they cover modification of the file, and
18 distribution when not linked into another program.)
20 This file is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; see the file COPYING. If not, write to
27 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, 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. */
46 /* The following macros can be defined to change the behaviour of this file:
47 FLOAT: Implement a `float', aka SFmode, fp library. If this is not
48 defined, then this file implements a `double', aka DFmode, fp library.
49 FLOAT_ONLY: Used with FLOAT, to implement a `float' only library, i.e.
50 don't include float->double conversion which requires the double library.
51 This is useful only for machines which can't support doubles, e.g. some
53 CMPtype: Specify the type that floating point compares should return.
54 This defaults to SItype, aka int.
55 US_SOFTWARE_GOFAST: This makes all entry points use the same names as the
56 US Software goFast library. If this is not defined, the entry points use
57 the same names as libgcc1.c.
58 _DEBUG_BITFLOAT: This makes debugging the code a little easier, by adding
59 two integers to the FLO_union_type.
60 NO_NANS: Disable nan and infinity handling
61 SMALL_MACHINE: Useful when operations on QIs and HIs are faster
64 typedef SFtype __attribute__ ((mode (SF)));
65 typedef DFtype __attribute__ ((mode (DF)));
67 typedef int HItype __attribute__ ((mode (HI)));
68 typedef int SItype __attribute__ ((mode (SI)));
69 typedef int DItype __attribute__ ((mode (DI)));
71 /* The type of the result of a fp compare */
73 #define CMPtype SItype
76 typedef unsigned int UHItype __attribute__ ((mode (HI)));
77 typedef unsigned int USItype __attribute__ ((mode (SI)));
78 typedef unsigned int UDItype __attribute__ ((mode (DI)));
80 #define MAX_SI_INT ((SItype) ((unsigned) (~0)>>1))
81 #define MAX_USI_INT ((USItype) ~0)
90 # define GARDROUND 0x3f
91 # define GARDMASK 0x7f
96 # define EXPMAX (0xff)
97 # define QUIET_NAN 0x100000L
98 # define FRAC_NBITS 32
99 # define FRACHIGH 0x80000000L
100 # define FRACHIGH2 0xc0000000L
101 typedef USItype fractype;
102 typedef UHItype halffractype;
103 typedef SFtype FLO_type;
104 typedef SItype intfrac;
107 # define PREFIXFPDP dp
108 # define PREFIXSFDF df
110 # define GARDROUND 0x7f
111 # define GARDMASK 0xff
112 # define GARDMSB 0x80
114 # define EXPBIAS 1023
116 # define EXPMAX (0x7ff)
117 # define QUIET_NAN 0x8000000000000LL
118 # define FRAC_NBITS 64
119 # define FRACHIGH 0x8000000000000000LL
120 # define FRACHIGH2 0xc000000000000000LL
121 typedef UDItype fractype;
122 typedef USItype halffractype;
123 typedef DFtype FLO_type;
124 typedef DItype intfrac;
127 #ifdef US_SOFTWARE_GOFAST
131 # define multiply fpmul
132 # define divide fpdiv
133 # define compare fpcmp
134 # define si_to_float sitofp
135 # define float_to_si fptosi
136 # define float_to_usi fptoui
137 # define negate __negsf2
138 # define sf_to_df fptodp
139 # define dptofp dptofp
143 # define multiply dpmul
144 # define divide dpdiv
145 # define compare dpcmp
146 # define si_to_float litodp
147 # define float_to_si dptoli
148 # define float_to_usi dptoul
149 # define negate __negdf2
150 # define df_to_sf dptofp
154 # define add __addsf3
155 # define sub __subsf3
156 # define multiply __mulsf3
157 # define divide __divsf3
158 # define compare __cmpsf2
159 # define _eq_f2 __eqsf2
160 # define _ne_f2 __nesf2
161 # define _gt_f2 __gtsf2
162 # define _ge_f2 __gesf2
163 # define _lt_f2 __ltsf2
164 # define _le_f2 __lesf2
165 # define si_to_float __floatsisf
166 # define float_to_si __fixsfsi
167 # define float_to_usi __fixunssfsi
168 # define negate __negsf2
169 # define sf_to_df __extendsfdf2
171 # define add __adddf3
172 # define sub __subdf3
173 # define multiply __muldf3
174 # define divide __divdf3
175 # define compare __cmpdf2
176 # define _eq_f2 __eqdf2
177 # define _ne_f2 __nedf2
178 # define _gt_f2 __gtdf2
179 # define _ge_f2 __gedf2
180 # define _lt_f2 __ltdf2
181 # define _le_f2 __ledf2
182 # define si_to_float __floatsidf
183 # define float_to_si __fixdfsi
184 # define float_to_usi __fixunsdfsi
185 # define negate __negdf2
186 # define df_to_sf __truncdfsf2
191 #define INLINE __inline__
193 /* Preserve the sticky-bit when shifting fractions to the right. */
194 #define LSHIFT(a) { a = (a & 1) | (a >> 1); }
196 /* numeric parameters */
197 /* F_D_BITOFF is the number of bits offset between the MSB of the mantissa
198 of a float and of a double. Assumes there are only two float types.
199 (double::FRAC_BITS+double::NGARGS-(float::FRAC_BITS-float::NGARDS))
201 #define F_D_BITOFF (52+8-(23+7))
204 #define NORMAL_EXPMIN (-(EXPBIAS)+1)
205 #define IMPLICIT_1 (1LL<<(FRACBITS+NGARDS))
206 #define IMPLICIT_2 (1LL<<(FRACBITS+1+NGARDS))
241 #ifdef _DEBUG_BITFLOAT
246 #ifndef FLOAT_BIT_ORDER_MISMATCH
247 unsigned int sign:1 __attribute__ ((packed));
248 unsigned int exp:EXPBITS __attribute__ ((packed));
249 fractype fraction:FRACBITS __attribute__ ((packed));
251 fractype fraction:FRACBITS __attribute__ ((packed));
252 unsigned int exp:EXPBITS __attribute__ ((packed));
253 unsigned int sign:1 __attribute__ ((packed));
263 /* IEEE "special" number predicates */
273 static fp_number_type *
276 static fp_number_type thenan;
283 isnan ( fp_number_type * x)
285 return x->class == CLASS_SNAN || x->class == CLASS_QNAN;
290 isinf ( fp_number_type * x)
292 return x->class == CLASS_INFINITY;
299 iszero ( fp_number_type * x)
301 return x->class == CLASS_ZERO;
306 flip_sign ( fp_number_type * x)
312 pack_d ( fp_number_type * src)
315 fractype fraction = src->fraction.ll; /* wasn't unsigned before? */
317 dst.bits.sign = src->sign;
321 dst.bits.exp = EXPMAX;
322 dst.bits.fraction = src->fraction.ll;
323 if (src->class == CLASS_QNAN || 1)
325 dst.bits.fraction |= QUIET_NAN;
328 else if (isinf (src))
330 dst.bits.exp = EXPMAX;
331 dst.bits.fraction = 0;
333 else if (iszero (src))
336 dst.bits.fraction = 0;
338 else if (fraction == 0)
344 if (src->normal_exp < NORMAL_EXPMIN)
346 /* This number's exponent is too low to fit into the bits
347 available in the number, so we'll store 0 in the exponent and
348 shift the fraction to the right to make up for it. */
350 int shift = NORMAL_EXPMIN - src->normal_exp;
354 if (shift > FRAC_NBITS - NGARDS)
356 /* No point shifting, since it's more that 64 out. */
361 /* Shift by the value */
365 dst.bits.fraction = fraction;
367 else if (src->normal_exp > EXPBIAS)
369 dst.bits.exp = EXPMAX;
370 dst.bits.fraction = 0;
374 dst.bits.exp = src->normal_exp + EXPBIAS;
375 /* IF the gard bits are the all zero, but the first, then we're
376 half way between two numbers, choose the one which makes the
377 lsb of the answer 0. */
378 if ((fraction & GARDMASK) == GARDMSB)
380 if (fraction & (1 << NGARDS))
381 fraction += GARDROUND + 1;
385 /* Add a one to the guards to round up */
386 fraction += GARDROUND;
388 if (fraction >= IMPLICIT_2)
394 dst.bits.fraction = fraction;
401 unpack_d (FLO_union_type * src, fp_number_type * dst)
403 fractype fraction = src->bits.fraction;
405 dst->sign = src->bits.sign;
406 if (src->bits.exp == 0)
408 /* Hmm. Looks like 0 */
411 /* tastes like zero */
412 dst->class = CLASS_ZERO;
416 /* Zero exponent with non zero fraction - it's denormalized,
417 so there isn't a leading implicit one - we'll shift it so
419 dst->normal_exp = src->bits.exp - EXPBIAS + 1;
422 dst->class = CLASS_NUMBER;
424 while (fraction < IMPLICIT_1)
430 dst->fraction.ll = fraction;
433 else if (src->bits.exp == EXPMAX)
438 /* Attatched to a zero fraction - means infinity */
439 dst->class = CLASS_INFINITY;
443 /* Non zero fraction, means nan */
446 dst->class = CLASS_SNAN;
450 dst->class = CLASS_QNAN;
452 /* Keep the fraction part as the nan number */
453 dst->fraction.ll = fraction;
458 /* Nothing strange about this number */
459 dst->normal_exp = src->bits.exp - EXPBIAS;
460 dst->class = CLASS_NUMBER;
461 dst->fraction.ll = (fraction << NGARDS) | IMPLICIT_1;
465 static fp_number_type *
466 _fpadd_parts (fp_number_type * a,
468 fp_number_type * tmp)
472 /* Put commonly used fields in local variables. */
503 /* Got two numbers. shift the smaller and increment the exponent till
508 a_normal_exp = a->normal_exp;
509 b_normal_exp = b->normal_exp;
510 a_fraction = a->fraction.ll;
511 b_fraction = b->fraction.ll;
513 diff = a_normal_exp - b_normal_exp;
517 if (diff < FRAC_NBITS)
519 /* ??? This does shifts one bit at a time. Optimize. */
520 while (a_normal_exp > b_normal_exp)
525 while (b_normal_exp > a_normal_exp)
533 /* Somethings's up.. choose the biggest */
534 if (a_normal_exp > b_normal_exp)
536 b_normal_exp = a_normal_exp;
541 a_normal_exp = b_normal_exp;
547 if (a->sign != b->sign)
551 tfraction = -a_fraction + b_fraction;
555 tfraction = a_fraction - b_fraction;
560 tmp->normal_exp = a_normal_exp;
561 tmp->fraction.ll = tfraction;
566 tmp->normal_exp = a_normal_exp;
567 tmp->fraction.ll = -tfraction;
569 /* and renomalize it */
571 while (tmp->fraction.ll < IMPLICIT_1 && tmp->fraction.ll)
573 tmp->fraction.ll <<= 1;
580 tmp->normal_exp = a_normal_exp;
581 tmp->fraction.ll = a_fraction + b_fraction;
583 tmp->class = CLASS_NUMBER;
584 /* Now the fraction is added, we have to shift down to renormalize the
587 if (tmp->fraction.ll >= IMPLICIT_2)
589 LSHIFT (tmp->fraction.ll);
597 add (FLO_type arg_a, FLO_type arg_b)
604 unpack_d ((FLO_union_type *) & arg_a, &a);
605 unpack_d ((FLO_union_type *) & arg_b, &b);
607 res = _fpadd_parts (&a, &b, &tmp);
613 sub (FLO_type arg_a, FLO_type arg_b)
620 unpack_d ((FLO_union_type *) & arg_a, &a);
621 unpack_d ((FLO_union_type *) & arg_b, &b);
625 res = _fpadd_parts (&a, &b, &tmp);
630 static fp_number_type *
631 _fpmul_parts ( fp_number_type * a,
633 fp_number_type * tmp)
640 a->sign = a->sign != b->sign;
645 b->sign = a->sign != b->sign;
652 a->sign = a->sign != b->sign;
661 b->sign = a->sign != b->sign;
666 a->sign = a->sign != b->sign;
671 b->sign = a->sign != b->sign;
675 /* Calculate the mantissa by multiplying both 64bit numbers to get a
678 fractype x = a->fraction.ll;
679 fractype ylow = b->fraction.ll;
683 #if defined(NO_DI_MODE)
685 /* ??? This does multiplies one bit at a time. Optimize. */
686 for (bit = 0; bit < FRAC_NBITS; bit++)
692 carry = (low += ylow) < ylow;
693 high += yhigh + carry;
706 /* Multiplying two 32 bit numbers to get a 64 bit number on
707 a machine with DI, so we're safe */
709 DItype answer = (DItype)(a->fraction.ll) * (DItype)(b->fraction.ll);
715 /* Doing a 64*64 to 128 */
717 UDItype nl = a->fraction.ll & 0xffffffff;
718 UDItype nh = a->fraction.ll >> 32;
719 UDItype ml = b->fraction.ll & 0xffffffff;
720 UDItype mh = b->fraction.ll >>32;
721 UDItype pp_ll = ml * nl;
722 UDItype pp_hl = mh * nl;
723 UDItype pp_lh = ml * nh;
724 UDItype pp_hh = mh * nh;
727 UDItype ps_hh__ = pp_hl + pp_lh;
729 res2 += 0x100000000LL;
730 pp_hl = (ps_hh__ << 32) & 0xffffffff00000000LL;
731 res0 = pp_ll + pp_hl;
734 res2 += ((ps_hh__ >> 32) & 0xffffffffL) + pp_hh;
741 tmp->normal_exp = a->normal_exp + b->normal_exp;
742 tmp->sign = a->sign != b->sign;
744 tmp->normal_exp += 2; /* ??????????????? */
746 tmp->normal_exp += 4; /* ??????????????? */
748 while (high >= IMPLICIT_2)
758 while (high < IMPLICIT_1)
767 /* rounding is tricky. if we only round if it won't make us round later. */
771 if (((high & GARDMASK) != GARDMSB)
772 && (((high + 1) & GARDMASK) == GARDMSB))
774 /* don't round, it gets done again later. */
782 if ((high & GARDMASK) == GARDMSB)
784 if (high & (1 << NGARDS))
786 /* half way, so round to even */
787 high += GARDROUND + 1;
791 /* but we really weren't half way */
792 high += GARDROUND + 1;
795 tmp->fraction.ll = high;
796 tmp->class = CLASS_NUMBER;
801 multiply (FLO_type arg_a, FLO_type arg_b)
808 unpack_d ((FLO_union_type *) & arg_a, &a);
809 unpack_d ((FLO_union_type *) & arg_b, &b);
811 res = _fpmul_parts (&a, &b, &tmp);
816 static fp_number_type *
817 _fpdiv_parts (fp_number_type * a,
819 fp_number_type * tmp)
823 fractype r0, r1, y0, y1, bit;
826 fractype denominator;
838 if (isinf (a) || iszero (a))
840 if (a->class == b->class)
844 a->sign = a->sign ^ b->sign;
854 a->class = CLASS_INFINITY;
858 /* Calculate the mantissa by multiplying both 64bit numbers to get a
862 intfrac d0, d1; /* weren't unsigned before ??? */
865 ( numerator / denominator) * 2^(numerator exponent - denominator exponent)
868 a->normal_exp = a->normal_exp - b->normal_exp;
869 numerator = a->fraction.ll;
870 denominator = b->fraction.ll;
872 if (numerator < denominator)
874 /* Fraction will be less than 1.0 */
880 /* ??? Does divide one bit at a time. Optimize. */
883 if (numerator >= denominator)
886 numerator -= denominator;
892 if ((quotient & GARDMASK) == GARDMSB)
894 if (quotient & (1 << NGARDS))
896 /* half way, so round to even */
897 quotient += GARDROUND + 1;
901 /* but we really weren't half way, more bits exist */
902 quotient += GARDROUND + 1;
906 a->fraction.ll = quotient;
912 divide (FLO_type arg_a, FLO_type arg_b)
919 unpack_d ((FLO_union_type *) & arg_a, &a);
920 unpack_d ((FLO_union_type *) & arg_b, &b);
922 res = _fpdiv_parts (&a, &b, &tmp);
927 /* according to the demo, fpcmp returns a comparison with 0... thus
934 _fpcmp_parts (fp_number_type * a, fp_number_type * b)
937 /* either nan -> unordered. Must be checked outside of this routine. */
938 if (isnan (a) && isnan (b))
940 return 1; /* still unordered! */
944 if (isnan (a) || isnan (b))
946 return 1; /* how to indicate unordered compare? */
948 if (isinf (a) && isinf (b))
950 /* +inf > -inf, but +inf != +inf */
951 /* b \a| +inf(0)| -inf(1)
952 ______\+--------+--------
953 +inf(0)| a==b(0)| a<b(-1)
954 -------+--------+--------
955 -inf(1)| a>b(1) | a==b(0)
956 -------+--------+--------
957 So since unordered must be non zero, just line up the columns...
959 return b->sign - a->sign;
961 /* but not both... */
964 return a->sign ? -1 : 1;
968 return b->sign ? 1 : -1;
970 if (iszero (a) && iszero (b))
976 return b->sign ? 1 : -1;
980 return a->sign ? -1 : 1;
982 /* now both are "normal". */
983 if (a->sign != b->sign)
986 return a->sign ? -1 : 1;
988 /* same sign; exponents? */
989 if (a->normal_exp > b->normal_exp)
991 return a->sign ? -1 : 1;
993 if (a->normal_exp < b->normal_exp)
995 return a->sign ? 1 : -1;
997 /* same exponents; check size. */
998 if (a->fraction.ll > b->fraction.ll)
1000 return a->sign ? -1 : 1;
1002 if (a->fraction.ll < b->fraction.ll)
1004 return a->sign ? 1 : -1;
1006 /* after all that, they're equal. */
1011 compare (FLO_type arg_a, FLO_type arg_b)
1016 unpack_d ((FLO_union_type *) & arg_a, &a);
1017 unpack_d ((FLO_union_type *) & arg_b, &b);
1019 return _fpcmp_parts (&a, &b);
1022 #ifndef US_SOFTWARE_GOFAST
1024 /* These should be optimized for their specific tasks someday. */
1027 _eq_f2 (FLO_type arg_a, FLO_type arg_b)
1032 unpack_d ((FLO_union_type *) & arg_a, &a);
1033 unpack_d ((FLO_union_type *) & arg_b, &b);
1035 if (isnan (&a) || isnan (&b))
1036 return 1; /* false, truth == 0 */
1038 return _fpcmp_parts (&a, &b) ;
1042 _ne_f2 (FLO_type arg_a, FLO_type arg_b)
1047 unpack_d ((FLO_union_type *) & arg_a, &a);
1048 unpack_d ((FLO_union_type *) & arg_b, &b);
1050 if (isnan (&a) || isnan (&b))
1051 return 1; /* true, truth != 0 */
1053 return _fpcmp_parts (&a, &b) ;
1057 _gt_f2 (FLO_type arg_a, FLO_type arg_b)
1062 unpack_d ((FLO_union_type *) & arg_a, &a);
1063 unpack_d ((FLO_union_type *) & arg_b, &b);
1065 if (isnan (&a) || isnan (&b))
1066 return -1; /* false, truth > 0 */
1068 return _fpcmp_parts (&a, &b);
1072 _ge_f2 (FLO_type arg_a, FLO_type arg_b)
1077 unpack_d ((FLO_union_type *) & arg_a, &a);
1078 unpack_d ((FLO_union_type *) & arg_b, &b);
1080 if (isnan (&a) || isnan (&b))
1081 return -1; /* false, truth >= 0 */
1082 return _fpcmp_parts (&a, &b) ;
1086 _lt_f2 (FLO_type arg_a, FLO_type arg_b)
1091 unpack_d ((FLO_union_type *) & arg_a, &a);
1092 unpack_d ((FLO_union_type *) & arg_b, &b);
1094 if (isnan (&a) || isnan (&b))
1095 return 1; /* false, truth < 0 */
1097 return _fpcmp_parts (&a, &b);
1101 _le_f2 (FLO_type arg_a, FLO_type arg_b)
1106 unpack_d ((FLO_union_type *) & arg_a, &a);
1107 unpack_d ((FLO_union_type *) & arg_b, &b);
1109 if (isnan (&a) || isnan (&b))
1110 return 1; /* false, truth <= 0 */
1112 return _fpcmp_parts (&a, &b) ;
1115 #endif /* ! US_SOFTWARE_GOFAST */
1118 si_to_float (SItype arg_a)
1122 in.class = CLASS_NUMBER;
1123 in.sign = arg_a < 0;
1126 in.class = CLASS_ZERO;
1130 in.normal_exp = FRACBITS + NGARDS;
1133 /* Special case for minint, since there is no +ve integer
1134 representation for it */
1135 if (arg_a == 0x80000000)
1137 return -2147483648.0;
1139 in.fraction.ll = (-arg_a);
1142 in.fraction.ll = arg_a;
1144 while (in.fraction.ll < (1LL << (FRACBITS + NGARDS)))
1146 in.fraction.ll <<= 1;
1150 return pack_d (&in);
1154 float_to_si (FLO_type arg_a)
1159 unpack_d ((FLO_union_type *) & arg_a, &a);
1164 /* get reasonable MAX_SI_INT... */
1166 return a.sign ? MAX_SI_INT : (-MAX_SI_INT)-1;
1167 /* it is a number, but a small one */
1168 if (a.normal_exp < 0)
1170 if (a.normal_exp > 30)
1171 return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
1172 tmp = a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
1173 return a.sign ? (-tmp) : (tmp);
1176 #ifdef US_SOFTWARE_GOFAST
1177 /* While libgcc2.c defines its own __fixunssfsi and __fixunsdfsi routines,
1178 we also define them for GOFAST because the ones in libgcc2.c have the
1179 wrong names and I'd rather define these here and keep GOFAST CYG-LOC's
1180 out of libgcc2.c. We can't define these here if not GOFAST because then
1181 there'd be duplicate copies. */
1184 float_to_usi (FLO_type arg_a)
1188 unpack_d ((FLO_union_type *) & arg_a, &a);
1193 /* get reasonable MAX_USI_INT... */
1195 return a.sign ? MAX_USI_INT : 0;
1196 /* it is a negative number */
1199 /* it is a number, but a small one */
1200 if (a.normal_exp < 0)
1202 if (a.normal_exp > 31)
1204 else if (a.normal_exp > (FRACBITS + NGARDS))
1205 return a.fraction.ll << ((FRACBITS + NGARDS) - a.normal_exp);
1207 return a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
1212 negate (FLO_type arg_a)
1216 unpack_d ((FLO_union_type *) & arg_a, &a);
1224 __make_fp(fp_class_type class,
1233 in.normal_exp = exp;
1234 in.fraction.ll = frac;
1235 return pack_d (&in);
1240 /* This enables one to build an fp library that supports float but not double.
1241 Otherwise, we would get an undefined reference to __make_dp.
1242 This is needed for some 8-bit ports that can't handle well values that
1243 are 8-bytes in size, so we just don't support double for them at all. */
1245 extern DFtype __make_dp (fp_class_type, unsigned int, int, UDItype frac);
1248 sf_to_df (SFtype arg_a)
1252 unpack_d ((FLO_union_type *) & arg_a, &in);
1253 return __make_dp (in.class, in.sign, in.normal_exp,
1254 ((UDItype) in.fraction.ll) << F_D_BITOFF);
1262 extern SFtype __make_fp (fp_class_type, unsigned int, int, USItype);
1265 __make_dp (fp_class_type class, unsigned int sign, int exp, UDItype frac)
1271 in.normal_exp = exp;
1272 in.fraction.ll = frac;
1273 return pack_d (&in);
1277 df_to_sf (DFtype arg_a)
1281 unpack_d ((FLO_union_type *) & arg_a, &in);
1282 return __make_fp (in.class, in.sign, in.normal_exp,
1283 in.fraction.ll >> F_D_BITOFF);