/* More subroutines needed by GCC output code on some machines. */
/* Compile this one with gcc. */
/* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ 2000, 2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
This file is part of GCC.
\f
/* Unless shift functions are defined with full ANSI prototypes,
- parameter b will be promoted to int if word_type is smaller than an int. */
+ parameter b will be promoted to int if shift_count_type is smaller than an int. */
#ifdef L_lshrdi3
DWtype
-__lshrdi3 (DWtype u, word_type b)
+__lshrdi3 (DWtype u, shift_count_type b)
{
if (b == 0)
return u;
const DWunion uu = {.ll = u};
- const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
+ const shift_count_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
DWunion w;
if (bm <= 0)
#ifdef L_ashldi3
DWtype
-__ashldi3 (DWtype u, word_type b)
+__ashldi3 (DWtype u, shift_count_type b)
{
if (b == 0)
return u;
const DWunion uu = {.ll = u};
- const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
+ const shift_count_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
DWunion w;
if (bm <= 0)
#ifdef L_ashrdi3
DWtype
-__ashrdi3 (DWtype u, word_type b)
+__ashrdi3 (DWtype u, shift_count_type b)
{
if (b == 0)
return u;
const DWunion uu = {.ll = u};
- const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
+ const shift_count_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
DWunion w;
if (bm <= 0)
#endif
\f
#ifdef L_bswapsi2
-UWtype
-__bswapSI2 (UWtype u)
+SItype
+__bswapsi2 (SItype u)
{
return ((((u) & 0xff000000) >> 24)
| (((u) & 0x00ff0000) >> 8)
}
#endif
#ifdef L_bswapdi2
-UDWtype
-__bswapDI2 (UDWtype u)
+DItype
+__bswapdi2 (DItype u)
{
return ((((u) & 0xff00000000000000ull) >> 56)
| (((u) & 0x00ff000000000000ull) >> 40)
DWtype
__divdi3 (DWtype u, DWtype v)
{
- word_type c = 0;
+ Wtype c = 0;
DWunion uu = {.ll = u};
DWunion vv = {.ll = v};
DWtype w;
DWtype
__moddi3 (DWtype u, DWtype v)
{
- word_type c = 0;
+ Wtype c = 0;
DWunion uu = {.ll = u};
DWunion vv = {.ll = v};
DWtype w;
#endif
\f
#ifdef L_cmpdi2
-word_type
+cmp_return_type
__cmpdi2 (DWtype a, DWtype b)
{
const DWunion au = {.ll = a};
#endif
#ifdef L_ucmpdi2
-word_type
+cmp_return_type
__ucmpdi2 (DWtype a, DWtype b)
{
const DWunion au = {.ll = a};
#define F_MODE_OK(SIZE) \
(SIZE < DI_SIZE \
&& SIZE > (DI_SIZE - SIZE + FSSIZE) \
- /* Don't use IBM Extended Double TFmode for TI->SF calculations. \
- The conversion from long double to float suffers from double \
- rounding, because we convert via double. In any case, the \
- fallback code is faster. */ \
- && !IS_IBM_EXTENDED (SIZE))
+ && !AVOID_FP_TYPE_CONVERSION(SIZE))
#if defined(L_floatdisf)
#define FUNC __floatdisf
#define FSTYPE SFtype
hi = u >> shift;
/* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
- if (u & (((DWtype)1 << shift) - 1))
+ if ((UWtype)u << (W_TYPE_SIZE - shift))
hi |= 1;
/* Convert the one word of data, and rescale. */
- FSTYPE f = hi;
- f *= (UDWtype)1 << shift;
- return f;
+ FSTYPE f = hi, e;
+ if (shift == W_TYPE_SIZE)
+ e = Wtype_MAXp1_F;
+ /* The following two cases could be merged if we knew that the target
+ supported a native unsigned->float conversion. More often, we only
+ have a signed conversion, and have to add extra fixup code. */
+ else if (shift == W_TYPE_SIZE - 1)
+ e = Wtype_MAXp1_F / 2;
+ else
+ e = (Wtype)1 << shift;
+ return f * e;
#endif
}
#endif
#define F_MODE_OK(SIZE) \
(SIZE < DI_SIZE \
&& SIZE > (DI_SIZE - SIZE + FSSIZE) \
- /* Don't use IBM Extended Double TFmode for TI->SF calculations. \
- The conversion from long double to float suffers from double \
- rounding, because we convert via double. In any case, the \
- fallback code is faster. */ \
- && !IS_IBM_EXTENDED (SIZE))
+ && !AVOID_FP_TYPE_CONVERSION(SIZE))
#if defined(L_floatundisf)
#define FUNC __floatundisf
#define FSTYPE SFtype
hi = u >> shift;
/* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
- if (u & (((UDWtype)1 << shift) - 1))
+ if ((UWtype)u << (W_TYPE_SIZE - shift))
hi |= 1;
/* Convert the one word of data, and rescale. */
- FSTYPE f = hi;
- f *= (UDWtype)1 << shift;
- return f;
+ FSTYPE f = hi, e;
+ if (shift == W_TYPE_SIZE)
+ e = Wtype_MAXp1_F;
+ /* The following two cases could be merged if we knew that the target
+ supported a native unsigned->float conversion. More often, we only
+ have a signed conversion, and have to add extra fixup code. */
+ else if (shift == W_TYPE_SIZE - 1)
+ e = Wtype_MAXp1_F / 2;
+ else
+ e = (Wtype)1 << shift;
+ return f * e;
#endif
}
#endif
# define MTYPE TFtype
# define CTYPE TCtype
# define MODE tc
-# define CEXT l
+# if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128
+# define CEXT l
+# else
+# define CEXT LIBGCC2_TF_CEXT
+# endif
# define NOTRUNC 1
#else
# error
{
MTYPE denom, ratio, x, y;
- /* ??? We can get better behavior from logarithmic scaling instead of
+ /* ??? We can get better behavior from logarithmic scaling instead of
the division. But that would mean starting to link libgcc against
libm. We could implement something akin to ldexp/frexp as gcc builtins
fairly easily... */
are nonzero/zero, infinite/finite, and finite/infinite. */
if (isnan (x) && isnan (y))
{
- if (denom == 0.0 && (!isnan (a) || !isnan (b)))
+ if (c == 0.0 && d == 0.0 && (!isnan (a) || !isnan (b)))
{
x = COPYSIGN (INFINITY, c) * a;
y = COPYSIGN (INFINITY, c) * b;