builtins.def: Encode additional information, such as names and types, here.

	* builtins.def: Encode additional information, such as names and
	types, here.
	* builtin-types.def: New file.
	* builtins.c (built_in_names): Adjust use of DEF_BUILTIN.
	(built_in_decls): Likewise.  Don't explicitly initialize global
	data to NULL.
	(expand_builtin_mathfn): Handle float and long double variants of
	math builtins.
	(expand_builtin): Likewise.
	* c-common.c (c_common_nodes_and_builtins): Make it table-driven.
	(expand_tree_builtin): Handle long, long long, float, and long
	double variants of math functions.
	* c-common.h (c_tree_index): Remove some unused nodes.
	(void_ftype): Remove.
	(void_type_ptr): Likewise.
	(int_ftype_int): Likewise.
	(ptr_ftype_sizetype): Likewise.
	* c-decl.c (init_decl_processing): Remove creation of DWARF
	builtins.
	* defaults.h (MD_INIT_BUILTINS): Provide default definition.
	* tree.h (built_in_function): Adjust definition of DEF_BUILTIN.
	* Makefile.in (c-common.o): Depend on builtin-types.def.

	* decl.c (init_decl_processing): Tweak.

From-SVN: r42583

gcc/ChangeLog

+2001-05-26  Mark  <mark@codesourcery.com>
+
+	* builtins.def: Encode additional information, such as names and
+	types, here.
+	* builtin-types.def: New file.
+	* builtins.c (built_in_names): Adjust use of DEF_BUILTIN.
+	(built_in_decls): Likewise.  Don't explicitly initialize global
+	data to NULL.
+	(expand_builtin_mathfn): Handle float and long double variants of
+	math builtins.
+	(expand_builtin): Likewise.
+	* c-common.c (c_common_nodes_and_builtins): Make it table-driven.
+	(expand_tree_builtin): Handle long, long long, float, and long
+	double variants of math functions.
+	* c-common.h (c_tree_index): Remove some unused nodes.
+	(void_ftype): Remove.
+	(void_type_ptr): Likewise.
+	(int_ftype_int): Likewise.
+	(ptr_ftype_sizetype): Likewise.
+	* c-decl.c (init_decl_processing): Remove creation of DWARF
+	builtins.
+	* defaults.h (MD_INIT_BUILTINS): Provide default definition.
+	* tree.h (built_in_function): Adjust definition of DEF_BUILTIN.
+	* Makefile.in (c-common.o): Depend on builtin-types.def.
+	
 2001-05-25  Dale Johannesen  <dalej@apple.com>
 
 	* config/rs6000/t-darwin: Fix dependencies for darwin.o.

gcc/Makefile.in

@@ -1227,7 +1227,7 @@ s-under: $(GCC_PASSES)
 
 c-common.o : c-common.c $(CONFIG_H) $(SYSTEM_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)
+	$(EXPR_H) $(TM_P_H) builtin-types.def
 
 c-format.o : c-format.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) \
 	$(C_COMMON_H) flags.h toplev.h intl.h diagnostic.h

gcc/builtin-types.def

