RFA: Move definition of __GNUC__ etc. to front-end

RFA: Move definition of __GNUC__ etc. to front-end

[Neil Booth]

This moves the definition of __GNUC__, __GNUG__, __GNUC_MINOR__
and __GNUC_PATCHLEVEL__ to the front end, to join most other
macro definitions.

Further to discussions with Zack, we couldn't see a good reason
for cpp to not give the preprocessed output that GCC sees, so
I define these unconditionally.  We also didn't think that there
was good reason to continue having -no-gcc, so I removed that too.

I took the opportunity to remove the growing body of CPP builtin
code in c-common.c into a new file.  4 builtins (for stddef.h)
had to remain in c-common.c, as they use macros defined therein,
and working round that was uglier than leaving them in c-common.c.

Bootstrapping x86 Linux.  OK to commit if there are no regressions?

Neil.

	* Makefile.in: Update.
	* c-common.c: Don't include real.h or except.h.
	(REGISTER_PREFIX): Remove.
	(builtin_define_std, builtin_define_with_value,
	builtin_define_with_int_value, builtin_define_with_hex_fp_value,
	builtin_define_type_max, builtin_define_type_precision,
	builtin_define_float_constants): Move to c-cppbuiltin.c.
	(c_stddef_cpp_builtins): New.
	* c-common.h (builtin_define_with_value, c_stddef_cpp_builtins): New.
	* c-cppbuiltin.c: New, extracted from c-common.c.
	(define__GNUC__): New.
	* cppspec.c (lang_specific_driver): Remove support of -no-gcc.
	* gcc.c: Remove support of %v1, %v2 and %v3 specs.
	(cpp_unique_options): Don't support no-gcc.
	(do_spec_1): Remove support of version specs.
	* doc/invoke.texi: Remove documentation of %v1, %v2 and %v3.
	* doc/passes.texi: Update.
	* doc/tm.texi: Update.
cp:
	* Make-lang.in (CXX_C_OBJS): Update.
	* lang-specs.h: Don't define __GNUG__ here.

============================================================
Index: gcc/Makefile.in
--- gcc/Makefile.in	8 Mar 2003 18:24:18 -0000	1.1012
+++ gcc/Makefile.in	10 Mar 2003 21:54:10 -0000
@@ -760,7 +760,7 @@ CXX_TARGET_OBJS=@cxx_target_objs@
 # Language-specific object files for C and Objective C.
 C_AND_OBJC_OBJS = attribs.o c-errors.o c-lex.o c-pragma.o c-decl.o c-typeck.o \
   c-convert.o c-aux-info.o c-common.o c-opts.o c-format.o c-semantics.o \
-  c-incpath.o cppdefault.o c-ppoutput.o \
+  c-incpath.o cppdefault.o c-ppoutput.o c-cppbuiltin.o \
   c-objc-common.o c-dump.o c-pch.o libcpp.a $(C_TARGET_OBJS)
 
 # Language-specific object files for C.
@@ -1273,15 +1273,19 @@ tlink.o: tlink.c $(DEMANGLE_H) $(HASHTAB
 # A file used by all variants of C.
 
 c-common.o : c-common.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \
-	$(OBSTACK_H) $(C_COMMON_H) flags.h toplev.h output.h c-pragma.h $(RTL_H) \
-	$(GGC_H) $(EXPR_H) $(TM_P_H) builtin-types.def builtin-attrs.def $(TARGET_H) \
-	diagnostic.h except.h gt-c-common.h real.h langhooks.h varray.h
+	$(OBSTACK_H) $(C_COMMON_H) flags.h toplev.h output.h c-pragma.h \
+	$(GGC_H) $(EXPR_H) $(TM_P_H) builtin-types.def builtin-attrs.def \
+	diagnostic.h gt-c-common.h langhooks.h varray.h $(RTL_H) $(TARGET_H)
 c-pretty-print.o : c-pretty-print.c c-pretty-print.h pretty-print.h \
 	$(C_COMMON_H) $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) real.h
 
 c-opts.o : c-opts.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) $(C_COMMON_H) \
         c-pragma.h flags.h toplev.h langhooks.h tree-inline.h diagnostic.h \
 	intl.h
+
+c-cppbuiltin.o : c-cppbuiltin.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
+	$(TREE_H) $(C_COMMON_H) c-pragma.h flags.h toplev.h langhooks.h \
+	output.h except.h real.h
 
 # A file used by all variants of C and some other languages.
 
============================================================
Index: gcc/c-common.c
--- gcc/c-common.c	9 Mar 2003 19:47:54 -0000	1.404
+++ gcc/c-common.c	10 Mar 2003 21:54:12 -0000
@@ -1,6 +1,6 @@
 /* Subroutines shared by all languages that are variants of C.
    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-   2001, 2002 Free Software Foundation, Inc.
+   2001, 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -24,7 +24,6 @@ Software Foundation, 59 Temple Place - S
 #include "coretypes.h"
 #include "tm.h"
 #include "tree.h"
-#include "real.h"
 #include "flags.h"
 #include "toplev.h"
 #include "output.h"
@@ -40,9 +39,9 @@ Software Foundation, 59 Temple Place - S
 #include "cpplib.h"
 #include "target.h"
 #include "langhooks.h"
-#include "except.h"		/* For USING_SJLJ_EXCEPTIONS.  */
 #include "tree-inline.h"
 
+
 cpp_reader *parse_in;		/* Declared in c-pragma.h.  */
 
 /* We let tm.h override the types used here, to handle trivial differences
@@ -87,10 +86,6 @@ cpp_reader *parse_in;		/* Declared in c-
 			: "long long unsigned int"))
 #endif
 
-#ifndef REGISTER_PREFIX
-#define REGISTER_PREFIX ""
-#endif
-
 /* The variant of the C language being processed.  */
 
 enum c_language_kind c_language;
