From: jakub Date: Mon, 27 Dec 1999 08:34:45 +0000 (+0000) Subject: * config/h8300/h8300.h (TARGET_H8300H, TARGET_H8300S): Make sure X-Git-Tag: upstream/4.9.2~104024 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=cf378360a7404318c1669d5618e2465ec1d0e73b;p=platform%2Fupstream%2Flinaro-gcc.git * config/h8300/h8300.h (TARGET_H8300H, TARGET_H8300S): Make sure UNITS_PER_WORD and BITS_PER_WORD are compile time constants when compiling libgcc2. * config/mips/mips.h (TARGET_64BIT): Likewise. * config/rs6000/rs6000.h (TARGET_POWERPC64): Likewise. * libgcc2.c: Use {,U}{HW,W,DW}type and DWunion everywhere instead of {SI,DI}type and DIunion. Define these types to QI/HI modes on dsps. Give routines proper names if SI/DI modes are not used. * longlong.h: Use DWunion instead of DIunion. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@31095 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 8a9a0f1..dd06786 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,15 @@ +1999-12-17 Jakub Jelinek + + * config/h8300/h8300.h (TARGET_H8300H, TARGET_H8300S): Make sure + UNITS_PER_WORD and BITS_PER_WORD are compile time constants when + compiling libgcc2. + * config/mips/mips.h (TARGET_64BIT): Likewise. + * config/rs6000/rs6000.h (TARGET_POWERPC64): Likewise. + * libgcc2.c: Use {,U}{HW,W,DW}type and DWunion everywhere instead + of {SI,DI}type and DIunion. Define these types to QI/HI modes on + dsps. Give routines proper names if SI/DI modes are not used. + * longlong.h: Use DWunion instead of DIunion. + 1999-12-26 Zack Weinberg * acconfig.h: New ENABLE flags: TREE_CHECKING, RTL_CHECKING, diff --git a/gcc/config/h8300/h8300.h b/gcc/config/h8300/h8300.h index d0617e5..1c980b7 100644 --- a/gcc/config/h8300/h8300.h +++ b/gcc/config/h8300/h8300.h @@ -112,6 +112,23 @@ extern int target_flags; {"align-300", 8192, "Use H8/300 alignment rules"}, \ { "", TARGET_DEFAULT, NULL}} +#ifdef IN_LIBGCC2 +#undef TARGET_H8300H +#undef TARGET_H8300S +/* If compiling libgcc2, make these compile time constants based on what + flags are we actually compiling with. */ +#ifdef __H8300H__ +#define TARGET_H8300H 1 +#else +#define TARGET_H8300H 0 +#endif +#ifdef __H8300S__ +#define TARGET_H8300S 1 +#else +#define TARGET_H8300S 0 +#endif +#endif /* !IN_LIBGCC2 */ + /* Do things that must be done once at start up. */ #define OVERRIDE_OPTIONS \ diff --git a/gcc/config/mips/mips.h b/gcc/config/mips/mips.h index 0f54a8f..8d8dcd0 100644 --- a/gcc/config/mips/mips.h +++ b/gcc/config/mips/mips.h @@ -481,6 +481,16 @@ extern void sbss_section PARAMS ((void)); #define MIPS_ISA_DEFAULT 1 #endif +#ifdef IN_LIBGCC2 +#undef TARGET_64BIT +/* Make this compile time constant for libgcc2 */ +#ifdef __mips64 +#define TARGET_64BIT 1 +#else +#define TARGET_64BIT 0 +#endif +#else /* IN_LIBGCC2 */ + #ifndef MULTILIB_ENDIAN_DEFAULT #if TARGET_ENDIAN_DEFAULT == 0 #define MULTILIB_ENDIAN_DEFAULT "EL" diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h index 68298b5..f3f3f2e 100644 --- a/gcc/config/rs6000/rs6000.h +++ b/gcc/config/rs6000/rs6000.h @@ -303,6 +303,16 @@ extern int target_flags; #define TARGET_UPDATE (! TARGET_NO_UPDATE) #define TARGET_FUSED_MADD (! TARGET_NO_FUSED_MADD) +#ifdef IN_LIBGCC2 +/* For libgcc2 we make sure this is a compile time constant */ +#undef TARGET_POWERPC64 +#ifdef __64BIT__ +#define TARGET_POWERPC64 1 +#else +#define TARGET_POWERPC64 0 +#endif +#endif + /* Pseudo target to indicate whether the object format is ELF (to get around not having conditional compilation in the md file) */ #ifndef TARGET_ELF diff --git a/gcc/libgcc2.c b/gcc/libgcc2.c index 37534fd..7cba424 100644 --- a/gcc/libgcc2.c +++ b/gcc/libgcc2.c @@ -95,11 +95,22 @@ extern int atexit(void (*)(void)); 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))); @@ -111,6 +122,29 @@ typedef float XFtype __attribute__ ((mode (XF))); 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 @@ -127,23 +161,75 @@ typedef int word_type __attribute__ ((mode (__word__))); #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 @@ -152,9 +238,9 @@ typedef int word_type __attribute__ ((mode (__word__))); 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) \ @@ -164,29 +250,21 @@ typedef union #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 #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; } @@ -195,29 +273,29 @@ __negdi2 (DItype u) /* 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; @@ -225,29 +303,29 @@ __lshrdi3 (DItype u, word_type b) #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; @@ -255,30 +333,30 @@ __ashldi3 (DItype u, word_type b) #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; @@ -286,10 +364,10 @@ __ashrdi3 (DItype u, word_type b) #endif #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); @@ -298,7 +376,7 @@ __ffsdi2 (DItype u) 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; @@ -306,18 +384,18 @@ __ffsdi2 (DItype u) #endif #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; } @@ -325,15 +403,15 @@ __muldi3 (DItype u, DItype v) #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); @@ -341,18 +419,18 @@ __udiv_w_sdiv (USItype *rp, USItype a1, USItype a0, USItype 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 */ { @@ -423,11 +501,11 @@ __udiv_w_sdiv (USItype *rp, USItype a1, USItype a0, USItype d) } #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; } @@ -456,15 +534,15 @@ static const UQItype __clz_tab[] = 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; @@ -523,7 +601,7 @@ __udivmoddi4 (UDItype n, UDItype d, UDItype *rp) denominator set. */ d0 = d0 << bm; - n1 = (n1 << bm) | (n0 >> (SI_TYPE_SIZE - bm)); + n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm)); n0 = n0 << bm; } @@ -548,7 +626,7 @@ __udivmoddi4 (UDItype n, UDItype d, UDItype *rp) 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; @@ -557,7 +635,7 @@ __udivmoddi4 (UDItype n, UDItype d, UDItype *rp) { /* Normalize. */ - b = SI_TYPE_SIZE - bm; + b = W_TYPE_SIZE - bm; d0 = d0 << bm; n2 = n1 >> b; @@ -634,10 +712,10 @@ __udivmoddi4 (UDItype n, UDItype d, UDItype *rp) } 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; @@ -675,12 +753,12 @@ __udivmoddi4 (UDItype n, UDItype d, UDItype *rp) #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; @@ -692,7 +770,7 @@ __divdi3 (DItype u, DItype 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); @@ -701,12 +779,12 @@ __divdi3 (DItype u, DItype v) #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; @@ -726,10 +804,10 @@ __moddi3 (DItype u, DItype 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); @@ -738,18 +816,18 @@ __umoddi3 (UDItype u, UDItype v) #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 #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; @@ -757,9 +835,9 @@ __cmpdi2 (DItype a, DItype 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; } @@ -767,58 +845,60 @@ __cmpdi2 (DItype a, DItype b) #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 #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) @@ -828,39 +908,41 @@ __fixtfdi (TFtype a) #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) @@ -870,39 +952,41 @@ __fixxfdi (XFtype a) #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) @@ -912,10 +996,10 @@ __fixdfdi (DFtype a) #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 @@ -923,32 +1007,34 @@ __fixunssfdi (SFtype original_a) 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) @@ -958,67 +1044,67 @@ __fixsfdi (SFtype a) #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. */ @@ -1049,7 +1135,7 @@ __floatdidf (DItype u) #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 @@ -1065,18 +1151,18 @@ __floatdisf (DItype u) 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; } @@ -1095,12 +1181,12 @@ __floatdisf (DItype u) #undef MAX #include -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 @@ -1117,12 +1203,12 @@ __fixunsxfsi (XFtype a) #undef MAX #include -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 @@ -1139,12 +1225,12 @@ __fixunsdfsi (DFtype a) #undef MAX #include -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 @@ -1156,6 +1242,12 @@ __fixunssfsi (SFtype a) #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 diff --git a/gcc/longlong.h b/gcc/longlong.h index 2cea66d..539174a 100644 --- a/gcc/longlong.h +++ b/gcc/longlong.h @@ -195,7 +195,7 @@ extern UDItype __udiv_qrnnd __P ((UDItype *, UDItype, UDItype, UDItype)); /* Call libgcc1 routine. */ #define umul_ppmm(w1, w0, u, v) \ do { \ - DIunion __w; \ + DWunion __w; \ __w.ll = __umulsidi3 (u, v); \ w1 = __w.s.high; \ w0 = __w.s.low; \ @@ -1383,7 +1383,7 @@ UDItype __umulsidi3 (USItype, USItype); #if !defined (__umulsidi3) #define __umulsidi3(u, v) \ - ({DIunion __w; \ + ({DWunion __w; \ umul_ppmm (__w.s.high, __w.s.low, u, v); \ __w.ll; }) #endif