+/* Copyright (C) 2001 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+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.
+
+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.
+
+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.  */
+
+/* This header provides a declaritive way of describing the types that
+   are used when declaring builtin functions.
+
+   Before including this header, you must define the following macros:
+
+   DEF_PRIMITIVE_TYPE (ENUM, TYPE)
+
+     The ENUM is an identifier indicating which type is being defined.
+     TYPE is an expression for a `tree' that represents the type.
+
+   DEF_FUNCTION_TYPE_0 (ENUM, RETURN)
+   DEF_FUNCTION_TYPE_1 (ENUM, RETURN, ARG1)
+   DEF_FUNCTION_TYPE_2 (ENUM, RETURN, ARG1, ARG2)
+   DEF_FUNCTION_TYPE_3 (ENUM, RETURN, ARG1, ARG2, ARG3)
+   DEF_FUNCTION_TYPE_4 (ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)
+
+     These macros describe function types.  ENUM is as above.  The
+     RETURN type is one of the enumerals already defined.  ARG1, ARG2,
+     and ARG3 give the types of the arguments, similarly.
+
+   DEF_FUNCTION_TYPE_VAR_0 (ENUM, RETURN)
+   DEF_FUNCTION_TYPE_VAR_1 (ENUM, RETURN, ARG1)
+   DEF_FUNCTION_TYPE_VAR_2 (ENUM, RETURN, ARG1, ARG2)
+
+     Similar, but for function types that take variable arguments.
+     For example:
+
+       DEF_FUNCTION_TYPE_1 (BT_INT_DOUBLE, BT_INT, BT_DOUBLE)
+
+     describes the type `int ()(double)', using the enumeral
+     BT_INT_DOUBLE, whereas:
+
+       DEF_FUNCTION_TYPE_VAR_1 (BT_INT_DOUBLE_VAR, BT_INT, BT_DOUBLE)
+
+     describes the type `int ()(double, ...)'.
+ 
+  DEF_POINTER_TYPE (ENUM, TYPE)
+
+    This macro describes a pointer type.  ENUM is as above; TYPE is
+    the type pointed to.  */
+
+DEF_PRIMITIVE_TYPE (BT_VOID, void_type_node)
+DEF_PRIMITIVE_TYPE (BT_INT, integer_type_node)
+DEF_PRIMITIVE_TYPE (BT_UNSIGNED, unsigned_type_node)
+DEF_PRIMITIVE_TYPE (BT_LONG, long_integer_type_node)
+DEF_PRIMITIVE_TYPE (BT_LONGLONG, long_long_integer_type_node)
+DEF_PRIMITIVE_TYPE (BT_FLOAT, float_type_node)
+DEF_PRIMITIVE_TYPE (BT_INTMAX, intmax_type_node)
+DEF_PRIMITIVE_TYPE (BT_DOUBLE, double_type_node)
+DEF_PRIMITIVE_TYPE (BT_LONG_DOUBLE, long_double_type_node)
+DEF_PRIMITIVE_TYPE (BT_COMPLEX_FLOAT, complex_float_type_node)
+DEF_PRIMITIVE_TYPE (BT_COMPLEX_DOUBLE, complex_double_type_node)
+DEF_PRIMITIVE_TYPE (BT_COMPLEX_LONG_DOUBLE, complex_long_double_type_node)
+
+DEF_PRIMITIVE_TYPE (BT_PTR, ptr_type_node)
+DEF_PRIMITIVE_TYPE (BT_CONST_PTR, const_ptr_type_node)
+DEF_PRIMITIVE_TYPE (BT_TRAD_PTR, traditional_ptr_type_node)
+DEF_PRIMITIVE_TYPE (BT_TRAD_CONST_PTR, traditional_cptr_type_node)
+DEF_PRIMITIVE_TYPE (BT_PTRMODE, type_for_mode (ptr_mode, 0))
+DEF_PRIMITIVE_TYPE (BT_SIZE, c_size_type_node)
+DEF_PRIMITIVE_TYPE (BT_STRING, string_type_node)
+DEF_PRIMITIVE_TYPE (BT_CONST_STRING, const_string_type_node)
+DEF_PRIMITIVE_TYPE (BT_LEN, traditional_len_type_node)
+
+DEF_PRIMITIVE_TYPE (BT_VALIST_REF, va_list_ref_type_node)
+DEF_PRIMITIVE_TYPE (BT_VALIST_ARG, va_list_arg_type_node)
+
+DEF_FUNCTION_TYPE_0 (BT_FN_VOID, BT_VOID)
+DEF_FUNCTION_TYPE_0 (BT_FN_PTR, BT_PTR)
+DEF_FUNCTION_TYPE_0 (BT_FN_UNSIGNED, BT_UNSIGNED)
+
+DEF_FUNCTION_TYPE_1 (BT_FN_LONG_LONG, BT_LONG, BT_LONG)
+DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_LONGLONG, BT_LONGLONG, BT_LONGLONG)
+DEF_FUNCTION_TYPE_1 (BT_FN_INTMAX_INTMAX, BT_INTMAX, BT_INTMAX)
+DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT_FLOAT, BT_FLOAT, BT_FLOAT)
+DEF_FUNCTION_TYPE_1 (BT_FN_DOUBLE_DOUBLE, BT_DOUBLE, BT_DOUBLE)
+DEF_FUNCTION_TYPE_1 (BT_FN_LONG_DOUBLE_LONG_DOUBLE, 
+	             BT_LONG_DOUBLE, BT_LONG_DOUBLE)
+DEF_FUNCTION_TYPE_1 (BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, 
+		     BT_COMPLEX_FLOAT, BT_COMPLEX_FLOAT)
+DEF_FUNCTION_TYPE_1 (BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, 
+		     BT_COMPLEX_DOUBLE, BT_COMPLEX_DOUBLE)
+DEF_FUNCTION_TYPE_1 (BT_FN_COMPLEX_LONG_DOUBLE_COMPLEX_LONG_DOUBLE, 
+	             BT_COMPLEX_LONG_DOUBLE, BT_COMPLEX_LONG_DOUBLE)
+DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT_COMPLEX_FLOAT, 
+                     BT_FLOAT, BT_COMPLEX_FLOAT)
+DEF_FUNCTION_TYPE_1 (BT_FN_DOUBLE_COMPLEX_DOUBLE,
+                     BT_DOUBLE, BT_COMPLEX_DOUBLE)
+DEF_FUNCTION_TYPE_1 (BT_FN_LONG_DOUBLE_COMPLEX_LONG_DOUBLE,
+                     BT_LONG_DOUBLE, BT_COMPLEX_LONG_DOUBLE)
+DEF_FUNCTION_TYPE_1 (BT_FN_PTR_UNSIGNED, BT_PTR, BT_UNSIGNED)
+DEF_FUNCTION_TYPE_1 (BT_FN_PTR_SIZE, BT_PTR, BT_SIZE)
+DEF_FUNCTION_TYPE_1 (BT_FN_INT_INT, BT_INT, BT_INT)
+DEF_FUNCTION_TYPE_1 (BT_FN_INT_PTR, BT_INT, BT_PTR)
+DEF_FUNCTION_TYPE_1 (BT_FN_VOID_PTR, BT_VOID, BT_PTR)
+DEF_FUNCTION_TYPE_1 (BT_FN_LEN_CONST_STRING, BT_LEN, BT_CONST_STRING)
+DEF_FUNCTION_TYPE_1 (BT_FN_INT_CONST_STRING, BT_INT, BT_CONST_STRING)
+DEF_FUNCTION_TYPE_1 (BT_FN_PTR_PTR, BT_PTR, BT_PTR)
+DEF_FUNCTION_TYPE_1 (BT_FN_VOID_VALIST_REF, BT_VOID, BT_VALIST_REF)
+DEF_FUNCTION_TYPE_1 (BT_FN_VOID_INT, BT_VOID, BT_INT)
+
+DEF_FUNCTION_TYPE_2 (BT_FN_VOID_PTR_INT, BT_VOID, BT_PTR, BT_INT)
+DEF_FUNCTION_TYPE_2 (BT_FN_STRING_STRING_CONST_STRING, 
+                     BT_STRING, BT_STRING, BT_CONST_STRING)
+DEF_FUNCTION_TYPE_2 (BT_FN_INT_CONST_STRING_CONST_STRING,
+	             BT_INT, BT_CONST_STRING, BT_CONST_STRING)
+DEF_FUNCTION_TYPE_2 (BT_FN_STRING_CONST_STRING_CONST_STRING,
+		     BT_STRING, BT_CONST_STRING, BT_CONST_STRING)
+DEF_FUNCTION_TYPE_2 (BT_FN_SIZE_CONST_STRING_CONST_STRING,
+	             BT_SIZE, BT_CONST_STRING, BT_CONST_STRING)
+DEF_FUNCTION_TYPE_2 (BT_FN_STRING_CONST_STRING_INT,
+	             BT_STRING, BT_CONST_STRING, BT_INT)
+DEF_FUNCTION_TYPE_2 (BT_FN_INT_CONST_STRING_PTR,
+		     BT_INT, BT_CONST_STRING, BT_PTR)
+DEF_FUNCTION_TYPE_2 (BT_FN_INT_INT_PTR,
+		     BT_INT, BT_INT, BT_PTR)
+DEF_FUNCTION_TYPE_2 (BT_FN_VOID_PTRMODE_PTR,
+		     BT_VOID, BT_PTRMODE, BT_PTR)
+DEF_FUNCTION_TYPE_2 (BT_FN_VOID_VALIST_REF_VALIST_ARG, 
+		     BT_VOID, BT_VALIST_REF, BT_VALIST_ARG)
+DEF_FUNCTION_TYPE_2 (BT_FN_LONG_LONG_LONG,
+		     BT_LONG, BT_LONG, BT_LONG)
+DEF_FUNCTION_TYPE_2 (BT_FN_INT_PTR_CONST_STRING,
+		     BT_INT, BT_PTR, BT_CONST_STRING)
+DEF_FUNCTION_TYPE_2 (BT_FN_VOID_TRAD_PTR_LEN,
+		     BT_VOID, BT_TRAD_PTR, BT_LEN)
+
+DEF_FUNCTION_TYPE_3 (BT_FN_STRING_STRING_CONST_STRING_SIZE,
+		     BT_STRING, BT_STRING, BT_CONST_STRING, BT_SIZE)
+DEF_FUNCTION_TYPE_3 (BT_FN_INT_CONST_STRING_CONST_STRING_SIZE,
+		     BT_INT, BT_CONST_STRING, BT_CONST_STRING, BT_SIZE)
+DEF_FUNCTION_TYPE_3 (BT_FN_TRAD_PTR_PTR_CONST_PTR_SIZE,
+		     BT_TRAD_PTR, BT_PTR, BT_CONST_PTR, BT_SIZE)
+DEF_FUNCTION_TYPE_3 (BT_FN_INT_CONST_PTR_CONST_PTR_SIZE,
+	             BT_INT, BT_CONST_PTR, BT_CONST_PTR, BT_SIZE)
+DEF_FUNCTION_TYPE_3 (BT_FN_TRAD_PTR_PTR_INT_SIZE,
+	             BT_TRAD_PTR, BT_PTR, BT_INT, BT_SIZE)
+DEF_FUNCTION_TYPE_3 (BT_FN_INT_TRAD_CONST_PTR_TRAD_CONST_PTR_LEN,
+		     BT_INT, BT_TRAD_CONST_PTR, BT_TRAD_CONST_PTR, BT_LEN)
+
+DEF_FUNCTION_TYPE_4 (BT_FN_SIZE_CONST_PTR_SIZE_SIZE_PTR,
+		     BT_SIZE, BT_CONST_PTR, BT_SIZE, BT_SIZE, BT_PTR)
+
+DEF_FUNCTION_TYPE_VAR_0 (BT_FN_VOID_VAR, BT_VOID)
+DEF_FUNCTION_TYPE_VAR_0 (BT_FN_INT_VAR, BT_INT)
+DEF_FUNCTION_TYPE_VAR_0 (BT_FN_PTR_VAR, BT_PTR)
+
+DEF_FUNCTION_TYPE_VAR_1 (BT_FN_VOID_VALIST_REF_VAR, 
+			 BT_VOID, BT_VALIST_REF)
+DEF_FUNCTION_TYPE_VAR_1 (BT_FN_INT_CONST_STRING_VAR,
+	                 BT_INT, BT_CONST_STRING)
+
+DEF_FUNCTION_TYPE_VAR_2 (BT_FN_INT_PTR_CONST_STRING_VAR,
+	                 BT_INT, BT_PTR, BT_CONST_STRING)
+
+DEF_POINTER_TYPE (BT_PTR_FN_VOID_VAR, BT_FN_VOID_VAR)
+DEF_FUNCTION_TYPE_3 (BT_FN_PTR_PTR_FN_VOID_VAR_PTR_SIZE,
+		     BT_PTR, BT_PTR_FN_VOID_VAR, BT_PTR, BT_SIZE)