@@ -806,18 +801,6 @@ static void check_nonnull_arg		PARAMS ((
 static bool nonnull_check_p		PARAMS ((tree, unsigned HOST_WIDE_INT));
 static bool get_nonnull_operand		PARAMS ((tree,
 						 unsigned HOST_WIDE_INT *));
-void builtin_define_std PARAMS ((const char *));
-static void builtin_define_with_value PARAMS ((const char *, const char *,
-                                               int));
-static void builtin_define_with_int_value PARAMS ((const char *,
-						   HOST_WIDE_INT));
-static void builtin_define_with_hex_fp_value PARAMS ((const char *, tree,
-						      int, const char *,
-						      const char *));
-static void builtin_define_type_max PARAMS ((const char *, tree, int));
-static void builtin_define_type_precision PARAMS ((const char *, tree));
-static void builtin_define_float_constants PARAMS ((const char *,
-						    const char *, tree));
 
 /* Table of machine-independent attributes common to all C-like languages.  */
 const struct attribute_spec c_common_attribute_table[] =
@@ -4761,461 +4744,15 @@ boolean_increment (code, arg)
   return val;
 }
 \f
-/* Define NAME with value TYPE precision.  */
-static void
-builtin_define_type_precision (name, type)
-     const char *name;
-     tree type;
-{
-  builtin_define_with_int_value (name, TYPE_PRECISION (type));
-}
-
-/* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX.  */
-static void
-builtin_define_float_constants (name_prefix, fp_suffix, type)
-     const char *name_prefix;
-     const char *fp_suffix;
-     tree type;
-{
-  /* Used to convert radix-based values to base 10 values in several cases.
-
-     In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
-     least 6 significant digits for correct results.  Using the fraction
-     formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
-     intermediate; perhaps someone can find a better approximation, in the
-     mean time, I suspect using doubles won't harm the bootstrap here.  */
-
-  const double log10_2 = .30102999566398119521;
-  double log10_b;
-  const struct real_format *fmt;
-
-  char name[64], buf[128];
-  int dig, min_10_exp, max_10_exp;
-  int decimal_dig;
-
-  fmt = real_format_for_mode[TYPE_MODE (type) - QFmode];
-
-  /* The radix of the exponent representation.  */
-  if (type == float_type_node)
-    builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
-  log10_b = log10_2 * fmt->log2_b;
-
-  /* The number of radix digits, p, in the floating-point significand.  */
-  sprintf (name, "__%s_MANT_DIG__", name_prefix);
-  builtin_define_with_int_value (name, fmt->p);
-
-  /* The number of decimal digits, q, such that any floating-point number
-     with q decimal digits can be rounded into a floating-point number with
-     p radix b digits and back again without change to the q decimal digits,
-
-	p log10 b			if b is a power of 10
- 	floor((p - 1) log10 b)		otherwise
-  */
-  dig = (fmt->p - 1) * log10_b;
-  sprintf (name, "__%s_DIG__", name_prefix);
-  builtin_define_with_int_value (name, dig);
-
-  /* The minimum negative int x such that b**(x-1) is a normalized float.  */
-  sprintf (name, "__%s_MIN_EXP__", name_prefix);
-  sprintf (buf, "(%d)", fmt->emin);
-  builtin_define_with_value (name, buf, 0);
-
-  /* The minimum negative int x such that 10**x is a normalized float,
-
-	  ceil (log10 (b ** (emin - 1)))
-	= ceil (log10 (b) * (emin - 1))
-
-     Recall that emin is negative, so the integer truncation calculates
-     the ceiling, not the floor, in this case.  */
-  min_10_exp = (fmt->emin - 1) * log10_b;
-  sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
-  sprintf (buf, "(%d)", min_10_exp);
-  builtin_define_with_value (name, buf, 0);
-
-  /* The maximum int x such that b**(x-1) is a representable float.  */
-  sprintf (name, "__%s_MAX_EXP__", name_prefix);
-  builtin_define_with_int_value (name, fmt->emax);
-
-  /* The maximum int x such that 10**x is in the range of representable
-     finite floating-point numbers,
-
-	  floor (log10((1 - b**-p) * b**emax))
-	= floor (log10(1 - b**-p) + log10(b**emax))
-	= floor (log10(1 - b**-p) + log10(b)*emax)
-
-     The safest thing to do here is to just compute this number.  But since
-     we don't link cc1 with libm, we cannot.  We could implement log10 here
-     a series expansion, but that seems too much effort because:
-
-     Note that the first term, for all extant p, is a number exceedingly close
-     to zero, but slightly negative.  Note that the second term is an integer
-     scaling an irrational number, and that because of the floor we are only
-     interested in its integral portion.
-
-     In order for the first term to have any effect on the integral portion
-     of the second term, the second term has to be exceedingly close to an
-     integer itself (e.g. 123.000000000001 or something).  Getting a result
-     that close to an integer requires that the irrational multiplicand have
-     a long series of zeros in its expansion, which doesn't occur in the
-     first 20 digits or so of log10(b).
-
-     Hand-waving aside, crunching all of the sets of constants above by hand
-     does not yield a case for which the first term is significant, which
-     in the end is all that matters.  */
-  max_10_exp = fmt->emax * log10_b;
-  sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
-  builtin_define_with_int_value (name, max_10_exp);
-
-  /* The number of decimal digits, n, such that any floating-point number
-     can be rounded to n decimal digits and back again without change to
-     the value. 
-
-	p * log10(b)			if b is a power of 10
-	ceil(1 + p * log10(b))		otherwise
-
-     The only macro we care about is this number for the widest supported
-     floating type, but we want this value for rendering constants below.  */
-  {
-    double d_decimal_dig = 1 + fmt->p * log10_b;
-    decimal_dig = d_decimal_dig;
-    if (decimal_dig < d_decimal_dig)
-      decimal_dig++;
-  }
-  if (type == long_double_type_node)
-    builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
-
-  /* Since, for the supported formats, B is always a power of 2, we
-     construct the following numbers directly as a hexadecimal
-     constants.  */
-
-  /* The maximum representable finite floating-point number,
-     (1 - b**-p) * b**emax  */
-  {
-    int i, n;
-    char *p;
-
-    strcpy (buf, "0x0.");
-    n = fmt->p * fmt->log2_b;
-    for (i = 0, p = buf + 4; i + 3 < n; i += 4)
-      *p++ = 'f';
-    if (i < n)
-      *p++ = "08ce"[n - i];
-    sprintf (p, "p%d", fmt->emax * fmt->log2_b);
-  }
-  sprintf (name, "__%s_MAX__", name_prefix);
-  builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
-
-  /* The minimum normalized positive floating-point number,
-     b**(emin-1).  */
-  sprintf (name, "__%s_MIN__", name_prefix);
-  sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
-  builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
-
-  /* The difference between 1 and the least value greater than 1 that is
-     representable in the given floating point type, b**(1-p).  */
-  sprintf (name, "__%s_EPSILON__", name_prefix);
-  sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
-  builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
-
-  /* For C++ std::numeric_limits<T>::denorm_min.  The minimum denormalized
-     positive floating-point number, b**(emin-p).  Zero for formats that
-     don't support denormals.  */
-  sprintf (name, "__%s_DENORM_MIN__", name_prefix);
-  if (fmt->has_denorm)
-    {
-      sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
-      builtin_define_with_hex_fp_value (name, type, decimal_dig,
-					buf, fp_suffix);
-    }
-  else
-    {
-      sprintf (buf, "0.0%s", fp_suffix);
-      builtin_define_with_value (name, buf, 0);
-    }
-
-  /* For C++ std::numeric_limits<T>::has_infinity.  */
-  sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
-  builtin_define_with_int_value (name, 
-				 MODE_HAS_INFINITIES (TYPE_MODE (type)));
-  /* For C++ std::numeric_limits<T>::has_quiet_NaN.  We do not have a
-     predicate to distinguish a target that has both quiet and
-     signalling NaNs from a target that has only quiet NaNs or only
-     signalling NaNs, so we assume that a target that has any kind of
-     NaN has quiet NaNs.  */
-  sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
-  builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
-}
-
-/* Hook that registers front end and target-specific built-ins.  */
+/* Built-in macros for stddef.h, that require macros defined in this
+   file.  */
 void
-cb_register_builtins (pfile)
-     cpp_reader *pfile;
+c_stddef_cpp_builtins()
 {
-  /* -undef turns off target-specific built-ins.  */
-  if (flag_undef)
-    return;
-
-  if (c_language == clk_cplusplus)
-    {
-      if (SUPPORTS_ONE_ONLY)
-	cpp_define (pfile, "__GXX_WEAK__=1");
-      else
-	cpp_define (pfile, "__GXX_WEAK__=0");
-      if (flag_exceptions)
-	cpp_define (pfile, "__EXCEPTIONS");
-      if (warn_deprecated)
-	cpp_define (pfile, "__DEPRECATED");
-    }
-
-  /* represents the C++ ABI version, always defined so it can be used while
-     preprocessing C and assembler.  */
-  cpp_define (pfile, "__GXX_ABI_VERSION=102");
-
-  /* libgcc needs to know this.  */
-  if (USING_SJLJ_EXCEPTIONS)
-    cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
-
-  /* stddef.h needs to know these.  */
   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
-
-  /* limits.h needs to know these.  */
-  builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
-  builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
-  builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
-  builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
-  builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
-  builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
-
-  builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
-
-  /* float.h needs to know these.  */
-
-  builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
-				 TARGET_FLT_EVAL_METHOD);
-
-  builtin_define_float_constants ("FLT", "F", float_type_node);
-  builtin_define_float_constants ("DBL", "", double_type_node);
-  builtin_define_float_constants ("LDBL", "L", long_double_type_node);
-
-  /* For use in assembly language.  */
-  builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
-  builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
-
-  /* Misc.  */
-  builtin_define_with_value ("__VERSION__", version_string, 1);
-
-  /* Other target-independent built-ins determined by command-line
-     options.  */
-  if (optimize_size)
-    cpp_define (pfile, "__OPTIMIZE_SIZE__");
-  if (optimize)
-    cpp_define (pfile, "__OPTIMIZE__");
-
-  if (flag_hosted)
-    cpp_define (pfile, "__STDC_HOSTED__=1");
-  else
-    cpp_define (pfile, "__STDC_HOSTED__=0");
-
-  if (fast_math_flags_set_p ())
-    cpp_define (pfile, "__FAST_MATH__");
-  if (flag_really_no_inline)
-    cpp_define (pfile, "__NO_INLINE__");
-  if (flag_signaling_nans)
-    cpp_define (pfile, "__SUPPORT_SNAN__");
-  if (flag_finite_math_only)
-    cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
-  else
-    cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
-
-  if (flag_iso)
-    cpp_define (pfile, "__STRICT_ANSI__");
-
-  if (!flag_signed_char)
-    cpp_define (pfile, "__CHAR_UNSIGNED__");
-
-  if (c_language == clk_cplusplus && TREE_UNSIGNED (wchar_type_node))
-    cpp_define (pfile, "__WCHAR_UNSIGNED__");
-
-  /* Make the choice of ObjC runtime visible to source code.  */
-  if (flag_objc && flag_next_runtime)
-    cpp_define (pfile, "__NEXT_RUNTIME__");
-
-  /* A straightforward target hook doesn't work, because of problems
-     linking that hook's body when part of non-C front ends.  */
-# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
-# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
-# define builtin_define(TXT) cpp_define (pfile, TXT)
-# define builtin_assert(TXT) cpp_assert (pfile, TXT)
-  TARGET_CPU_CPP_BUILTINS ();
-  TARGET_OS_CPP_BUILTINS ();
-}
-
-/* Pass an object-like macro.  If it doesn't lie in the user's
-   namespace, defines it unconditionally.  Otherwise define a version
-   with two leading underscores, and another version with two leading
-   and trailing underscores, and define the original only if an ISO
-   standard was not nominated.
-
-   e.g. passing "unix" defines "__unix", "__unix__" and possibly
-   "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
-   "_mips".  */
-void
-builtin_define_std (macro)
-     const char *macro;
-{
-  size_t len = strlen (macro);
-  char *buff = alloca (len + 5);
-  char *p = buff + 2;
-  char *q = p + len;
-
-  /* prepend __ (or maybe just _) if in user's namespace.  */
-  memcpy (p, macro, len + 1);
-  if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
-    {
-      if (*p != '_')
-	*--p = '_';
-      if (p[1] != '_')
-	*--p = '_';
-    }
-  cpp_define (parse_in, p);
-
-  /* If it was in user's namespace...  */
-  if (p != buff + 2)
-    {
-      /* Define the macro with leading and following __.  */
-      if (q[-1] != '_')
-	*q++ = '_';
-      if (q[-2] != '_')
-	*q++ = '_';
-      *q = '\0';
-      cpp_define (parse_in, p);
-
-      /* Finally, define the original macro if permitted.  */
-      if (!flag_iso)
-	cpp_define (parse_in, macro);
-    }
-}
-
-/* Pass an object-like macro and a value to define it to.  The third
-   parameter says whether or not to turn the value into a string
-   constant.  */
-static void
-builtin_define_with_value (macro, expansion, is_str)
-     const char *macro;
-     const char *expansion;
-     int is_str;
-{
-  char *buf;
-  size_t mlen = strlen (macro);
-  size_t elen = strlen (expansion);
-  size_t extra = 2;  /* space for an = and a NUL */
-
-  if (is_str)
-    extra += 2;  /* space for two quote marks */
-
-  buf = alloca (mlen + elen + extra);
-  if (is_str)
-    sprintf (buf, "%s=\"%s\"", macro, expansion);
-  else
-    sprintf (buf, "%s=%s", macro, expansion);
-
-  cpp_define (parse_in, buf);
-}
-
-/* Pass an object-like macro and an integer value to define it to.  */
-static void
-builtin_define_with_int_value (macro, value)
-     const char *macro;
-     HOST_WIDE_INT value;
-{
-  char *buf;
-  size_t mlen = strlen (macro);
-  size_t vlen = 18;
-  size_t extra = 2; /* space for = and NUL.  */
-
-  buf = alloca (mlen + vlen + extra);
-  memcpy (buf, macro, mlen);
-  buf[mlen] = '=';
-  sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
-
-  cpp_define (parse_in, buf);
-}
-
-/* Pass an object-like macro a hexadecimal floating-point value.  */
-static void
-builtin_define_with_hex_fp_value (macro, type, digits, hex_str, fp_suffix)
-     const char *macro;
-     tree type ATTRIBUTE_UNUSED;
-     int digits;
-     const char *hex_str;
-     const char *fp_suffix;
-{
-  REAL_VALUE_TYPE real;
-  char dec_str[64], buf[256];
-
-  /* Hex values are really cool and convenient, except that they're
-     not supported in strict ISO C90 mode.  First, the "p-" sequence
-     is not valid as part of a preprocessor number.  Second, we get a
-     pedwarn from the preprocessor, which has no context, so we can't
-     suppress the warning with __extension__.
-
-     So instead what we do is construct the number in hex (because 
-     it's easy to get the exact correct value), parse it as a real,
-     then print it back out as decimal.  */
-
-  real_from_string (&real, hex_str);
-  real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
-
-  sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
-  cpp_define (parse_in, buf);
-}
-
-/* Define MAX for TYPE based on the precision of the type.  IS_LONG is
-   1 for type "long" and 2 for "long long".  We have to handle
-   unsigned types, since wchar_t might be unsigned.  */
-
-static void
-builtin_define_type_max (macro, type, is_long)
-     const char *macro;
-     tree type;
-     int is_long;
-{
-  static const char *const values[]
-    = { "127", "255",
-	"32767", "65535",
-	"2147483647", "4294967295",
-	"9223372036854775807", "18446744073709551615",
-	"170141183460469231731687303715884105727",
-	"340282366920938463463374607431768211455" };
-  static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
-
-  const char *value, *suffix;
-  char *buf;
-  size_t idx;
-
-  /* Pre-rendering the values mean we don't have to futz with printing a
-     multi-word decimal value.  There are also a very limited number of
-     precisions that we support, so it's really a waste of time.  */
-  switch (TYPE_PRECISION (type))
-    {
-    case 8:	idx = 0; break;
-    case 16:	idx = 2; break;
-    case 32:	idx = 4; break;
-    case 64:	idx = 6; break;
-    case 128:	idx = 8; break;
-    default:    abort ();
-    }
-
-  value = values[idx + TREE_UNSIGNED (type)];
-  suffix = suffixes[is_long * 2 + TREE_UNSIGNED (type)];
-
-  buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1);
-  sprintf (buf, "%s=%s%s", macro, value, suffix);
-
-  cpp_define (parse_in, buf);
 }
 
 static void
