because the sizes for those types can be configured to be anything.
Instead we use the following special type names. */
+typedef int QItype __attribute__ ((mode (QI)));
typedef unsigned int UQItype __attribute__ ((mode (QI)));
+typedef int HItype __attribute__ ((mode (HI)));
+typedef unsigned int UHItype __attribute__ ((mode (HI)));
+#if UNITS_PER_WORD > 1
+/* These typedefs are usually forbidden on dsp's with UNITS_PER_WORD 1 */
typedef int SItype __attribute__ ((mode (SI)));
typedef unsigned int USItype __attribute__ ((mode (SI)));
+#if UNITS_PER_WORD > 2
+/* These typedefs are usually forbidden on archs with UNITS_PER_WORD 2 */
typedef int DItype __attribute__ ((mode (DI)));
typedef unsigned int UDItype __attribute__ ((mode (DI)));
+#endif
+#endif
+
+#if BITS_PER_UNIT == 8
typedef float SFtype __attribute__ ((mode (SF)));
typedef float DFtype __attribute__ ((mode (DF)));
typedef float TFtype __attribute__ ((mode (TF)));
#endif
+#else /* BITS_PER_UNIT != 8 */
+
+/* On dsp's there are usually qf/hf/tqf modes used instead of the above.
+ For now we don't support them in libgcc2.c. */
+
+#undef L_fixdfdi
+#undef L_fixsfdi
+#undef L_fixtfdi
+#undef L_fixunsdfdi
+#undef L_fixunsdfsi
+#undef L_fixunssfdi
+#undef L_fixunssfsi
+#undef L_fixunstfdi
+#undef L_fixunsxfdi
+#undef L_fixunsxfsi
+#undef L_fixxfdi
+#undef L_floatdidf
+#undef L_floatdisf
+#undef L_floatditf
+#undef L_floatdixf
+
+#endif /* BITS_PER_UNIT != 8 */
+
typedef int word_type __attribute__ ((mode (__word__)));
/* Make sure that we don't accidentally use any normal C language built-in
#define float bogus_type
#define double bogus_type
-#if BITS_PER_UNIT == 8
-#define SI_TYPE_SIZE 32
-#else
-#define SI_TYPE_SIZE (sizeof (SItype) * BITS_PER_UNIT)
-#endif
-#define W_TYPE_SIZE SI_TYPE_SIZE
+#if UNITS_PER_WORD > 2
+#define W_TYPE_SIZE (4 * BITS_PER_UNIT)
+#define Wtype SItype
#define UWtype USItype
+#define HWtype SItype
#define UHWtype USItype
+#define DWtype DItype
#define UDWtype UDItype
+#define __NW(a,b) __ ## a ## si ## b
+#define __NDW(a,b) __ ## a ## di ## b
+#elif UNITS_PER_WORD > 1
+#define W_TYPE_SIZE (2 * BITS_PER_UNIT)
+#define Wtype HItype
+#define UWtype UHItype
+#define HWtype HItype
+#define UHWtype UHItype
+#define DWtype SItype
+#define UDWtype USItype
+#define __NW(a,b) __ ## a ## hi ## b
+#define __NDW(a,b) __ ## a ## si ## b
+#else
+#define W_TYPE_SIZE BITS_PER_UNIT
+#define Wtype QItype
+#define UWtype UQItype
+#define HWtype QItype
+#define UHWtype UQItype
+#define DWtype HItype
+#define UDWtype UHItype
+#define __NW(a,b) __ ## a ## qi ## b
+#define __NDW(a,b) __ ## a ## hi ## b
+#endif
-/* DIstructs are pairs of SItype values in the order determined by
+#define __muldi3 __NDW(mul,3)
+#define __divdi3 __NDW(div,3)
+#define __udivdi3 __NDW(udiv,3)
+#define __moddi3 __NDW(mod,3)
+#define __umoddi3 __NDW(umod,3)
+#define __negdi2 __NDW(neg,2)
+#define __lshrdi3 __NDW(lshr,3)
+#define __ashldi3 __NDW(ashl,3)
+#define __ashrdi3 __NDW(ashr,3)
+#define __ffsdi2 __NDW(ffs,2)
+#define __cmpdi2 __NDW(cmp,2)
+#define __ucmpdi2 __NDW(ucmp,2)
+#define __udivmoddi4 __NDW(udivmod,4)
+#define __fixunstfdi __NDW(fixunstf,)
+#define __fixtfdi __NDW(fixtf,)
+#define __fixunsxfdi __NDW(fixunsxf,)
+#define __fixxfdi __NDW(fixxf,)
+#define __fixunsdfdi __NDW(fixunsdf,)
+#define __fixdfdi __NDW(fixdf,)
+#define __fixunssfdi __NDW(fixunssf,)
+#define __fixsfdi __NDW(fixsf,)
+#define __floatdixf __NDW(float,xf)
+#define __floatditf __NDW(float,tf)
+#define __floatdidf __NDW(float,df)
+#define __floatdisf __NDW(float,sf)
+#define __fixunsxfsi __NW(fixunsxf,)
+#define __fixunstfsi __NW(fixunstf,)
+#define __fixunsdfsi __NW(fixunsdf,)
+#define __fixunssfsi __NW(fixunssf,)
+
+/* DWstructs are pairs of Wtype values in the order determined by
LIBGCC2_WORDS_BIG_ENDIAN. */
#if LIBGCC2_WORDS_BIG_ENDIAN
- struct DIstruct {SItype high, low;};
+ struct DWstruct {Wtype high, low;};
#else
- struct DIstruct {SItype low, high;};
+ struct DWstruct {Wtype low, high;};
#endif
/* We need this union to unpack/pack DImode values, since we don't have
typedef union
{
- struct DIstruct s;
- DItype ll;
-} DIunion;
+ struct DWstruct s;
+ DWtype ll;
+} DWunion;
#if (defined (L_udivmoddi4) || defined (L_muldi3) || defined (L_udiv_w_sdiv)\
|| defined (L_divdi3) || defined (L_udivdi3) \
#endif /* udiv or mul */
-extern DItype __fixunssfdi (SFtype a);
-extern DItype __fixunsdfdi (DFtype a);
-#if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
-extern DItype __fixunsxfdi (XFtype a);
-#endif
-#if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128
-extern DItype __fixunstfdi (TFtype a);
-#endif
\f
#if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
#if defined (L_divdi3) || defined (L_moddi3)
static inline
#endif
-DItype
-__negdi2 (DItype u)
+DWtype
+__negdi2 (DWtype u)
{
- DIunion w;
- DIunion uu;
+ DWunion w;
+ DWunion uu;
uu.ll = u;
w.s.low = -uu.s.low;
- w.s.high = -uu.s.high - ((USItype) w.s.low > 0);
+ w.s.high = -uu.s.high - ((UWtype) w.s.low > 0);
return w.ll;
}
/* Unless shift functions are defined whith full ANSI prototypes,
parameter b will be promoted to int if word_type is smaller than an int. */
#ifdef L_lshrdi3
-DItype
-__lshrdi3 (DItype u, word_type b)
+DWtype
+__lshrdi3 (DWtype u, word_type b)
{
- DIunion w;
+ DWunion w;
word_type bm;
- DIunion uu;
+ DWunion uu;
if (b == 0)
return u;
uu.ll = u;
- bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
+ bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
if (bm <= 0)
{
w.s.high = 0;
- w.s.low = (USItype)uu.s.high >> -bm;
+ w.s.low = (UWtype)uu.s.high >> -bm;
}
else
{
- USItype carries = (USItype)uu.s.high << bm;
- w.s.high = (USItype)uu.s.high >> b;
- w.s.low = ((USItype)uu.s.low >> b) | carries;
+ UWtype carries = (UWtype)uu.s.high << bm;
+ w.s.high = (UWtype)uu.s.high >> b;
+ w.s.low = ((UWtype)uu.s.low >> b) | carries;
}
return w.ll;
#endif
#ifdef L_ashldi3
-DItype
-__ashldi3 (DItype u, word_type b)
+DWtype
+__ashldi3 (DWtype u, word_type b)
{
- DIunion w;
+ DWunion w;
word_type bm;
- DIunion uu;
+ DWunion uu;
if (b == 0)
return u;
uu.ll = u;
- bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
+ bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
if (bm <= 0)
{
w.s.low = 0;
- w.s.high = (USItype)uu.s.low << -bm;
+ w.s.high = (UWtype)uu.s.low << -bm;
}
else
{
- USItype carries = (USItype)uu.s.low >> bm;
- w.s.low = (USItype)uu.s.low << b;
- w.s.high = ((USItype)uu.s.high << b) | carries;
+ UWtype carries = (UWtype)uu.s.low >> bm;
+ w.s.low = (UWtype)uu.s.low << b;
+ w.s.high = ((UWtype)uu.s.high << b) | carries;
}
return w.ll;
#endif
#ifdef L_ashrdi3
-DItype
-__ashrdi3 (DItype u, word_type b)
+DWtype
+__ashrdi3 (DWtype u, word_type b)
{
- DIunion w;
+ DWunion w;
word_type bm;
- DIunion uu;
+ DWunion uu;
if (b == 0)
return u;
uu.ll = u;
- bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
+ bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
if (bm <= 0)
{
/* w.s.high = 1..1 or 0..0 */
- w.s.high = uu.s.high >> (sizeof (SItype) * BITS_PER_UNIT - 1);
+ w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1);
w.s.low = uu.s.high >> -bm;
}
else
{
- USItype carries = (USItype)uu.s.high << bm;
+ UWtype carries = (UWtype)uu.s.high << bm;
w.s.high = uu.s.high >> b;
- w.s.low = ((USItype)uu.s.low >> b) | carries;
+ w.s.low = ((UWtype)uu.s.low >> b) | carries;
}
return w.ll;
#endif
\f
#ifdef L_ffsdi2
-DItype
-__ffsdi2 (DItype u)
+DWtype
+__ffsdi2 (DWtype u)
{
- DIunion uu, w;
+ DWunion uu, w;
uu.ll = u;
w.s.high = 0;
w.s.low = ffs (uu.s.low);
w.s.low = ffs (uu.s.high);
if (w.s.low != 0)
{
- w.s.low += BITS_PER_UNIT * sizeof (SItype);
+ w.s.low += BITS_PER_UNIT * sizeof (Wtype);
return w.ll;
}
return w.ll;
#endif
\f
#ifdef L_muldi3
-DItype
-__muldi3 (DItype u, DItype v)
+DWtype
+__muldi3 (DWtype u, DWtype v)
{
- DIunion w;
- DIunion uu, vv;
+ DWunion w;
+ DWunion uu, vv;
uu.ll = u,
vv.ll = v;
w.ll = __umulsidi3 (uu.s.low, vv.s.low);
- w.s.high += ((USItype) uu.s.low * (USItype) vv.s.high
- + (USItype) uu.s.high * (USItype) vv.s.low);
+ w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
+ + (UWtype) uu.s.high * (UWtype) vv.s.low);
return w.ll;
}
\f
#ifdef L_udiv_w_sdiv
#if defined (sdiv_qrnnd)
-USItype
-__udiv_w_sdiv (USItype *rp, USItype a1, USItype a0, USItype d)
+UWtype
+__udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
{
- USItype q, r;
- USItype c0, c1, b1;
+ UWtype q, r;
+ UWtype c0, c1, b1;
- if ((SItype) d >= 0)
+ if ((Wtype) d >= 0)
{
- if (a1 < d - a1 - (a0 >> (SI_TYPE_SIZE - 1)))
+ if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
{
/* dividend, divisor, and quotient are nonnegative */
sdiv_qrnnd (q, r, a1, a0, d);
else
{
/* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
- sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (SI_TYPE_SIZE - 1));
+ sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
/* Divide (c1*2^32 + c0) by d */
sdiv_qrnnd (q, r, c1, c0, d);
/* Add 2^31 to quotient */
- q += (USItype) 1 << (SI_TYPE_SIZE - 1);
+ q += (UWtype) 1 << (W_TYPE_SIZE - 1);
}
}
else
{
b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
c1 = a1 >> 1; /* A/2 */
- c0 = (a1 << (SI_TYPE_SIZE - 1)) + (a0 >> 1);
+ c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
{
}
#else
/* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
-USItype
-__udiv_w_sdiv (USItype *rp __attribute__ ((__unused__)),
- USItype a1 __attribute__ ((__unused__)),
- USItype a0 __attribute__ ((__unused__)),
- USItype d __attribute__ ((__unused__)))
+UWtype
+__udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
+ UWtype a1 __attribute__ ((__unused__)),
+ UWtype a0 __attribute__ ((__unused__)),
+ UWtype d __attribute__ ((__unused__)))
{
return 0;
}
defined (L_umoddi3) || defined (L_moddi3))
static inline
#endif
-UDItype
-__udivmoddi4 (UDItype n, UDItype d, UDItype *rp)
+UDWtype
+__udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
{
- DIunion ww;
- DIunion nn, dd;
- DIunion rr;
- USItype d0, d1, n0, n1, n2;
- USItype q0, q1;
- USItype b, bm;
+ DWunion ww;
+ DWunion nn, dd;
+ DWunion rr;
+ UWtype d0, d1, n0, n1, n2;
+ UWtype q0, q1;
+ UWtype b, bm;
nn.ll = n;
dd.ll = d;
denominator set. */
d0 = d0 << bm;
- n1 = (n1 << bm) | (n0 >> (SI_TYPE_SIZE - bm));
+ n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
n0 = n0 << bm;
}
leading quotient digit q1 = 1).
This special case is necessary, not an optimization.
- (Shifts counts of SI_TYPE_SIZE are undefined.) */
+ (Shifts counts of W_TYPE_SIZE are undefined.) */
n1 -= d0;
q1 = 1;
{
/* Normalize. */
- b = SI_TYPE_SIZE - bm;
+ b = W_TYPE_SIZE - bm;
d0 = d0 << bm;
n2 = n1 >> b;
}
else
{
- USItype m1, m0;
+ UWtype m1, m0;
/* Normalize. */
- b = SI_TYPE_SIZE - bm;
+ b = W_TYPE_SIZE - bm;
d1 = (d1 << bm) | (d0 >> b);
d0 = d0 << bm;
#endif
#ifdef L_divdi3
-DItype
-__divdi3 (DItype u, DItype v)
+DWtype
+__divdi3 (DWtype u, DWtype v)
{
word_type c = 0;
- DIunion uu, vv;
- DItype w;
+ DWunion uu, vv;
+ DWtype w;
uu.ll = u;
vv.ll = v;
c = ~c,
vv.ll = __negdi2 (vv.ll);
- w = __udivmoddi4 (uu.ll, vv.ll, (UDItype *) 0);
+ w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
if (c)
w = __negdi2 (w);
#endif
#ifdef L_moddi3
-DItype
-__moddi3 (DItype u, DItype v)
+DWtype
+__moddi3 (DWtype u, DWtype v)
{
word_type c = 0;
- DIunion uu, vv;
- DItype w;
+ DWunion uu, vv;
+ DWtype w;
uu.ll = u;
vv.ll = v;
#endif
#ifdef L_umoddi3
-UDItype
-__umoddi3 (UDItype u, UDItype v)
+UDWtype
+__umoddi3 (UDWtype u, UDWtype v)
{
- UDItype w;
+ UDWtype w;
(void) __udivmoddi4 (u, v, &w);
#endif
#ifdef L_udivdi3
-UDItype
-__udivdi3 (UDItype n, UDItype d)
+UDWtype
+__udivdi3 (UDWtype n, UDWtype d)
{
- return __udivmoddi4 (n, d, (UDItype *) 0);
+ return __udivmoddi4 (n, d, (UDWtype *) 0);
}
#endif
\f
#ifdef L_cmpdi2
word_type
-__cmpdi2 (DItype a, DItype b)
+__cmpdi2 (DWtype a, DWtype b)
{
- DIunion au, bu;
+ DWunion au, bu;
au.ll = a, bu.ll = b;
return 0;
else if (au.s.high > bu.s.high)
return 2;
- if ((USItype) au.s.low < (USItype) bu.s.low)
+ if ((UWtype) au.s.low < (UWtype) bu.s.low)
return 0;
- else if ((USItype) au.s.low > (USItype) bu.s.low)
+ else if ((UWtype) au.s.low > (UWtype) bu.s.low)
return 2;
return 1;
}
#ifdef L_ucmpdi2
word_type
-__ucmpdi2 (DItype a, DItype b)
+__ucmpdi2 (DWtype a, DWtype b)
{
- DIunion au, bu;
+ DWunion au, bu;
au.ll = a, bu.ll = b;
- if ((USItype) au.s.high < (USItype) bu.s.high)
+ if ((UWtype) au.s.high < (UWtype) bu.s.high)
return 0;
- else if ((USItype) au.s.high > (USItype) bu.s.high)
+ else if ((UWtype) au.s.high > (UWtype) bu.s.high)
return 2;
- if ((USItype) au.s.low < (USItype) bu.s.low)
+ if ((UWtype) au.s.low < (UWtype) bu.s.low)
return 0;
- else if ((USItype) au.s.low > (USItype) bu.s.low)
+ else if ((UWtype) au.s.low > (UWtype) bu.s.low)
return 2;
return 1;
}
#endif
\f
#if defined(L_fixunstfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
-#define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
-#define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
+#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
+#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
-DItype
+DWtype
__fixunstfdi (TFtype a)
{
TFtype b;
- UDItype v;
+ UDWtype v;
if (a < 0)
return 0;
/* Compute high word of result, as a flonum. */
b = (a / HIGH_WORD_COEFF);
- /* Convert that to fixed (but not to DItype!),
+ /* Convert that to fixed (but not to DWtype!),
and shift it into the high word. */
- v = (USItype) b;
+ v = (UWtype) b;
v <<= WORD_SIZE;
/* Remove high part from the TFtype, leaving the low part as flonum. */
a -= (TFtype)v;
- /* Convert that to fixed (but not to DItype!) and add it in.
+ /* Convert that to fixed (but not to DWtype!) and add it in.
Sometimes A comes out negative. This is significant, since
A has more bits than a long int does. */
if (a < 0)
- v -= (USItype) (- a);
+ v -= (UWtype) (- a);
else
- v += (USItype) a;
+ v += (UWtype) a;
return v;
}
#endif
#if defined(L_fixtfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
-DItype
+extern DWtype __fixunstfdi (TFtype a);
+
+DWtype
__fixtfdi (TFtype a)
{
if (a < 0)
#endif
#if defined(L_fixunsxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
-#define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
-#define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
+#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
+#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
-DItype
+DWtype
__fixunsxfdi (XFtype a)
{
XFtype b;
- UDItype v;
+ UDWtype v;
if (a < 0)
return 0;
/* Compute high word of result, as a flonum. */
b = (a / HIGH_WORD_COEFF);
- /* Convert that to fixed (but not to DItype!),
+ /* Convert that to fixed (but not to DWtype!),
and shift it into the high word. */
- v = (USItype) b;
+ v = (UWtype) b;
v <<= WORD_SIZE;
/* Remove high part from the XFtype, leaving the low part as flonum. */
a -= (XFtype)v;
- /* Convert that to fixed (but not to DItype!) and add it in.
+ /* Convert that to fixed (but not to DWtype!) and add it in.
Sometimes A comes out negative. This is significant, since
A has more bits than a long int does. */
if (a < 0)
- v -= (USItype) (- a);
+ v -= (UWtype) (- a);
else
- v += (USItype) a;
+ v += (UWtype) a;
return v;
}
#endif
#if defined(L_fixxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
-DItype
+extern DWtype __fixunsxfdi (XFtype a);
+
+DWtype
__fixxfdi (XFtype a)
{
if (a < 0)
#endif
#ifdef L_fixunsdfdi
-#define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
-#define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
+#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
+#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
-DItype
+DWtype
__fixunsdfdi (DFtype a)
{
DFtype b;
- UDItype v;
+ UDWtype v;
if (a < 0)
return 0;
/* Compute high word of result, as a flonum. */
b = (a / HIGH_WORD_COEFF);
- /* Convert that to fixed (but not to DItype!),
+ /* Convert that to fixed (but not to DWtype!),
and shift it into the high word. */
- v = (USItype) b;
+ v = (UWtype) b;
v <<= WORD_SIZE;
/* Remove high part from the DFtype, leaving the low part as flonum. */
a -= (DFtype)v;
- /* Convert that to fixed (but not to DItype!) and add it in.
+ /* Convert that to fixed (but not to DWtype!) and add it in.
Sometimes A comes out negative. This is significant, since
A has more bits than a long int does. */
if (a < 0)
- v -= (USItype) (- a);
+ v -= (UWtype) (- a);
else
- v += (USItype) a;
+ v += (UWtype) a;
return v;
}
#endif
#ifdef L_fixdfdi
-DItype
+extern DWtype __fixunsdfdi (DFtype a);
+
+DWtype
__fixdfdi (DFtype a)
{
if (a < 0)
#endif
#ifdef L_fixunssfdi
-#define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
-#define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
+#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
+#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
-DItype
+DWtype
__fixunssfdi (SFtype original_a)
{
/* Convert the SFtype to a DFtype, because that is surely not going
that avoids converting to DFtype, and verify it really works right. */
DFtype a = original_a;
DFtype b;
- UDItype v;
+ UDWtype v;
if (a < 0)
return 0;
/* Compute high word of result, as a flonum. */
b = (a / HIGH_WORD_COEFF);
- /* Convert that to fixed (but not to DItype!),
+ /* Convert that to fixed (but not to DWtype!),
and shift it into the high word. */
- v = (USItype) b;
+ v = (UWtype) b;
v <<= WORD_SIZE;
/* Remove high part from the DFtype, leaving the low part as flonum. */
a -= (DFtype)v;
- /* Convert that to fixed (but not to DItype!) and add it in.
+ /* Convert that to fixed (but not to DWtype!) and add it in.
Sometimes A comes out negative. This is significant, since
A has more bits than a long int does. */
if (a < 0)
- v -= (USItype) (- a);
+ v -= (UWtype) (- a);
else
- v += (USItype) a;
+ v += (UWtype) a;
return v;
}
#endif
#ifdef L_fixsfdi
-DItype
+extern DWtype __fixunssfdi (SFtype a);
+
+DWtype
__fixsfdi (SFtype a)
{
if (a < 0)
#endif
#if defined(L_floatdixf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
-#define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
-#define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
-#define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
+#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)
XFtype
-__floatdixf (DItype u)
+__floatdixf (DWtype u)
{
XFtype d;
- d = (SItype) (u >> WORD_SIZE);
+ d = (Wtype) (u >> WORD_SIZE);
d *= HIGH_HALFWORD_COEFF;
d *= HIGH_HALFWORD_COEFF;
- d += (USItype) (u & (HIGH_WORD_COEFF - 1));
+ d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
return d;
}
#endif
#if defined(L_floatditf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
-#define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
-#define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
-#define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
+#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)
TFtype
-__floatditf (DItype u)
+__floatditf (DWtype u)
{
TFtype d;
- d = (SItype) (u >> WORD_SIZE);
+ d = (Wtype) (u >> WORD_SIZE);
d *= HIGH_HALFWORD_COEFF;
d *= HIGH_HALFWORD_COEFF;
- d += (USItype) (u & (HIGH_WORD_COEFF - 1));
+ d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
return d;
}
#endif
#ifdef L_floatdidf
-#define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
-#define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
-#define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
+#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)
DFtype
-__floatdidf (DItype u)
+__floatdidf (DWtype u)
{
DFtype d;
- d = (SItype) (u >> WORD_SIZE);
+ d = (Wtype) (u >> WORD_SIZE);
d *= HIGH_HALFWORD_COEFF;
d *= HIGH_HALFWORD_COEFF;
- d += (USItype) (u & (HIGH_WORD_COEFF - 1));
+ d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
return d;
}
#endif
#ifdef L_floatdisf
-#define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
-#define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
-#define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
-#define DI_SIZE (sizeof (DItype) * BITS_PER_UNIT)
+#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 codes for all the float formats that we know of. Note
that this is copied from real.h. */
#endif
SFtype
-__floatdisf (DItype u)
+__floatdisf (DWtype u)
{
/* Do the calculation in DFmode
so that we don't lose any of the precision of the high word
if (DF_SIZE < DI_SIZE
&& DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
{
-#define REP_BIT ((USItype) 1 << (DI_SIZE - DF_SIZE))
- if (! (- ((DItype) 1 << DF_SIZE) < u
- && u < ((DItype) 1 << DF_SIZE)))
+#define REP_BIT ((UWtype) 1 << (DI_SIZE - DF_SIZE))
+ if (! (- ((DWtype) 1 << DF_SIZE) < u
+ && u < ((DWtype) 1 << DF_SIZE)))
{
- if ((USItype) u & (REP_BIT - 1))
+ if ((UWtype) u & (REP_BIT - 1))
u |= REP_BIT;
}
}
- f = (SItype) (u >> WORD_SIZE);
+ f = (Wtype) (u >> WORD_SIZE);
f *= HIGH_HALFWORD_COEFF;
f *= HIGH_HALFWORD_COEFF;
- f += (USItype) (u & (HIGH_WORD_COEFF - 1));
+ f += (UWtype) (u & (HIGH_WORD_COEFF - 1));
return (SFtype) f;
}
#undef MAX
#include <limits.h>
-USItype
+UWtype
__fixunsxfsi (XFtype a)
{
if (a >= - (DFtype) LONG_MIN)
- return (SItype) (a + LONG_MIN) - LONG_MIN;
- return (SItype) a;
+ return (Wtype) (a + LONG_MIN) - LONG_MIN;
+ return (Wtype) a;
}
#endif
#undef MAX
#include <limits.h>
-USItype
+UWtype
__fixunsdfsi (DFtype a)
{
if (a >= - (DFtype) LONG_MIN)
- return (SItype) (a + LONG_MIN) - LONG_MIN;
- return (SItype) a;
+ return (Wtype) (a + LONG_MIN) - LONG_MIN;
+ return (Wtype) a;
}
#endif
#undef MAX
#include <limits.h>
-USItype
+UWtype
__fixunssfsi (SFtype a)
{
if (a >= - (SFtype) LONG_MIN)
- return (SItype) (a + LONG_MIN) - LONG_MIN;
- return (SItype) a;
+ return (Wtype) (a + LONG_MIN) - LONG_MIN;
+ return (Wtype) a;
}
#endif
\f
#define UDItype bogus_type
#define SFtype bogus_type
#define DFtype bogus_type
+#undef Wtype
+#undef UWtype
+#undef HWtype
+#undef UHWtype
+#undef DWtype
+#undef UDWtype
#undef char
#undef short
OSDN Git Service
