OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

re PR middle-end/19920 (build broken on several targets due to recent 'DC' type update to libgcc2) 

PR 19920
        * libgcc2.c (WORD_SIZE): Remove all definitions; replace uses
        with W_TYPE_SIZE.
        (HIGH_WORD_COEFF, HIGH_HALFWORD_COEFF): Remove all definitions;
        replace uses with Wtype_MAXp1_F.
        (L_fixunstfdi, L_fixtfdi, L_floatditf, L_fixunsxfdi, L_fixxfdi,
        L_floatdixf, L_fixunsxfsi, L_fixunsdfdi, L_floatdidf, L_fixunsdfsi,
        L_powidf2, L_powixf2, L_powitf2, L_muldc3, L_divdc3, L_mulxc3,
        L_divxc3, L_multc3, L_divtc3): Protect with HAVE_DFMODE, HAVE_XFMODE,
        and HAVE_TFMODE as appropriate.
        (__fixunssfDI): Provide an implementation that doesn't need DFmode.
        (__floatdisf): Likewise.
        * libgcc2.h (LIBGCC2_DOUBLE_TYPE_SIZE): New.
        (HAVE_DFMODE, HAVE_XFMODE, HAVE_TFMODE): New.
        (Wtype_MAXp1_F): New.
        (DFtype, DCtype, __fixdfdi, __floatdidf, __fixunsdfSI, __fixunsdfDI,
        __powidf2, __divdc3, __muldc3): Protect with HAVE_DFMODE.

From-SVN: r95121
This commit is contained in:
Richard Henderson 2005-02-16 14:55:33 -08:00 committed by Richard Henderson
parent 9f7bf991d0
commit 4f2e0d5ecc
3 changed files with 200 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
gcc/ChangeLog
View File

@ -1,3 +1,23 @@
2005-02-16 Richard Henderson <rth@redhat.com>
PR 19920
* libgcc2.c (WORD_SIZE): Remove all definitions; replace uses
with W_TYPE_SIZE.
(HIGH_WORD_COEFF, HIGH_HALFWORD_COEFF): Remove all definitions;
replace uses with Wtype_MAXp1_F.
(L_fixunstfdi, L_fixtfdi, L_floatditf, L_fixunsxfdi, L_fixxfdi,
L_floatdixf, L_fixunsxfsi, L_fixunsdfdi, L_floatdidf, L_fixunsdfsi,
L_powidf2, L_powixf2, L_powitf2, L_muldc3, L_divdc3, L_mulxc3,
L_divxc3, L_multc3, L_divtc3): Protect with HAVE_DFMODE, HAVE_XFMODE,
and HAVE_TFMODE as appropriate.
(__fixunssfDI): Provide an implementation that doesn't need DFmode.
(__floatdisf): Likewise.
* libgcc2.h (LIBGCC2_DOUBLE_TYPE_SIZE): New.
(HAVE_DFMODE, HAVE_XFMODE, HAVE_TFMODE): New.
(Wtype_MAXp1_F): New.
(DFtype, DCtype, __fixdfdi, __floatdidf, __fixunsdfSI, __fixunsdfDI,
__powidf2, __divdc3, __muldc3): Protect with HAVE_DFMODE.
2005-02-16 Richard Earnshaw <rearnsha@arm.com>
* PR target/19162

245
gcc/libgcc2.c
View File