============================================================
Index: gcc/c-common.h
--- gcc/c-common.h	8 Mar 2003 21:12:21 -0000	1.170
+++ gcc/c-common.h	10 Mar 2003 21:54:12 -0000
@@ -1292,6 +1292,9 @@ extern void c_common_read_pch			PARAMS (
 							 int fd,
 							 const char *orig));
 extern void c_common_write_pch			PARAMS ((void));
+extern void builtin_define_with_value		PARAMS ((const char *,
+							 const char *, int));
+extern void c_stddef_cpp_builtins		PARAMS ((void));
 
 /* In c-ppoutput.c  */
 extern void init_pp_output			PARAMS ((FILE *));
============================================================
Index: gcc/c-cppbuiltin.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gcc/c-cppbuiltin.c	10 Mar 2003 21:54:12 -0000
@@ -0,0 +1,570 @@
+/* Define builtin-in macros for the C family front ends.
+   Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+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.
+
+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 GCC; see the file COPYING.  If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "tree.h"
+#include "flags.h"
+#include "real.h"
+#include "c-common.h"
+#include "c-pragma.h"
+#include "output.h"
+#include "except.h"		/* For USING_SJLJ_EXCEPTIONS.  */
+#include "toplev.h"
+
+#ifndef REGISTER_PREFIX
+#define REGISTER_PREFIX ""
+#endif
+
+static void builtin_define_std PARAMS ((const char *));
+static void builtin_define_with_value_n PARAMS ((const char *, const char *,
+						 size_t));
+static void builtin_define_with_int_value PARAMS ((const char *,
+						   HOST_WIDE_INT));
+static void builtin_define_with_hex_fp_value PARAMS ((const char *, tree,
+						      int, const char *,
+						      const char *));
+static void builtin_define_type_max PARAMS ((const char *, tree, int));
+static void builtin_define_type_precision PARAMS ((const char *, tree));
+static void builtin_define_float_constants PARAMS ((const char *,
+						    const char *, tree));
+static void define__GNUC__		PARAMS ((void));
+
+/* Define NAME with value TYPE precision.  */
+static void
+builtin_define_type_precision (name, type)
+     const char *name;
+     tree type;
+{
+  builtin_define_with_int_value (name, TYPE_PRECISION (type));
+}
+
+/* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX.  */
+static void
+builtin_define_float_constants (name_prefix, fp_suffix, type)
+     const char *name_prefix;
+     const char *fp_suffix;
+     tree type;
+{
+  /* Used to convert radix-based values to base 10 values in several cases.
+
+     In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
+     least 6 significant digits for correct results.  Using the fraction
+     formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
+     intermediate; perhaps someone can find a better approximation, in the
+     mean time, I suspect using doubles won't harm the bootstrap here.  */
+
+  const double log10_2 = .30102999566398119521;
+  double log10_b;
+  const struct real_format *fmt;
+
+  char name[64], buf[128];
+  int dig, min_10_exp, max_10_exp;
+  int decimal_dig;
+
+  fmt = real_format_for_mode[TYPE_MODE (type) - QFmode];
+
+  /* The radix of the exponent representation.  */
+  if (type == float_type_node)
+    builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
+  log10_b = log10_2 * fmt->log2_b;
+
+  /* The number of radix digits, p, in the floating-point significand.  */
+  sprintf (name, "__%s_MANT_DIG__", name_prefix);
+  builtin_define_with_int_value (name, fmt->p);
+
+  /* The number of decimal digits, q, such that any floating-point number
+     with q decimal digits can be rounded into a floating-point number with
+     p radix b digits and back again without change to the q decimal digits,
+
+	p log10 b			if b is a power of 10
+ 	floor((p - 1) log10 b)		otherwise
+  */
+  dig = (fmt->p - 1) * log10_b;
+  sprintf (name, "__%s_DIG__", name_prefix);
+  builtin_define_with_int_value (name, dig);
+
+  /* The minimum negative int x such that b**(x-1) is a normalized float.  */
+  sprintf (name, "__%s_MIN_EXP__", name_prefix);
+  sprintf (buf, "(%d)", fmt->emin);
+  builtin_define_with_value (name, buf, 0);
+
+  /* The minimum negative int x such that 10**x is a normalized float,
+
+	  ceil (log10 (b ** (emin - 1)))
+	= ceil (log10 (b) * (emin - 1))
+
+     Recall that emin is negative, so the integer truncation calculates
+     the ceiling, not the floor, in this case.  */
+  min_10_exp = (fmt->emin - 1) * log10_b;
+  sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
+  sprintf (buf, "(%d)", min_10_exp);
+  builtin_define_with_value (name, buf, 0);
+
+  /* The maximum int x such that b**(x-1) is a representable float.  */
+  sprintf (name, "__%s_MAX_EXP__", name_prefix);
+  builtin_define_with_int_value (name, fmt->emax);
+
+  /* The maximum int x such that 10**x is in the range of representable
+     finite floating-point numbers,
+
+	  floor (log10((1 - b**-p) * b**emax))
+	= floor (log10(1 - b**-p) + log10(b**emax))
+	= floor (log10(1 - b**-p) + log10(b)*emax)
+
+     The safest thing to do here is to just compute this number.  But since
+     we don't link cc1 with libm, we cannot.  We could implement log10 here
+     a series expansion, but that seems too much effort because:
+
+     Note that the first term, for all extant p, is a number exceedingly close
+     to zero, but slightly negative.  Note that the second term is an integer
+     scaling an irrational number, and that because of the floor we are only
+     interested in its integral portion.
+
+     In order for the first term to have any effect on the integral portion
+     of the second term, the second term has to be exceedingly close to an
+     integer itself (e.g. 123.000000000001 or something).  Getting a result
+     that close to an integer requires that the irrational multiplicand have
+     a long series of zeros in its expansion, which doesn't occur in the
+     first 20 digits or so of log10(b).
+
+     Hand-waving aside, crunching all of the sets of constants above by hand
+     does not yield a case for which the first term is significant, which
+     in the end is all that matters.  */
+  max_10_exp = fmt->emax * log10_b;
+  sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
+  builtin_define_with_int_value (name, max_10_exp);
+
+  /* The number of decimal digits, n, such that any floating-point number
+     can be rounded to n decimal digits and back again without change to
+     the value. 
+
+	p * log10(b)			if b is a power of 10
+	ceil(1 + p * log10(b))		otherwise
+
+     The only macro we care about is this number for the widest supported
+     floating type, but we want this value for rendering constants below.  */
+  {
+    double d_decimal_dig = 1 + fmt->p * log10_b;
+    decimal_dig = d_decimal_dig;
+    if (decimal_dig < d_decimal_dig)
+      decimal_dig++;
+  }
+  if (type == long_double_type_node)
+    builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
+
+  /* Since, for the supported formats, B is always a power of 2, we
+     construct the following numbers directly as a hexadecimal
+     constants.  */
+
+  /* The maximum representable finite floating-point number,
+     (1 - b**-p) * b**emax  */
+  {
+    int i, n;
+    char *p;
+
+    strcpy (buf, "0x0.");
+    n = fmt->p * fmt->log2_b;
+    for (i = 0, p = buf + 4; i + 3 < n; i += 4)
+      *p++ = 'f';
+    if (i < n)
+      *p++ = "08ce"[n - i];
+    sprintf (p, "p%d", fmt->emax * fmt->log2_b);
+  }
+  sprintf (name, "__%s_MAX__", name_prefix);
+  builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
+
+  /* The minimum normalized positive floating-point number,
+     b**(emin-1).  */
+  sprintf (name, "__%s_MIN__", name_prefix);
+  sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
+  builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
+
+  /* The difference between 1 and the least value greater than 1 that is
+     representable in the given floating point type, b**(1-p).  */
+  sprintf (name, "__%s_EPSILON__", name_prefix);
+  sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
+  builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
+
+  /* For C++ std::numeric_limits<T>::denorm_min.  The minimum denormalized
+     positive floating-point number, b**(emin-p).  Zero for formats that
+     don't support denormals.  */
+  sprintf (name, "__%s_DENORM_MIN__", name_prefix);
+  if (fmt->has_denorm)
+    {
+      sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
+      builtin_define_with_hex_fp_value (name, type, decimal_dig,
+					buf, fp_suffix);
+    }
+  else
+    {
+      sprintf (buf, "0.0%s", fp_suffix);
+      builtin_define_with_value (name, buf, 0);
+    }
+
+  /* For C++ std::numeric_limits<T>::has_infinity.  */
+  sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
+  builtin_define_with_int_value (name, 
+				 MODE_HAS_INFINITIES (TYPE_MODE (type)));
+  /* For C++ std::numeric_limits<T>::has_quiet_NaN.  We do not have a
+     predicate to distinguish a target that has both quiet and
+     signalling NaNs from a target that has only quiet NaNs or only
+     signalling NaNs, so we assume that a target that has any kind of
+     NaN has quiet NaNs.  */
+  sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
+  builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
+}
+
+/* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__.  */
+static void
+define__GNUC__ ()
+{
+  /* The format of the version string, enforced below, is
+     ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?  */
+  const char *q, *v = version_string;
+
+  while (*v && ! ISDIGIT (*v))
+    v++;
+  if (!*v || (v > version_string && v[-1] != '-'))
+    abort ();
+
+  q = v;
+  while (ISDIGIT (*v))
+    v++;
+  builtin_define_with_value_n ("__GNUC__", q, v - q);
+  if (c_language == clk_cplusplus)
+    builtin_define_with_value_n ("__GNUG__", q, v - q);
+
+  if (*v != '.' || !ISDIGIT (v[1]))
+    abort ();
+  q = ++v;
+  while (ISDIGIT (*v))
+    v++;
+  builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);
+
+  if (*v == '.')
+    {
+      if (!ISDIGIT (v[1]))
+	abort ();
+      q = ++v;
+      while (ISDIGIT (*v))
+	v++;
+      builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);
+    }
+  else
+    builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
+
+  if (*v && *v != ' ' && *v != '-')
+    abort ();
+}
+
+/* Hook that registers front end and target-specific built-ins.  */
+void
+cb_register_builtins (pfile)
+     cpp_reader *pfile;
+{
+  /* -undef turns off target-specific built-ins.  */
+  if (flag_undef)
+    return;
+
+  define__GNUC__ ();
+
+  /* For stddef.h.  They require macros defined in c-common.c.  */
+  c_stddef_cpp_builtins ();
+
+  if (c_language == clk_cplusplus)
+    {
+      if (SUPPORTS_ONE_ONLY)
+	cpp_define (pfile, "__GXX_WEAK__=1");
+      else
+	cpp_define (pfile, "__GXX_WEAK__=0");
+      if (flag_exceptions)
+	cpp_define (pfile, "__EXCEPTIONS");
+      if (warn_deprecated)
+	cpp_define (pfile, "__DEPRECATED");
+    }
+
+  /* represents the C++ ABI version, always defined so it can be used while
+     preprocessing C and assembler.  */
+  cpp_define (pfile, "__GXX_ABI_VERSION=102");
+
+  /* libgcc needs to know this.  */
+  if (USING_SJLJ_EXCEPTIONS)
+    cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
+
+  /* limits.h needs to know these.  */
+  builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
+  builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
+  builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
+  builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
+  builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
+  builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
+
+  builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
+
+  /* float.h needs to know these.  */
+
+  builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
+				 TARGET_FLT_EVAL_METHOD);
+
+  builtin_define_float_constants ("FLT", "F", float_type_node);
+  builtin_define_float_constants ("DBL", "", double_type_node);
+  builtin_define_float_constants ("LDBL", "L", long_double_type_node);
+
+  /* For use in assembly language.  */
+  builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
+  builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
+
+  /* Misc.  */
+  builtin_define_with_value ("__VERSION__", version_string, 1);
+
+  /* Other target-independent built-ins determined by command-line
+     options.  */
+  if (optimize_size)
+    cpp_define (pfile, "__OPTIMIZE_SIZE__");
+  if (optimize)
+    cpp_define (pfile, "__OPTIMIZE__");
+
+  if (flag_hosted)
+    cpp_define (pfile, "__STDC_HOSTED__=1");
+  else
+    cpp_define (pfile, "__STDC_HOSTED__=0");
+
+  if (fast_math_flags_set_p ())
+    cpp_define (pfile, "__FAST_MATH__");
+  if (flag_really_no_inline)
+    cpp_define (pfile, "__NO_INLINE__");
+  if (flag_signaling_nans)
+    cpp_define (pfile, "__SUPPORT_SNAN__");
+  if (flag_finite_math_only)
+    cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
+  else
+    cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
+
+  if (flag_iso)
+    cpp_define (pfile, "__STRICT_ANSI__");
+
+  if (!flag_signed_char)
+    cpp_define (pfile, "__CHAR_UNSIGNED__");
+
+  if (c_language == clk_cplusplus && TREE_UNSIGNED (wchar_type_node))
+    cpp_define (pfile, "__WCHAR_UNSIGNED__");
+
+  /* Make the choice of ObjC runtime visible to source code.  */
+  if (flag_objc && flag_next_runtime)
+    cpp_define (pfile, "__NEXT_RUNTIME__");
+
+  /* A straightforward target hook doesn't work, because of problems
+     linking that hook's body when part of non-C front ends.  */
+# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
+# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
+# define builtin_define(TXT) cpp_define (pfile, TXT)
+# define builtin_assert(TXT) cpp_assert (pfile, TXT)
+  TARGET_CPU_CPP_BUILTINS ();
+  TARGET_OS_CPP_BUILTINS ();
+}
+
+/* Pass an object-like macro.  If it doesn't lie in the user's
+   namespace, defines it unconditionally.  Otherwise define a version
+   with two leading underscores, and another version with two leading
+   and trailing underscores, and define the original only if an ISO
+   standard was not nominated.
+
+   e.g. passing "unix" defines "__unix", "__unix__" and possibly
+   "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
+   "_mips".  */
+static void
+builtin_define_std (macro)
+     const char *macro;
+{
+  size_t len = strlen (macro);
+  char *buff = alloca (len + 5);
+  char *p = buff + 2;
+  char *q = p + len;
+
+  /* prepend __ (or maybe just _) if in user's namespace.  */
+  memcpy (p, macro, len + 1);
+  if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
+    {
+      if (*p != '_')
+	*--p = '_';
+      if (p[1] != '_')
+	*--p = '_';
+    }
+  cpp_define (parse_in, p);
+
+  /* If it was in user's namespace...  */
+  if (p != buff + 2)
+    {
+      /* Define the macro with leading and following __.  */
+      if (q[-1] != '_')
+	*q++ = '_';
+      if (q[-2] != '_')
+	*q++ = '_';
+      *q = '\0';
+      cpp_define (parse_in, p);
+
+      /* Finally, define the original macro if permitted.  */
+      if (!flag_iso)
+	cpp_define (parse_in, macro);
+    }
+}
+
+/* Pass an object-like macro and a value to define it to.  The third
+   parameter says whether or not to turn the value into a string
+   constant.  */
+void
+builtin_define_with_value (macro, expansion, is_str)
+     const char *macro;
+     const char *expansion;
+     int is_str;
+{
+  char *buf;
+  size_t mlen = strlen (macro);
+  size_t elen = strlen (expansion);
+  size_t extra = 2;  /* space for an = and a NUL */
+
+  if (is_str)
+    extra += 2;  /* space for two quote marks */
+
+  buf = alloca (mlen + elen + extra);
+  if (is_str)
+    sprintf (buf, "%s=\"%s\"", macro, expansion);
+  else
+    sprintf (buf, "%s=%s", macro, expansion);
+
+  cpp_define (parse_in, buf);
+}
+
+/* Pass an object-like macro and a value to define it to.  The third
+   parameter is the length of the expansion.  */
+static void
+builtin_define_with_value_n (macro, expansion, elen)
+     const char *macro;
+     const char *expansion;
+     size_t elen;
+{
+  char *buf;
+  size_t mlen = strlen (macro);
+  
+  /* Space for an = and a NUL.  */
+  buf = alloca (mlen + elen + 2);
+  memcpy (buf, macro, mlen);
+  buf[mlen]= '=';
+  memcpy (buf + mlen + 1, expansion, elen);
+  buf[mlen + elen + 1] = '\0';
+
+  cpp_define (parse_in, buf);
+}
+
+/* Pass an object-like macro and an integer value to define it to.  */
+static void
+builtin_define_with_int_value (macro, value)
+     const char *macro;
+     HOST_WIDE_INT value;
+{
+  char *buf;
+  size_t mlen = strlen (macro);
+  size_t vlen = 18;
+  size_t extra = 2; /* space for = and NUL.  */
+
+  buf = alloca (mlen + vlen + extra);
+  memcpy (buf, macro, mlen);
+  buf[mlen] = '=';
+  sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
+
+  cpp_define (parse_in, buf);
+}
+
+/* Pass an object-like macro a hexadecimal floating-point value.  */
+static void
+builtin_define_with_hex_fp_value (macro, type, digits, hex_str, fp_suffix)
+     const char *macro;
+     tree type ATTRIBUTE_UNUSED;
+     int digits;
+     const char *hex_str;
+     const char *fp_suffix;
+{
+  REAL_VALUE_TYPE real;
+  char dec_str[64], buf[256];
+
+  /* Hex values are really cool and convenient, except that they're
+     not supported in strict ISO C90 mode.  First, the "p-" sequence
+     is not valid as part of a preprocessor number.  Second, we get a
+     pedwarn from the preprocessor, which has no context, so we can't
+     suppress the warning with __extension__.
+
+     So instead what we do is construct the number in hex (because 
+     it's easy to get the exact correct value), parse it as a real,
+     then print it back out as decimal.  */
+
+  real_from_string (&real, hex_str);
+  real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
+
+  sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
+  cpp_define (parse_in, buf);
+}
+
+/* Define MAX for TYPE based on the precision of the type.  IS_LONG is
+   1 for type "long" and 2 for "long long".  We have to handle
+   unsigned types, since wchar_t might be unsigned.  */
+
+static void
+builtin_define_type_max (macro, type, is_long)
+     const char *macro;
+     tree type;
+     int is_long;
+{
+  static const char *const values[]
+    = { "127", "255",
+	"32767", "65535",
+	"2147483647", "4294967295",
+	"9223372036854775807", "18446744073709551615",
+	"170141183460469231731687303715884105727",
+	"340282366920938463463374607431768211455" };
+  static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
+
+  const char *value, *suffix;
+  char *buf;
+  size_t idx;
+
+  /* Pre-rendering the values mean we don't have to futz with printing a
+     multi-word decimal value.  There are also a very limited number of
+     precisions that we support, so it's really a waste of time.  */
+  switch (TYPE_PRECISION (type))
+    {
+    case 8:	idx = 0; break;
+    case 16:	idx = 2; break;
+    case 32:	idx = 4; break;
+    case 64:	idx = 6; break;
+    case 128:	idx = 8; break;
+    default:    abort ();
+    }
+
+  value = values[idx + TREE_UNSIGNED (type)];
+  suffix = suffixes[is_long * 2 + TREE_UNSIGNED (type)];
+
+  buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1);
+  sprintf (buf, "%s=%s%s", macro, value, suffix);
+
+  cpp_define (parse_in, buf);
+}
============================================================
Index: gcc/cppspec.c
--- gcc/cppspec.c	16 Dec 2002 18:19:19 -0000	1.19
+++ gcc/cppspec.c	10 Mar 2003 21:54:12 -0000
@@ -87,9 +87,6 @@ lang_specific_driver (in_argc, in_argv, 
   /* Do we need to insert -E? */
   int need_E = 1;
 
-  /* Do we need to insert -no-gcc? */
-  int need_no_gcc = 1;
-
   /* Have we seen an input file? */
   int seen_input = 0;
 
@@ -144,8 +141,6 @@ lang_specific_driver (in_argc, in_argv, 
 	    }
 	  else if (argv[i][1] == 'x')
 	    need_fixups = 0;
-	  else if (argv[i][1] == 'g' && !strcmp(&argv[i][2], "cc"))
-	    need_no_gcc = 0;
 	  else if (WORD_SWITCH_TAKES_ARG (&argv[i][1]))
 	    quote = 1;
 	}
