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.

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 */