gcc/builtins.c

@@ -57,7 +57,7 @@ Boston, MA 02111-1307, USA.  */
 const char *const built_in_class_names[4]
   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
 
-#define DEF_BUILTIN(x) STRINGX(x),
+#define DEF_BUILTIN(X, N, C, T, LT, B, F, NA) STRINGX(X),
 const char *const built_in_names[(int) END_BUILTINS] =
 {
 #include "builtins.def"
@@ -66,12 +66,7 @@ const char *const built_in_names[(int) END_BUILTINS] =
 
 /* Setup an array of _DECL trees, make sure each element is
    initialized to NULL_TREE.  */
-#define DEF_BUILTIN(x) NULL_TREE,
-tree built_in_decls[(int) END_BUILTINS] =
-{
-#include "builtins.def"
-};
-#undef DEF_BUILTIN
+tree built_in_decls[(int) END_BUILTINS];
 
 tree (*lang_type_promotes_to) PARAMS ((tree));
 
@@ -1409,11 +1404,17 @@ expand_builtin_mathfn (exp, target, subtarget)
 
   switch (DECL_FUNCTION_CODE (fndecl))
     {
-     case BUILT_IN_SIN:
+    case BUILT_IN_SIN:
+    case BUILT_IN_SINF:
+    case BUILT_IN_SINL:
       builtin_optab = sin_optab; break;
-     case BUILT_IN_COS:
+    case BUILT_IN_COS:
+    case BUILT_IN_COSF:
+    case BUILT_IN_COSL:
       builtin_optab = cos_optab; break;
-     case BUILT_IN_FSQRT:
+    case BUILT_IN_FSQRT:
+    case BUILT_IN_SQRTF:
+    case BUILT_IN_SQRTL:
       builtin_optab = sqrt_optab; break;
      default:
       abort ();
@@ -3300,7 +3301,8 @@ expand_builtin (exp, target, subtarget, mode, ignore)
      set of builtins.  */
   if (! optimize && ! CALLED_AS_BUILT_IN (fndecl)
       && (fcode == BUILT_IN_SIN || fcode == BUILT_IN_COS
-	  || fcode == BUILT_IN_FSQRT || fcode == BUILT_IN_MEMSET
+	  || fcode == BUILT_IN_FSQRT || fcode == BUILT_IN_SQRTF
+	  || fcode == BUILT_IN_SQRTL || fcode == BUILT_IN_MEMSET
 	  || fcode == BUILT_IN_MEMCPY || fcode == BUILT_IN_MEMCMP
 	  || fcode == BUILT_IN_BCMP || fcode == BUILT_IN_BZERO
 	  || fcode == BUILT_IN_INDEX || fcode == BUILT_IN_RINDEX
@@ -3319,24 +3321,41 @@ expand_builtin (exp, target, subtarget, mode, ignore)
   switch (fcode)
     {
     case BUILT_IN_ABS:
+    case BUILT_IN_LABS:
+    case BUILT_IN_LLABS:
+    case BUILT_IN_IMAXABS:
     case BUILT_IN_FABS:
+    case BUILT_IN_FABSF:
+    case BUILT_IN_FABSL:
       /* build_function_call changes these into ABS_EXPR.  */
       abort ();
 
     case BUILT_IN_CONJ:
+    case BUILT_IN_CONJF:
+    case BUILT_IN_CONJL:
     case BUILT_IN_CREAL:
+    case BUILT_IN_CREALF:
+    case BUILT_IN_CREALL:
     case BUILT_IN_CIMAG:
+    case BUILT_IN_CIMAGF:
+    case BUILT_IN_CIMAGL:
       /* expand_tree_builtin changes these into CONJ_EXPR, REALPART_EXPR
 	 and IMAGPART_EXPR.  */
       abort ();
 
     case BUILT_IN_SIN:
+    case BUILT_IN_SINF:
+    case BUILT_IN_SINL:
     case BUILT_IN_COS:
+    case BUILT_IN_COSF:
+    case BUILT_IN_COSL:
       /* Treat these like sqrt only if unsafe math optimizations are allowed,
 	 because of possible accuracy problems.  */
       if (! flag_unsafe_math_optimizations)
 	break;
     case BUILT_IN_FSQRT:
+    case BUILT_IN_SQRTF:
+    case BUILT_IN_SQRTL:
       target = expand_builtin_mathfn (exp, target, subtarget);
       if (target)
 	return target;

gcc/c-common.h

@@ -148,11 +148,6 @@ enum c_tree_index
     CTI_C_BOOL_FALSE,
     CTI_DEFAULT_FUNCTION_TYPE,
 
-    CTI_VOID_FTYPE,
-    CTI_VOID_FTYPE_PTR,
-    CTI_INT_FTYPE_INT,
-    CTI_PTR_FTYPE_SIZETYPE,
-
     CTI_G77_INTEGER_TYPE,
     CTI_G77_UINTEGER_TYPE,
     CTI_G77_LONGINT_TYPE,
@@ -207,10 +202,6 @@ struct c_common_identifier
 #define const_string_type_node		c_global_trees[CTI_CONST_STRING_TYPE]
 
 #define default_function_type		c_global_trees[CTI_DEFAULT_FUNCTION_TYPE]
-#define void_ftype			c_global_trees[CTI_VOID_FTYPE]
-#define void_ftype_ptr			c_global_trees[CTI_VOID_FTYPE_PTR]
-#define int_ftype_int			c_global_trees[CTI_INT_FTYPE_INT]
-#define ptr_ftype_sizetype		c_global_trees[CTI_PTR_FTYPE_SIZETYPE]
 
 /* g77 integer types, which which must be kept in sync with f/com.h */
 #define g77_integer_type_node		c_global_trees[CTI_G77_INTEGER_TYPE]

gcc/c-decl.c

@@ -3056,36 +3056,6 @@ init_decl_processing ()
 			    g77_ulongint_type_node));
     }
 
-  builtin_function ("__builtin_aggregate_incoming_address",
-		    build_function_type (ptr_type_node, NULL_TREE),
-		    BUILT_IN_AGGREGATE_INCOMING_ADDRESS,
-		    BUILT_IN_NORMAL, NULL);
-
-  /* Hooks for the DWARF 2 __throw routine.  */
-  builtin_function ("__builtin_unwind_init",
-		    build_function_type (void_type_node, endlink),
-		    BUILT_IN_UNWIND_INIT, BUILT_IN_NORMAL, NULL);
-  builtin_function ("__builtin_dwarf_cfa", ptr_ftype_void,
-		    BUILT_IN_DWARF_CFA, BUILT_IN_NORMAL, NULL);
-  builtin_function ("__builtin_dwarf_fp_regnum",
-		    build_function_type (unsigned_type_node, endlink),
-		    BUILT_IN_DWARF_FP_REGNUM, BUILT_IN_NORMAL, NULL);
-  builtin_function ("__builtin_init_dwarf_reg_size_table", void_ftype_ptr,
-		    BUILT_IN_INIT_DWARF_REG_SIZES, BUILT_IN_NORMAL, NULL);
-  builtin_function ("__builtin_frob_return_addr", ptr_ftype_ptr,
-		    BUILT_IN_FROB_RETURN_ADDR, BUILT_IN_NORMAL, NULL);
-  builtin_function ("__builtin_extract_return_addr", ptr_ftype_ptr,
-		    BUILT_IN_EXTRACT_RETURN_ADDR, BUILT_IN_NORMAL, NULL);
-  builtin_function
-    ("__builtin_eh_return",
-     build_function_type (void_type_node,
-			  tree_cons (NULL_TREE,
-				     type_for_mode (ptr_mode, 0),
-				     tree_cons (NULL_TREE,
-						ptr_type_node,
-						endlink))),
-     BUILT_IN_EH_RETURN, BUILT_IN_NORMAL, NULL);
-
   pedantic_lvalues = pedantic;
 
   make_fname_decl = c_make_fname_decl;

gcc/cp/ChangeLog

+2001-05-26  Mark Mitchell <mark@codesourcery.com>
+
+	* decl.c (init_decl_processing): Tweak.
+
 2001-05-24  Mark Mitchell  <mark@codesourcery.com>
 
 	* decl.c (duplicate_decls): Tidy.

gcc/cp/decl.c

@@ -6325,6 +6325,8 @@ void
 init_decl_processing ()
 {
   tree fields[20];
+  tree void_ftype;
+  tree void_ftype_ptr;
 
   /* Check to see that the user did not specify an invalid combination
      of command-line options.  */
@@ -6452,6 +6454,11 @@ init_decl_processing ()
   vtt_parm_type = build_pointer_type (const_ptr_type_node);
   lang_type_promotes_to = convert_type_from_ellipsis;
 
+  void_ftype = build_function_type (void_type_node, void_list_node);
+  void_ftype_ptr = build_function_type (void_type_node,
+					tree_cons (NULL_TREE,
+						   ptr_type_node, 
+						   void_list_node));
   void_ftype_ptr
     = build_exception_variant (void_ftype_ptr, empty_except_spec);
 
@@ -6528,13 +6535,19 @@ init_decl_processing ()
 
   {
     tree bad_alloc_type_node, newtype, deltype;
-    
+    tree ptr_ftype_sizetype;
+
     if (flag_honor_std)
       push_namespace (std_identifier);
     bad_alloc_type_node = xref_tag
       (class_type_node, get_identifier ("bad_alloc"), 1);
     if (flag_honor_std)
       pop_namespace ();
+    ptr_ftype_sizetype 
+      = build_function_type (ptr_type_node,
+			     tree_cons (NULL_TREE,
+					c_size_type_node,
+					void_list_node));
     newtype = build_exception_variant
       (ptr_ftype_sizetype, add_exception_specifier
        (NULL_TREE, bad_alloc_type_node, -1));

gcc/defaults.h

@@ -343,5 +343,13 @@ do {								\
 #define TARGET_ALLOWS_PROFILING_WITHOUT_FRAME_POINTER true
 #endif
 
+/* Define this macro if you have any machine-specific builtin
+   functions that need to be defined.  It should be a C expression
+   that performs the necessary setup. */
+
+#ifndef MD_INIT_BUILTINS
+#define MD_INIT_BUILTINS
+#endif
+
 #endif  /* GCC_DEFAULTS_H */
 

gcc/tree.h

@@ -84,7 +84,7 @@ extern const char *const built_in_class_names[4];
 /* Codes that identify the various built in functions
    so that expand_call can identify them quickly.  */
 
-#define DEF_BUILTIN(x) x,
+#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA) ENUM,
 enum built_in_function
 {
 #include "builtins.def"