@@ -194,7 +189,7 @@ lang_specific_driver (in_argc, in_argv, 
 
   /* If we don't need to edit the command line, we can bail early.  */
 
-  new_argc = argc + need_E + need_no_gcc + read_stdin
+  new_argc = argc + need_E + read_stdin
     + !!o_here + !!lang_c_here + !!lang_S_here;
 
   if (new_argc == argc)
@@ -208,9 +203,6 @@ lang_specific_driver (in_argc, in_argv, 
 
   if (need_E)
     new_argv[j++] = "-E";
-
-  if (need_no_gcc)
-    new_argv[j++] = "-no-gcc";
 
   for (i = 1; i < argc; i++, j++)
     {
============================================================
Index: gcc/gcc.c
--- gcc/gcc.c	9 Mar 2003 21:44:49 -0000	1.368
+++ gcc/gcc.c	10 Mar 2003 21:54:14 -0000
@@ -466,12 +466,6 @@ or with constant text in a single argume
  %X	Output the accumulated linker options specified by compilations.
  %Y	Output the accumulated assembler options specified by compilations.
  %Z	Output the accumulated preprocessor options specified by compilations.
- %v1	Substitute the major version number of GCC.
-	(For version 2.5.3, this is 2.)
- %v2	Substitute the minor version number of GCC.
-	(For version 2.5.3, this is 5.)
- %v3	Substitute the patch level number of GCC.
-	(For version 2.5.3, this is 3.)
  %a     process ASM_SPEC as a spec.
         This allows config.h to specify part of the spec for running as.
  %A	process ASM_FINAL_SPEC as a spec.  A capital A is actually
@@ -740,14 +734,12 @@ static const char *trad_capable_cpp =
    therefore no dependency entry, confuses make into thinking a .o
    file that happens to exist is up-to-date.  */
 static const char *cpp_unique_options =
-"%{C:%{!E:%eGNU C does not support -C without using -E}}\
- %{CC:%{!E:%eGNU C does not support -CC without using -E}}\
+"%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
  %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*} %{P} %I\
  %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
  %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
  %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
  %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
- %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
  %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
  %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
  %{E|M|MM:%W{o*}}";
@@ -5322,63 +5314,6 @@ do_spec_1 (spec, inswitch, soft_matched_
 	      /* Discard the closing paren or bracket.  */
 	      if (*p)
 		p++;
-	    }
-	    break;
-
-	  case 'v':
-	    {
-	      int c1 = *p++;  /* Select first or second version number.  */
-	      const char *v = compiler_version;
-	      const char *q;
-	      static const char zeroc = '0';
-
-	      /* The format of the version string is
-		 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?  */
-
-	      /* Ignore leading non-digits.  i.e. "foo-" in "foo-2.7.2".  */
-	      while (! ISDIGIT (*v))
-		v++;
-	      if (v > compiler_version && v[-1] != '-')
-		abort ();
-
-	      /* If desired, advance to second version number.  */
-	      if (c1 >= '2')
-		{
-		  /* Set V after the first period.  */
-		  while (ISDIGIT (*v))
-		    v++;
-		  if (*v != '.')
-		    abort ();
-		  v++;
-		}
-
-	      /* If desired, advance to third version number.
-                 But don't complain if it's not present */
-	      if (c1 == '3')
-		{
-		  /* Set V after the second period.  */
-		  while (ISDIGIT (*v))
-		    v++;
-		  if ((*v != 0) && (*v != ' ') && (*v != '.') && (*v != '-'))
-		    abort ();
-		  if (*v != 0)
-		    v++;
-		}
-
-	      /* Set Q at the next period or at the end.  */
-	      q = v;
-	      while (ISDIGIT (*q))
-		q++;
-	      if (*q != 0 && q > v && *q != ' ' && *q != '.' && *q != '-')
-		abort ();
-
-	      if (q > v)
-		/* Put that part into the command.  */
-		obstack_grow (&obstack, v, q - v);
-	      else
-		/* Default to "0" */
-		obstack_grow (&obstack, &zeroc, 1);
-	      arg_going = 1;
 	    }
 	    break;
 
============================================================
Index: gcc/cp/Make-lang.in
--- gcc/cp/Make-lang.in	4 Mar 2003 21:32:09 -0000	1.137
+++ gcc/cp/Make-lang.in	10 Mar 2003 21:54:14 -0000
@@ -80,7 +80,7 @@ g++-cross$(exeext): g++$(exeext)
 # Shared with C front end:
 CXX_C_OBJS = attribs.o c-common.o c-format.o c-pragma.o c-semantics.o c-lex.o \
 	c-dump.o $(CXX_TARGET_OBJS) c-pretty-print.o c-opts.o c-pch.o \
-	c-incpath.o cppdefault.o c-ppoutput.o
+	c-incpath.o cppdefault.o c-ppoutput.o c-cppbuiltin.o
 
 # Language-specific object files.
 CXX_OBJS = cp/call.o cp/decl.o cp/expr.o cp/pt.o cp/typeck2.o \
============================================================
Index: gcc/cp/lang-specs.h
--- gcc/cp/lang-specs.h	9 Mar 2003 00:35:22 -0000	1.59
+++ gcc/cp/lang-specs.h	10 Mar 2003 21:54:14 -0000
@@ -36,24 +36,22 @@ Boston, MA 02111-1307, USA.  */
   {".H",   "@c++-header", 0},
   {".hh",  "@c++-header", 0},
   {"@c++-header",
-    "%{E|M|MM:cc1plus -E %{!no-gcc:-D__GNUG__=%v1}\
-       %(cpp_options) %2 %(cpp_debug_options)}\
+    "%{E|M|MM:cc1plus -E %(cpp_options) %2 %(cpp_debug_options)}\
      %{!E:%{!M:%{!MM:\
-       %{save-temps:cc1plus -E %{!no-gcc:-D__GNUG__=%v1}\
+       %{save-temps:cc1plus -E\
 		%(cpp_options) %2 %b.ii \n}\
       cc1plus %{save-temps:-fpreprocessed %b.ii}\
-	      %{!save-temps:%(cpp_unique_options) %{!no-gcc:-D__GNUG__=%v1}}\
+	      %{!save-temps:%(cpp_unique_options)}\
 	%(cc1_options) %2 %{+e1*}\
         -o %g.s %{!o*:--output-pch=%i.gch} %W{o*:--output-pch=%*}%V}}}",
      CPLUSPLUS_CPP_SPEC},
   {"@c++",
-    "%{E|M|MM:cc1plus -E %{!no-gcc:-D__GNUG__=%v1}\
-       %(cpp_options) %2 %(cpp_debug_options)}\
+    "%{E|M|MM:cc1plus -E %(cpp_options) %2 %(cpp_debug_options)}\
      %{!E:%{!M:%{!MM:\
-       %{save-temps|no-integrated-cpp:cc1plus -E %{!no-gcc:-D__GNUG__=%v1}\
+       %{save-temps|no-integrated-cpp:cc1plus -E\
 		%(cpp_options) %2 %{save-temps:%b.ii} %{!save-temps:%g.ii} \n}\
       cc1plus %{save-temps|no-integrated-cpp:-fpreprocessed %{save-temps:%b.ii} %{!save-temps:%g.ii}}\
-	      %{!save-temps:%{!no-integrated-cpp:%(cpp_unique_options) %{!no-gcc:-D__GNUG__=%v1}}}\
+	      %{!save-temps:%{!no-integrated-cpp:%(cpp_unique_options)}}\
 	%(cc1_options) %2 %{+e1*}\
        %{!fsyntax-only:%(invoke_as)}}}}",
      CPLUSPLUS_CPP_SPEC},
============================================================
Index: gcc/doc/invoke.texi
--- gcc/doc/invoke.texi	5 Mar 2003 01:33:26 -0000	1.253
+++ gcc/doc/invoke.texi	10 Mar 2003 21:54:18 -0000
@@ -5305,18 +5305,6 @@ Output the accumulated assembler options
 @item %Z
 Output the accumulated preprocessor options specified by @option{-Wp}.
 
-@item %v1
-Substitute the major version number of GCC@.
-(For version 2.9.5, this is 2.)
-
-@item %v2
-Substitute the minor version number of GCC@.
-(For version 2.9.5, this is 9.)
-
-@item %v3
-Substitute the patch level number of GCC@.
-(For version 2.9.5, this is 5.)
-
 @item %a
 Process the @code{asm} spec.  This is used to compute the
 switches to be passed to the assembler.
============================================================
Index: gcc/doc/passes.texi
--- gcc/doc/passes.texi	4 Mar 2003 07:00:39 -0000	1.22
+++ gcc/doc/passes.texi	10 Mar 2003 21:54:18 -0000
@@ -84,6 +84,7 @@ the other C-like languages: @file{c-comm
 @file{c-lex.c},
 @file{c-incpath.c},
 @file{c-ppoutput.c},
+@file{c-cppbuiltin.c},
 @file{c-common.h},
 @file{c-dump.h},
 @file{c-incpath.h}
============================================================
Index: gcc/doc/tm.texi
--- gcc/doc/tm.texi	5 Mar 2003 22:37:52 -0000	1.206
+++ gcc/doc/tm.texi	10 Mar 2003 21:54:23 -0000
@@ -619,7 +619,7 @@ Here are run-time target specifications.
 This function-like macro expands to a block of code that defines
 built-in preprocessor macros and assertions for the target cpu, using
 the functions @code{builtin_define}, @code{builtin_define_std} and
-@code{builtin_assert} defined in @file{c-common.c}.  When the front end
+@code{builtin_assert}.  When the front end
 calls this macro it provides a trailing semicolon, and since it has
 finished command line option processing your code can use those
 results freely.

Re: RFA: Move definition of __GNUC__ etc. to front-end

[Zack Weinberg]

Neil Booth <neil@daikokuya.co.uk> writes:

> This moves the definition of __GNUC__, __GNUG__, __GNUC_MINOR__
> and __GNUC_PATCHLEVEL__ to the front end, to join most other
> macro definitions.
>
> Further to discussions with Zack, we couldn't see a good reason
> for cpp to not give the preprocessed output that GCC sees, so
> I define these unconditionally.  We also didn't think that there
> was good reason to continue having -no-gcc, so I removed that too.
>
> I took the opportunity to remove the growing body of CPP builtin
> code in c-common.c into a new file.  4 builtins (for stddef.h)
> had to remain in c-common.c, as they use macros defined therein,
> and working round that was uglier than leaving them in c-common.c.
>
> Bootstrapping x86 Linux.  OK to commit if there are no regressions?

Since I was in on the design discussion, I should not review it.
Could one of the C front end maintainers or other global write
privileges people please look at this?

zw

Re: RFA: Move definition of __GNUC__ etc. to front-end

[Geoff Keating]

Neil Booth <neil@daikokuya.co.uk> writes:

> This moves the definition of __GNUC__, __GNUG__, __GNUC_MINOR__
> and __GNUC_PATCHLEVEL__ to the front end, to join most other
> macro definitions.
> 
> Further to discussions with Zack, we couldn't see a good reason
> for cpp to not give the preprocessed output that GCC sees, so
> I define these unconditionally.  We also didn't think that there
> was good reason to continue having -no-gcc, so I removed that too.
> 
> I took the opportunity to remove the growing body of CPP builtin
> code in c-common.c into a new file.  4 builtins (for stddef.h)
> had to remain in c-common.c, as they use macros defined therein,
> and working round that was uglier than leaving them in c-common.c.
> 
> Bootstrapping x86 Linux.  OK to commit if there are no regressions?

This is OK, assuming that you can still do

gcc -U__GNUC__ t.c ...

There are rare cases when you really do want to suppress __GNUC__, for
instance some old versions of SPEC.

-- 
- Geoffrey Keating <geoffk@geoffk.org>

Re: RFA: Move definition of __GNUC__ etc. to front-end

[Neil Booth]

Geoff Keating wrote:-

> This is OK, assuming that you can still do
> 
> gcc -U__GNUC__ t.c ...
> 
> There are rare cases when you really do want to suppress __GNUC__, for
> instance some old versions of SPEC.

Indeed you can:

$ ./cc1 -E -dM -quiet /dev/null | grep GNU
#define __GNUC_PATCHLEVEL__ 0
#define __GNUC__ 3
#define __GNUC_MINOR__ 4
$ ./cc1 -E -dM -quiet -U __GNUC__ /dev/null | grep GNU
#define __GNUC_PATCHLEVEL__ 0
#define __GNUC_MINOR__ 4
$ 

Thanks Geoff.

Neil.