@ -148,13 +148,12 @@ __subvDI3 (DWtype a, DWtype b)
#endif
#ifdef L_mulvsi3
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
Wtype
__mulvSI3 (Wtype a, Wtype b)
{
const DWtype w = (DWtype) a * (DWtype) b;
if ((Wtype) (w >> WORD_SIZE) != (Wtype) w >> (WORD_SIZE - 1))
if ((Wtype) (w >> W_TYPE_SIZE) != (Wtype) w >> (W_TYPE_SIZE - 1))
abort ();
return w;
@ -273,7 +272,6 @@ __absvDI2 (DWtype a)
#endif
#ifdef L_mulvdi3
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
DWtype
__mulvDI3 (DWtype u, DWtype v)
{
@ -282,10 +280,10 @@ __mulvDI3 (DWtype u, DWtype v)
const DWunion uu = {.ll = u};
const DWunion vv = {.ll = v};
if (__builtin_expect (uu.s.high == uu.s.low >> (WORD_SIZE - 1), 1))
if (__builtin_expect (uu.s.high == uu.s.low >> (W_TYPE_SIZE - 1), 1))
{
/* u fits in a single Wtype. */
if (__builtin_expect (vv.s.high == vv.s.low >> (WORD_SIZE - 1), 1))
if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
{
/* v fits in a single Wtype as well. */
/* A single multiplication. No overflow risk. */
@ -304,7 +302,7 @@ __mulvDI3 (DWtype u, DWtype v)
if (uu.s.low < 0)
w1.ll -= vv.ll;
w1.ll += (UWtype) w0.s.high;
if (__builtin_expect (w1.s.high == w1.s.low >> (WORD_SIZE - 1), 1))
if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1))
{
w0.s.high = w1.s.low;
return w0.ll;
@ -313,7 +311,7 @@ __mulvDI3 (DWtype u, DWtype v)
}
else
{
if (__builtin_expect (vv.s.high == vv.s.low >> (WORD_SIZE - 1), 1))
if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
{
/* v fits into a single Wtype. */
/* Two multiplications. */
@ -327,7 +325,7 @@ __mulvDI3 (DWtype u, DWtype v)
if (vv.s.low < 0)
w1.ll -= uu.ll;
w1.ll += (UWtype) w0.s.high;
if (__builtin_expect (w1.s.high == w1.s.low >> (WORD_SIZE - 1), 1))
if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1))
{
w0.s.high = w1.s.low;
return w0.ll;
@ -1157,10 +1155,7 @@ __ucmpdi2 (DWtype a, DWtype b)
}
#endif
#if defined(L_fixunstfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
#if defined(L_fixunstfdi) && defined(HAVE_TFMODE)
DWtype
__fixunstfDI (TFtype a)
{
@ -1168,11 +1163,11 @@ __fixunstfDI (TFtype a)
return 0;
/* Compute high word of result, as a flonum. */
const TFtype b = (a / HIGH_WORD_COEFF);
const TFtype b = (a / Wtype_MAXp1_F);
/* Convert that to fixed (but not to DWtype!),
and shift it into the high word. */
UDWtype v = (UWtype) b;
v <<= WORD_SIZE;
v <<= W_TYPE_SIZE;
/* Remove high part from the TFtype, leaving the low part as flonum. */
a -= (TFtype)v;
/* Convert that to fixed (but not to DWtype!) and add it in.
@ -1186,7 +1181,7 @@ __fixunstfDI (TFtype a)
}
#endif
#if defined(L_fixtfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
#if defined(L_fixtfdi) && defined(HAVE_TFMODE)
DWtype
__fixtfdi (TFtype a)
{
@ -1196,10 +1191,7 @@ __fixtfdi (TFtype a)
}
#endif
#if defined(L_fixunsxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 80)
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
#if defined(L_fixunsxfdi) && defined(HAVE_XFMODE)
DWtype
__fixunsxfDI (XFtype a)
{
@ -1207,11 +1199,11 @@ __fixunsxfDI (XFtype a)
return 0;
/* Compute high word of result, as a flonum. */
const XFtype b = (a / HIGH_WORD_COEFF);
const XFtype b = (a / Wtype_MAXp1_F);
/* Convert that to fixed (but not to DWtype!),
and shift it into the high word. */
UDWtype v = (UWtype) b;
v <<= WORD_SIZE;
v <<= W_TYPE_SIZE;
/* Remove high part from the XFtype, leaving the low part as flonum. */
a -= (XFtype)v;
/* Convert that to fixed (but not to DWtype!) and add it in.
@ -1225,7 +1217,7 @@ __fixunsxfDI (XFtype a)
}
#endif
#if defined(L_fixxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 80)
#if defined(L_fixxfdi) && defined(HAVE_XFMODE)
DWtype
__fixxfdi (XFtype a)
{
@ -1235,29 +1227,26 @@ __fixxfdi (XFtype a)
}
#endif
#ifdef L_fixunsdfdi
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
#if defined(L_fixunsdfdi) && defined(HAVE_DFMODE)
DWtype
__fixunsdfDI (DFtype a)
{
/* Get high part of result. The division here will just moves the radix
point and will not cause any rounding. Then the conversion to integral
type chops result as desired. */
const UWtype hi = a / HIGH_WORD_COEFF;
const UWtype hi = a / Wtype_MAXp1_F;
/* Get low part of result. Convert `hi' to floating type and scale it back,
then subtract this from the number being converted. This leaves the low
part. Convert that to integral type. */
const UWtype lo = (a - ((DFtype) hi) * HIGH_WORD_COEFF);
const UWtype lo = a - (DFtype) hi * Wtype_MAXp1_F;
/* Assemble result from the two parts. */
return ((UDWtype) hi << WORD_SIZE) | lo;
return ((UDWtype) hi << W_TYPE_SIZE) | lo;
}
#endif
#ifdef L_fixdfdi
#if defined(L_fixdfdi) && defined(HAVE_DFMODE)
DWtype
__fixdfdi (DFtype a)
{
@ -1268,29 +1257,66 @@ __fixdfdi (DFtype a)
#endif
#ifdef L_fixunssfdi
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
DWtype
__fixunssfDI (SFtype original_a)
__fixunssfDI (SFtype a)
{
#if defined(HAVE_DFMODE)
/* Convert the SFtype to a DFtype, because that is surely not going
to lose any bits. Some day someone else can write a faster version
that avoids converting to DFtype, and verify it really works right. */
const DFtype a = original_a;
const DFtype dfa = a;
/* Get high part of result. The division here will just moves the radix
point and will not cause any rounding. Then the conversion to integral
type chops result as desired. */
const UWtype hi = a / HIGH_WORD_COEFF;
const UWtype hi = dfa / Wtype_MAXp1_F;
/* Get low part of result. Convert `hi' to floating type and scale it back,
then subtract this from the number being converted. This leaves the low
part. Convert that to integral type. */
const UWtype lo = (a - ((DFtype) hi) * HIGH_WORD_COEFF);
const UWtype lo = dfa - (DFtype) hi * Wtype_MAXp1_F;
/* Assemble result from the two parts. */
return ((UDWtype) hi << WORD_SIZE) | lo;
return ((UDWtype) hi << W_TYPE_SIZE) | lo;
#elif FLT_MANT_DIG < W_TYPE_SIZE
if (a < 1)
return 0;
if (a < Wtype_MAXp1_F)
return (UWtype)a;
if (a < Wtype_MAXp1_F * Wtype_MAXp1_F)
{
/* Since we know that there are fewer significant bits in the SFmode
quantity than in a word, we know that we can convert out all the
signficant bits in one step, and thus avoid losing bits. */
/* ??? This following loop essentially performs frexpf. If we could
use the real libm function, or poke at the actual bits of the fp
format, it would be significantly faster. */
UWtype shift = 0, counter;
SFtype msb;
a /= Wtype_MAXp1_F;
for (counter = W_TYPE_SIZE / 2; counter != 0; counter >>= 1)
{
SFtype counterf = (UWtype)1 << counter;
if (a >= counterf)
{
shift |= counter;
a /= counterf;
}
}
/* Rescale into the range of one word, extract the bits of that
one word, and shift the result into position. */
a *= Wtype_MAXp1_F;
counter = a;
return (DWtype)counter << shift;
}
return -1;
#else
# error
#endif
}
#endif
@ -1304,79 +1330,72 @@ __fixsfdi (SFtype a)
}
#endif
#if defined(L_floatdixf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 80)
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
#if defined(L_floatdixf) && defined(HAVE_XFMODE)
XFtype
__floatdixf (DWtype u)
{
XFtype d = (Wtype) (u >> WORD_SIZE);
d *= HIGH_HALFWORD_COEFF;
d *= HIGH_HALFWORD_COEFF;
d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
XFtype d = (Wtype) (u >> W_TYPE_SIZE);
d *= Wtype_MAXp1_F;
d += (UWtype)u;
return d;
}
#endif
#if defined(L_floatditf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
#if defined(L_floatditf) && defined(HAVE_TFMODE)
TFtype
__floatditf (DWtype u)
{
TFtype d = (Wtype) (u >> WORD_SIZE);
d *= HIGH_HALFWORD_COEFF;
d *= HIGH_HALFWORD_COEFF;
d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
TFtype d = (Wtype) (u >> W_TYPE_SIZE);
d *= Wtype_MAXp1_F;
d += (UWtype)u;
return d;
}
#endif
#ifdef L_floatdidf
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
#if defined(L_floatdidf) && defined(HAVE_DFMODE)
DFtype
__floatdidf (DWtype u)
{
DFtype d = (Wtype) (u >> WORD_SIZE);
d *= HIGH_HALFWORD_COEFF;
d *= HIGH_HALFWORD_COEFF;
d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
DFtype d = (Wtype) (u >> W_TYPE_SIZE);
d *= Wtype_MAXp1_F;
d += (UWtype)u;
return d;
}
#endif
#ifdef L_floatdisf
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
#define DI_SIZE (sizeof (DWtype) * BITS_PER_UNIT)
#define DF_SIZE DBL_MANT_DIG
#define DI_SIZE (W_TYPE_SIZE * 2)
#define SF_SIZE FLT_MANT_DIG
SFtype
__floatdisf (DWtype u)
{
#if SF_SIZE >= W_TYPE_SIZE
/* When the word size is small, we never get any rounding error. */
SFtype f = (Wtype) (u >> W_TYPE_SIZE);
f *= Wtype_MAXp1_F;
f += (UWtype)u;
return f;
#elif defined(HAVE_DFMODE)
#if LIBGCC2_DOUBLE_TYPE_SIZE == 64
#define DF_SIZE DBL_MANT_DIG
#elif LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
#define DF_SIZE LDBL_MANT_DIG
#else
# error
#endif
#define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
/* Protect against double-rounding error.
Represent any low-order bits, that might be truncated in DFmode,
by a bit that won't be lost. The bit can go in anywhere below the
rounding position of the SFmode. A fixed mask and bit position
handles all usual configurations. It doesn't handle the case
of 128-bit DImode, however. */
Represent any low-order bits, that might be truncated by a bit that
won't be lost. The bit can go in anywhere below the rounding position
of the SFmode. A fixed mask and bit position handles all usual
configurations. It doesn't handle the case of 128-bit DImode, however. */
if (DF_SIZE < DI_SIZE
&& DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
{
#define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
if (! (- ((DWtype) 1 << DF_SIZE) < u
&& u < ((DWtype) 1 << DF_SIZE)))
{
@ -1387,19 +1406,52 @@ __floatdisf (DWtype u)
}
}
}
/* Do the calculation in DFmode
so that we don't lose any of the precision of the high word
while multiplying it. */
DFtype f = (Wtype) (u >> WORD_SIZE);
f *= HIGH_HALFWORD_COEFF;
f *= HIGH_HALFWORD_COEFF;
f += (UWtype) (u & (HIGH_WORD_COEFF - 1));
/* Do the calculation in DFmode so that we don't lose any of the
precision of the high word while multiplying it. */
DFtype f = (Wtype) (u >> W_TYPE_SIZE);
f *= Wtype_MAXp1_F;
f += (UWtype)u;
return (SFtype) f;
#else
/* Finally, the word size is larger than the number of bits in SFmode,
and we've got no DFmode. The only way to avoid double rounding is
to special case the extraction. */
/* If there are no high bits set, fall back to one conversion. */
if ((Wtype)u == u)
return (SFtype)(Wtype)u;
/* Otherwise, find the power of two. */
Wtype hi = u >> W_TYPE_SIZE;
if (hi < 0)
hi = -hi;
UWtype count, shift;
count_leading_zeros (count, hi);
/* No leading bits means u == minimum. */
if (count == 0)
return -(Wtype_MAXp1_F * Wtype_MAXp1_F / 2);
shift = W_TYPE_SIZE - count;
/* Shift down the most significant bits. */
hi = u >> shift;
/* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
if (u & ((1 << shift) - 1))
hi |= 1;
/* Convert the one word of data, and rescale. */
SFtype f = hi;
f *= (UWtype)1 << shift;
return f;
#endif
}
#endif
#if defined(L_fixunsxfsi) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 80
#if defined(L_fixunsxfsi) && defined(HAVE_XFMODE)
/* Reenable the normal types, in case limits.h needs them. */
#undef char
#undef short
@ -1421,7 +1473,7 @@ __fixunsxfSI (XFtype a)
}
#endif
#ifdef L_fixunsdfsi
#if defined(L_fixunsdfsi) && defined(HAVE_DFMODE)
/* Reenable the normal types, in case limits.h needs them. */
#undef char
#undef short
@ -1468,9 +1520,10 @@ __fixunssfSI (SFtype a)
/* Integer power helper used from __builtin_powi for non-constant
exponents. */
#if defined(L_powisf2) || defined(L_powidf2) \
|| (defined(L_powixf2) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 80) \
|| (defined(L_powitf2) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
#if defined(L_powisf2) \
|| (defined(L_powidf2) && defined(HAVE_DFMODE)) \
|| (defined(L_powixf2) && defined(HAVE_XFMODE)) \
|| (defined(L_powitf2) && defined(HAVE_TFMODE))
# if defined(L_powisf2)
# define TYPE SFtype
# define NAME __powisf2
@ -1502,11 +1555,9 @@ NAME (TYPE x, Wtype m)
#endif
#if defined(L_mulsc3) || defined(L_divsc3) \
|| defined(L_muldc3) || defined(L_divdc3) \
|| (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 80 \
&& (defined(L_mulxc3) || defined(L_divxc3))) \
|| (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128 \
&& (defined(L_multc3) || defined(L_divtc3)))
|| ((defined(L_muldc3) || defined(L_divdc3)) && defined(HAVE_DFMODE)) \
|| ((defined(L_mulxc3) || defined(L_divxc3)) && defined(HAVE_XFMODE)) \
|| ((defined(L_multc3) || defined(L_divtc3)) && defined(HAVE_TFMODE))
#undef float
#undef double

42
gcc/libgcc2.h
View File

@ -51,6 +51,9 @@ extern short int __get_eh_table_version (struct exception_descriptor *);
#define LIBGCC2_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN
#endif
#ifndef LIBGCC2_DOUBLE_TYPE_SIZE
#define LIBGCC2_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE
#endif
#ifndef LIBGCC2_LONG_DOUBLE_TYPE_SIZE
#define LIBGCC2_LONG_DOUBLE_TYPE_SIZE LONG_DOUBLE_TYPE_SIZE
#endif
@ -91,15 +94,20 @@ typedef unsigned int UTItype __attribute__ ((mode (TI)));
#if BITS_PER_UNIT == 8
typedef float SFtype __attribute__ ((mode (SF)));
typedef float DFtype __attribute__ ((mode (DF)));
typedef _Complex float SCtype __attribute__ ((mode (SC)));
typedef _Complex float DCtype __attribute__ ((mode (DC)));
#if LIBGCC2_DOUBLE_TYPE_SIZE == 64 || LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
#define HAVE_DFMODE
typedef float DFtype __attribute__ ((mode (DF)));
typedef _Complex float DCtype __attribute__ ((mode (DC)));
#endif
#if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 80
#define HAVE_XFMODE
typedef float XFtype __attribute__ ((mode (XF)));
typedef _Complex float XCtype __attribute__ ((mode (XC)));
#endif
#if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128
#define HAVE_TFMODE
typedef float TFtype __attribute__ ((mode (TF)));
typedef _Complex float TCtype __attribute__ ((mode (TC)));
#endif
@ -200,6 +208,18 @@ typedef int word_type __attribute__ ((mode (__word__)));
#define Wtype_MAX ((Wtype)(((UWtype)1 << (W_TYPE_SIZE - 1)) - 1))
#define Wtype_MIN (- Wtype_MAX - 1)
#if W_TYPE_SIZE == 8
# define Wtype_MAXp1_F 0x1p8f
#elif W_TYPE_SIZE == 16
# define Wtype_MAXp1_F 0x1p16f
#elif W_TYPE_SIZE == 32
# define Wtype_MAXp1_F 0x1p32f
#elif W_TYPE_SIZE == 64
# define Wtype_MAXp1_F 0x1p64f
#else
# error "expand the table"
#endif
#define __muldi3 __NDW(mul,3)
#define __divdi3 __NDW(div,3)
#define __udivdi3 __NDW(udiv,3)
@ -301,23 +321,25 @@ extern SItype __negvsi2 (SItype);
#endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
#if BITS_PER_UNIT == 8
extern DWtype __fixdfdi (DFtype);
extern DWtype __fixsfdi (SFtype);
extern DFtype __floatdidf (DWtype);
extern SFtype __floatdisf (DWtype);
extern UWtype __fixunsdfSI (DFtype);
extern UWtype __fixunssfSI (SFtype);
extern DWtype __fixunsdfDI (DFtype);
extern DWtype __fixunssfDI (SFtype);
extern SFtype __powisf2 (SFtype, Wtype);
extern DFtype __powidf2 (DFtype, Wtype);
extern SCtype __divsc3 (SFtype, SFtype, SFtype, SFtype);
extern SCtype __mulsc3 (SFtype, SFtype, SFtype, SFtype);
#ifdef HAVE_DFMODE
extern DWtype __fixdfdi (DFtype);
extern DFtype __floatdidf (DWtype);
extern UWtype __fixunsdfSI (DFtype);
extern DWtype __fixunsdfDI (DFtype);
extern DFtype __powidf2 (DFtype, Wtype);
extern DCtype __divdc3 (DFtype, DFtype, DFtype, DFtype);
extern DCtype __muldc3 (DFtype, DFtype, DFtype, DFtype);
#endif
#if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 80
#ifdef HAVE_XFMODE
extern DWtype __fixxfdi (XFtype);
extern DWtype __fixunsxfDI (XFtype);
extern XFtype __floatdixf (DWtype);
@ -327,7 +349,7 @@ extern XCtype __divxc3 (XFtype, XFtype, XFtype, XFtype);
extern XCtype __mulxc3 (XFtype, XFtype, XFtype, XFtype);
#endif
#if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128
#ifdef HAVE_TFMODE
extern DWtype __fixunstfDI (TFtype);
extern DWtype __fixtfdi (TFtype);
extern TFtype __floatditf (DWtype);