diff options
author | obrien <obrien@FreeBSD.org> | 2002-02-01 18:16:02 +0000 |
---|---|---|
committer | obrien <obrien@FreeBSD.org> | 2002-02-01 18:16:02 +0000 |
commit | c9ab9ae440a8066b2c2b85b157b1fdadcf09916a (patch) | |
tree | 086d9d6c8fbd4fc8fe4495059332f66bc0f8d12b /contrib/gcc/real.h | |
parent | 2ecfd8bd04b63f335c1ec6295740a4bfd97a4fa6 (diff) | |
download | FreeBSD-src-c9ab9ae440a8066b2c2b85b157b1fdadcf09916a.zip FreeBSD-src-c9ab9ae440a8066b2c2b85b157b1fdadcf09916a.tar.gz |
Enlist the FreeBSD-CURRENT users as testers of what is to become Gcc 3.1.0.
These bits are taken from the FSF anoncvs repo on 1-Feb-2002 08:20 PST.
Diffstat (limited to 'contrib/gcc/real.h')
-rw-r--r-- | contrib/gcc/real.h | 206 |
1 files changed, 98 insertions, 108 deletions
diff --git a/contrib/gcc/real.h b/contrib/gcc/real.h index f289379..2d3a909 100644 --- a/contrib/gcc/real.h +++ b/contrib/gcc/real.h @@ -1,25 +1,26 @@ /* Definitions of floating-point access for GNU compiler. - Copyright (C) 1989, 91, 94, 96-98, 1999 Free Software Foundation, Inc. + Copyright (C) 1989, 1991, 1994, 1996, 1997, 1998, + 1999, 2000, 2002 Free Software Foundation, Inc. -This file is part of GNU CC. +This file is part of GCC. -GNU CC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. -GNU CC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. You should have received a copy of the GNU General Public License -along with GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ -#ifndef REAL_H_INCLUDED -#define REAL_H_INCLUDED +#ifndef GCC_REAL_H +#define GCC_REAL_H /* Define codes for all the float formats that we know of. */ #define UNKNOWN_FLOAT_FORMAT 0 @@ -38,6 +39,10 @@ Boston, MA 02111-1307, USA. */ #define HOST_FLOAT_FORMAT IEEE_FLOAT_FORMAT #endif +#ifndef INTEL_EXTENDED_IEEE_FORMAT +#define INTEL_EXTENDED_IEEE_FORMAT 0 +#endif + #if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT #define REAL_INFINITY #endif @@ -67,7 +72,15 @@ Boston, MA 02111-1307, USA. */ #ifndef LONG_DOUBLE_TYPE_SIZE #define LONG_DOUBLE_TYPE_SIZE 64 #endif -#if (LONG_DOUBLE_TYPE_SIZE == 96) || (LONG_DOUBLE_TYPE_SIZE == 128) +/* MAX_LONG_DOUBLE_TYPE_SIZE is a constant tested by #if. + LONG_DOUBLE_TYPE_SIZE can vary at compiler run time. + So long as macros like REAL_VALUE_TO_TARGET_LONG_DOUBLE cannot + vary too, however, then XFmode and TFmode long double + cannot both be supported at the same time. */ +#ifndef MAX_LONG_DOUBLE_TYPE_SIZE +#define MAX_LONG_DOUBLE_TYPE_SIZE LONG_DOUBLE_TYPE_SIZE +#endif +#if (MAX_LONG_DOUBLE_TYPE_SIZE == 96) || (MAX_LONG_DOUBLE_TYPE_SIZE == 128) #ifndef REAL_ARITHMETIC #define REAL_ARITHMETIC #endif @@ -76,8 +89,8 @@ Boston, MA 02111-1307, USA. */ /* **** Start of software floating point emulator interface macros **** */ /* Support 80-bit extended real XFmode if LONG_DOUBLE_TYPE_SIZE - has been defined to be 96 in the tm.h machine file. */ -#if (LONG_DOUBLE_TYPE_SIZE == 96) + has been defined to be 96 in the tm.h machine file. */ +#if (MAX_LONG_DOUBLE_TYPE_SIZE == 96) #define REAL_IS_NOT_DOUBLE #define REAL_ARITHMETIC typedef struct { @@ -87,7 +100,7 @@ typedef struct { #else /* no XFmode support */ -#if (LONG_DOUBLE_TYPE_SIZE == 128) +#if (MAX_LONG_DOUBLE_TYPE_SIZE == 128) #define REAL_IS_NOT_DOUBLE #define REAL_ARITHMETIC @@ -100,7 +113,7 @@ typedef struct { #if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT /* If no XFmode support, then a REAL_VALUE_TYPE is 64 bits wide - but it is not necessarily a host machine double. */ + but it is not necessarily a host machine double. */ #define REAL_IS_NOT_DOUBLE typedef struct { HOST_WIDE_INT r[(7 + sizeof (HOST_WIDE_INT))/(sizeof (HOST_WIDE_INT))]; @@ -108,14 +121,14 @@ typedef struct { #define REAL_VALUE_TYPE realvaluetype #else /* If host and target formats are compatible, then a REAL_VALUE_TYPE - is actually a host machine double. */ + is actually a host machine double. */ #define REAL_VALUE_TYPE double #endif #endif /* no TFmode support */ #endif /* no XFmode support */ -extern int significand_size PROTO((enum machine_mode)); +extern unsigned int significand_size PARAMS ((enum machine_mode)); /* If emulation has been enabled by defining REAL_ARITHMETIC or by setting LONG_DOUBLE_TYPE_SIZE to 96 or 128, then define macros so that @@ -127,37 +140,36 @@ extern int significand_size PROTO((enum machine_mode)); #define REAL_ARITHMETIC(value, code, d1, d2) \ earith (&(value), (code), &(d1), &(d2)) -/* Declare functions in real.c. */ -extern void earith PROTO((REAL_VALUE_TYPE *, int, +/* Declare functions in real.c. */ +extern void earith PARAMS ((REAL_VALUE_TYPE *, int, REAL_VALUE_TYPE *, REAL_VALUE_TYPE *)); -extern REAL_VALUE_TYPE etrunci PROTO((REAL_VALUE_TYPE)); -extern REAL_VALUE_TYPE etruncui PROTO((REAL_VALUE_TYPE)); -extern REAL_VALUE_TYPE ereal_atof PROTO((const char *, enum machine_mode)); -extern REAL_VALUE_TYPE ereal_negate PROTO((REAL_VALUE_TYPE)); -extern HOST_WIDE_INT efixi PROTO((REAL_VALUE_TYPE)); -extern unsigned HOST_WIDE_INT efixui PROTO((REAL_VALUE_TYPE)); -extern void ereal_from_int PROTO((REAL_VALUE_TYPE *, +extern REAL_VALUE_TYPE etrunci PARAMS ((REAL_VALUE_TYPE)); +extern REAL_VALUE_TYPE etruncui PARAMS ((REAL_VALUE_TYPE)); +extern REAL_VALUE_TYPE ereal_negate PARAMS ((REAL_VALUE_TYPE)); +extern HOST_WIDE_INT efixi PARAMS ((REAL_VALUE_TYPE)); +extern unsigned HOST_WIDE_INT efixui PARAMS ((REAL_VALUE_TYPE)); +extern void ereal_from_int PARAMS ((REAL_VALUE_TYPE *, HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode)); -extern void ereal_from_uint PROTO((REAL_VALUE_TYPE *, +extern void ereal_from_uint PARAMS ((REAL_VALUE_TYPE *, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, enum machine_mode)); -extern void ereal_to_int PROTO((HOST_WIDE_INT *, HOST_WIDE_INT *, +extern void ereal_to_int PARAMS ((HOST_WIDE_INT *, HOST_WIDE_INT *, REAL_VALUE_TYPE)); -extern REAL_VALUE_TYPE ereal_ldexp PROTO((REAL_VALUE_TYPE, int)); - -extern void etartdouble PROTO((REAL_VALUE_TYPE, long *)); -extern void etarldouble PROTO((REAL_VALUE_TYPE, long *)); -extern void etardouble PROTO((REAL_VALUE_TYPE, long *)); -extern long etarsingle PROTO((REAL_VALUE_TYPE)); -extern void ereal_to_decimal PROTO((REAL_VALUE_TYPE, char *)); -extern int ereal_cmp PROTO((REAL_VALUE_TYPE, REAL_VALUE_TYPE)); -extern int ereal_isneg PROTO((REAL_VALUE_TYPE)); -extern REAL_VALUE_TYPE ereal_unto_float PROTO((long)); -extern REAL_VALUE_TYPE ereal_unto_double PROTO((long *)); -extern REAL_VALUE_TYPE ereal_from_float PROTO((HOST_WIDE_INT)); -extern REAL_VALUE_TYPE ereal_from_double PROTO((HOST_WIDE_INT *)); +extern REAL_VALUE_TYPE ereal_ldexp PARAMS ((REAL_VALUE_TYPE, int)); + +extern void etartdouble PARAMS ((REAL_VALUE_TYPE, long *)); +extern void etarldouble PARAMS ((REAL_VALUE_TYPE, long *)); +extern void etardouble PARAMS ((REAL_VALUE_TYPE, long *)); +extern long etarsingle PARAMS ((REAL_VALUE_TYPE)); +extern void ereal_to_decimal PARAMS ((REAL_VALUE_TYPE, char *)); +extern int ereal_cmp PARAMS ((REAL_VALUE_TYPE, REAL_VALUE_TYPE)); +extern int ereal_isneg PARAMS ((REAL_VALUE_TYPE)); +extern REAL_VALUE_TYPE ereal_unto_float PARAMS ((long)); +extern REAL_VALUE_TYPE ereal_unto_double PARAMS ((long *)); +extern REAL_VALUE_TYPE ereal_from_float PARAMS ((HOST_WIDE_INT)); +extern REAL_VALUE_TYPE ereal_from_double PARAMS ((HOST_WIDE_INT *)); #define REAL_VALUES_EQUAL(x, y) (ereal_cmp ((x), (y)) == 0) /* true if x < y : */ @@ -167,21 +179,19 @@ extern REAL_VALUE_TYPE ereal_from_double PROTO((HOST_WIDE_INT *)); /* These return REAL_VALUE_TYPE: */ #define REAL_VALUE_RNDZINT(x) (etrunci (x)) #define REAL_VALUE_UNSIGNED_RNDZINT(x) (etruncui (x)) -extern REAL_VALUE_TYPE real_value_truncate PROTO ((enum machine_mode, - REAL_VALUE_TYPE)); #define REAL_VALUE_TRUNCATE(mode, x) real_value_truncate (mode, x) /* These return HOST_WIDE_INT: */ /* Convert a floating-point value to integer, rounding toward zero. */ #define REAL_VALUE_FIX(x) (efixi (x)) /* Convert a floating-point value to unsigned integer, rounding - toward zero. */ + toward zero. */ #define REAL_VALUE_UNSIGNED_FIX(x) (efixui (x)) /* Convert ASCII string S to floating point in mode M. Decimal input uses ATOF. Hexadecimal uses HTOF. */ -#define REAL_VALUE_ATOF ereal_atof -#define REAL_VALUE_HTOF ereal_atof +#define REAL_VALUE_ATOF(s,m) ereal_atof(s,m) +#define REAL_VALUE_HTOF(s,m) ereal_atof(s,m) #define REAL_VALUE_NEGATE ereal_negate @@ -197,28 +207,28 @@ extern REAL_VALUE_TYPE real_value_truncate PROTO ((enum machine_mode, #define REAL_VALUE_FROM_UNSIGNED_INT(d, lo, hi, mode) \ ereal_from_uint (&d, lo, hi, mode) -/* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ -#if LONG_DOUBLE_TYPE_SIZE == 96 -#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) (etarldouble ((IN), (OUT))) -#else -#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) (etartdouble ((IN), (OUT))) -#endif +/* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ +#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) \ + (LONG_DOUBLE_TYPE_SIZE == 64 ? etardouble ((IN), (OUT)) \ + : LONG_DOUBLE_TYPE_SIZE == 96 ? etarldouble ((IN), (OUT)) \ + : LONG_DOUBLE_TYPE_SIZE == 128 ? etartdouble ((IN), (OUT)) \ + : abort ()) #define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) (etardouble ((IN), (OUT))) -/* IN is a REAL_VALUE_TYPE. OUT is a long. */ +/* IN is a REAL_VALUE_TYPE. OUT is a long. */ #define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) ((OUT) = etarsingle ((IN))) -/* Inverse of REAL_VALUE_TO_TARGET_DOUBLE. */ +/* Inverse of REAL_VALUE_TO_TARGET_DOUBLE. */ #define REAL_VALUE_UNTO_TARGET_DOUBLE(d) (ereal_unto_double (d)) -/* Inverse of REAL_VALUE_TO_TARGET_SINGLE. */ +/* Inverse of REAL_VALUE_TO_TARGET_SINGLE. */ #define REAL_VALUE_UNTO_TARGET_SINGLE(f) (ereal_unto_float (f)) /* d is an array of HOST_WIDE_INT that holds a double precision - value in the target computer's floating point format. */ + value in the target computer's floating point format. */ #define REAL_VALUE_FROM_TARGET_DOUBLE(d) (ereal_from_double (d)) -/* f is a HOST_WIDE_INT containing a single precision target float value. */ +/* f is a HOST_WIDE_INT containing a single precision target float value. */ #define REAL_VALUE_FROM_TARGET_SINGLE(f) (ereal_from_float (f)) /* Conversions to decimal ASCII string. */ @@ -275,7 +285,7 @@ do { \ HOST_WIDE_INT l; \ } u; \ if (sizeof(HOST_WIDE_INT) < sizeof(float)) \ - abort(); \ + abort (); \ u.l = 0; \ u.f = (IN); \ (OUT) = u.l; \ @@ -293,7 +303,7 @@ do { \ HOST_WIDE_INT l[2]; \ } u; \ if (sizeof(HOST_WIDE_INT) * 2 < sizeof(REAL_VALUE_TYPE)) \ - abort(); \ + abort (); \ u.l[0] = u.l[1] = 0; \ u.f = (IN); \ if (HOST_FLOAT_WORDS_BIG_ENDIAN == FLOAT_WORDS_BIG_ENDIAN) \ @@ -304,7 +314,7 @@ do { \ #endif #endif /* HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT */ -/* In this configuration, double and long double are the same. */ +/* In this configuration, double and long double are the same. */ #ifndef REAL_VALUE_TO_TARGET_LONG_DOUBLE #define REAL_VALUE_TO_TARGET_LONG_DOUBLE(a, b) REAL_VALUE_TO_TARGET_DOUBLE (a, b) #endif @@ -314,7 +324,7 @@ do { \ -0.0 equals 0.0 but they are not identical, and conversely two NaNs might be identical but they cannot be equal. */ #define REAL_VALUES_IDENTICAL(x, y) \ - (!bcmp ((char *) &(x), (char *) &(y), sizeof (REAL_VALUE_TYPE))) + (!memcmp ((char *) &(x), (char *) &(y), sizeof (REAL_VALUE_TYPE))) /* Compare two floating-point values for equality. */ #ifndef REAL_VALUES_EQUAL @@ -342,7 +352,7 @@ do { \ #endif /* Convert a floating-point value to unsigned integer, rounding - toward zero. */ + toward zero. */ #ifndef REAL_VALUE_UNSIGNED_FIX #define REAL_VALUE_UNSIGNED_FIX(x) ((unsigned int) (x)) #endif @@ -350,14 +360,13 @@ do { \ /* Scale X by Y powers of 2. */ #ifndef REAL_VALUE_LDEXP #define REAL_VALUE_LDEXP(x, y) ldexp (x, y) -extern double ldexp (); +extern double ldexp PARAMS ((double, int)); #endif /* Convert the string X to a floating-point value. */ #ifndef REAL_VALUE_ATOF #if 1 -/* Use real.c to convert decimal numbers to binary, ... */ -REAL_VALUE_TYPE ereal_atof (); +/* Use real.c to convert decimal numbers to binary, ... */ #define REAL_VALUE_ATOF(x, s) ereal_atof (x, s) /* Could use ereal_atof here for hexadecimal floats too, but real_hex_to_f is OK and it uses faster native fp arithmetic. */ @@ -379,7 +388,8 @@ extern double (atof) (); /* Hexadecimal floating constant input for use with host computer's fp arithmetic. */ #ifndef REAL_VALUE_HTOF -extern REAL_VALUE_TYPE real_hex_to_f PROTO((char *, enum machine_mode)); +extern REAL_VALUE_TYPE real_hex_to_f PARAMS ((const char *, + enum machine_mode)); #define REAL_VALUE_HTOF(s,m) real_hex_to_f(s,m) #endif @@ -393,7 +403,8 @@ extern REAL_VALUE_TYPE real_hex_to_f PROTO((char *, enum machine_mode)); size and where `float' is SFmode. */ /* Don't use REAL_VALUE_TRUNCATE directly--always call real_value_truncate. */ -extern REAL_VALUE_TYPE real_value_truncate PROTO((enum machine_mode, REAL_VALUE_TYPE)); +extern REAL_VALUE_TYPE real_value_truncate PARAMS ((enum machine_mode, + REAL_VALUE_TYPE)); #ifndef REAL_VALUE_TRUNCATE #define REAL_VALUE_TRUNCATE(mode, x) \ @@ -401,26 +412,22 @@ extern REAL_VALUE_TYPE real_value_truncate PROTO((enum machine_mode, REAL_VALUE_ ? (float) (x) : (x)) #endif -/* Determine whether a floating-point value X is infinite. */ +/* Determine whether a floating-point value X is infinite. */ #ifndef REAL_VALUE_ISINF #define REAL_VALUE_ISINF(x) (target_isinf (x)) #endif -/* Determine whether a floating-point value X is a NaN. */ +/* Determine whether a floating-point value X is a NaN. */ #ifndef REAL_VALUE_ISNAN #define REAL_VALUE_ISNAN(x) (target_isnan (x)) #endif -/* Determine whether a floating-point value X is negative. */ +/* Determine whether a floating-point value X is negative. */ #ifndef REAL_VALUE_NEGATIVE #define REAL_VALUE_NEGATIVE(x) (target_negative (x)) #endif -extern int target_isnan PROTO ((REAL_VALUE_TYPE)); -extern int target_isinf PROTO ((REAL_VALUE_TYPE)); -extern int target_negative PROTO ((REAL_VALUE_TYPE)); - -/* Determine whether a floating-point value X is minus 0. */ +/* Determine whether a floating-point value X is minus 0. */ #ifndef REAL_VALUE_MINUS_ZERO #define REAL_VALUE_MINUS_ZERO(x) ((x) == 0 && REAL_VALUE_NEGATIVE (x)) #endif @@ -441,39 +448,22 @@ union real_extract HOST_WIDE_INT i[sizeof (REAL_VALUE_TYPE) / sizeof (HOST_WIDE_INT)]; }; -/* For a CONST_DOUBLE: - The usual two ints that hold the value. - For a DImode, that is all there are; - and CONST_DOUBLE_LOW is the low-order word and ..._HIGH the high-order. - For a float, the number of ints varies, - and CONST_DOUBLE_LOW is the one that should come first *in memory*. - So use &CONST_DOUBLE_LOW(r) as the address of an array of ints. */ -#define CONST_DOUBLE_LOW(r) XWINT (r, 2) -#define CONST_DOUBLE_HIGH(r) XWINT (r, 3) - -/* Link for chain of all CONST_DOUBLEs in use in current function. */ -#define CONST_DOUBLE_CHAIN(r) XEXP (r, 1) -/* The MEM which represents this CONST_DOUBLE's value in memory, - or const0_rtx if no MEM has been made for it yet, - or cc0_rtx if it is not on the chain. */ -#define CONST_DOUBLE_MEM(r) XEXP (r, 0) - /* Given a CONST_DOUBLE in FROM, store into TO the value it represents. */ /* Function to return a real value (not a tree node) from a given integer constant. */ union tree_node; -REAL_VALUE_TYPE real_value_from_int_cst PROTO ((union tree_node *, +REAL_VALUE_TYPE real_value_from_int_cst PARAMS ((union tree_node *, union tree_node *)); #define REAL_VALUE_FROM_CONST_DOUBLE(to, from) \ do { union real_extract u; \ - bcopy ((char *) &CONST_DOUBLE_LOW ((from)), (char *) &u, sizeof u); \ + memcpy (&u, &CONST_DOUBLE_LOW ((from)), sizeof u); \ to = u.d; } while (0) /* Return a CONST_DOUBLE with value R and mode M. */ #define CONST_DOUBLE_FROM_REAL_VALUE(r, m) immed_real_const_1 (r, m) -extern struct rtx_def *immed_real_const_1 PROTO((REAL_VALUE_TYPE, +extern struct rtx_def *immed_real_const_1 PARAMS ((REAL_VALUE_TYPE, enum machine_mode)); @@ -485,11 +475,11 @@ extern struct rtx_def *immed_real_const_1 PROTO((REAL_VALUE_TYPE, #endif /* Replace R by 1/R in the given machine mode, if the result is exact. */ -extern int exact_real_inverse PROTO((enum machine_mode, REAL_VALUE_TYPE *)); - -extern void debug_real PROTO ((REAL_VALUE_TYPE)); - -/* In varasm.c */ -extern void assemble_real PROTO ((REAL_VALUE_TYPE, - enum machine_mode)); -#endif /* Not REAL_H_INCLUDED */ +extern int exact_real_inverse PARAMS ((enum machine_mode, REAL_VALUE_TYPE *)); +extern int target_isnan PARAMS ((REAL_VALUE_TYPE)); +extern int target_isinf PARAMS ((REAL_VALUE_TYPE)); +extern int target_negative PARAMS ((REAL_VALUE_TYPE)); +extern void debug_real PARAMS ((REAL_VALUE_TYPE)); +extern REAL_VALUE_TYPE ereal_atof PARAMS ((const char *, enum machine_mode)); + +#endif /* ! GCC_REAL_H */ |