Makefile.in (C_AND_OBJC_OBJS): Add c-dump.o.

	* Makefile.in (C_AND_OBJC_OBJS): Add c-dump.o.
	(c-dump.o): New target.
	* c-common.h (flag_dump_translation_unit): New variable.
	(C_TYPE_QUALS): New macro.
	(strip_array_types): New function.
	(DECL_C_BIT_FIELD): New macro.
	(SET_DECL_C_BIT_FIELD): Likewise.
	(CLEAR_DECL_C_BIT_FIELD): Likewise.
	(dump_info_p): New typedef.
	(dump_tree_fn): Likewise.
	(lang_dump_tree): New variable.
	(dump_node_to_file): New function.
	* c-common.c (flag_dump_translation_unit): Define it.
	(strip_array_types): New function.
	* c-decl.c (c_decode_option): Handle -fdump-translation-unit.
	* c-lang.c (finish_file): Call dump_node_to_file if
	flag_dump_translation_unit.
	* c-semantics.c (mark_rtl_for_local_static): Fix typo in comment.
	* c-tree.h (DECL_C_BIT_FIELD): Remove declaration.
	* c-dump.c: New file.

	* Make-lang.in (CXX_C_OBJS): Add c-dump.o.
	(dump.o): Update dependency list.
	* cp-tree.h (DECL_MAYBE_TEMPLATE): Remove.
	(flag_dump_translation_unit): Likewise.
	(CP_TYPE_QUALS): Adjust definition.
	(DECL_C_BIT_FIELD): Remove.
	(SET_DECL_C_BIT_FIELD): Likewise.
	(CLEAR_DECL_C_BIT_FIELD): Likewise.
	(add_maybe_template): Likewise.
	(strip_array_types): Likewise.
	(dump_node_to_file): Likewise.
	(cp_dump_tree): New function.
	* decl.c (init_decl_processing): Set lang_dump_tree.
	* decl2.c (flag_dump_translation_unit): Remove.
	* dump.c: Move most of it to ../c-dump.c.
	(cp_dump_tree): New function.
	* pt.c (add_maybe_template): Remove.
	* typeck.c (strip_array_types): Likewise.

From-SVN: r37358

8 files changed, 68 insertions, 842 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 384d8c2..9d79a4c 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,24 @@
+2000-11-09  Mark Mitchell  <mark@codesourcery.com>
+
+	* Make-lang.in (CXX_C_OBJS): Add c-dump.o.
+	(dump.o): Update dependency list.
+	* cp-tree.h (DECL_MAYBE_TEMPLATE): Remove.
+	(flag_dump_translation_unit): Likewise.
+	(CP_TYPE_QUALS): Adjust definition.
+	(DECL_C_BIT_FIELD): Remove.
+	(SET_DECL_C_BIT_FIELD): Likewise.
+	(CLEAR_DECL_C_BIT_FIELD): Likewise.
+	(add_maybe_template): Likewise.
+	(strip_array_types): Likewise.
+	(dump_node_to_file): Likewise.
+	(cp_dump_tree): New function.
+	* decl.c (init_decl_processing): Set lang_dump_tree.
+	* decl2.c (flag_dump_translation_unit): Remove.
+	* dump.c: Move most of it to ../c-dump.c.
+	(cp_dump_tree): New function.
+	* pt.c (add_maybe_template): Remove.
+	* typeck.c (strip_array_types): Likewise.
+	
 2000-11-07  Eric Christopher  <echristo@redhat.com>
 
         * decl.c (init_decl_processing): Change definition of
diff --git a/gcc/cp/Make-lang.in b/gcc/cp/Make-lang.in
index 2099c3a..e8091f5 100644
--- a/gcc/cp/Make-lang.in
+++ b/gcc/cp/Make-lang.in
@@ -90,7 +90,7 @@ $(DEMANGLER_PROG): cxxmain.o underscore.o $(LIBDEPS)
 
 # The compiler itself.
 # Shared with C front end:
-CXX_C_OBJS = c-common.o c-pragma.o c-semantics.o c-lex.o
+CXX_C_OBJS = c-common.o c-pragma.o c-semantics.o c-lex.o c-dump.o
 
 # Language-specific object files.
 CXX_OBJS = cp/call.o cp/decl.o cp/errfn.o cp/expr.o cp/pt.o cp/typeck2.o \
@@ -264,7 +264,7 @@ cp/errfn.o: cp/errfn.c $(CXX_TREE_H) toplev.h
 cp/repo.o: cp/repo.c $(CXX_TREE_H) toplev.h $(GGC_H)
 cp/semantics.o: cp/semantics.c $(CXX_TREE_H) cp/lex.h except.h toplev.h \
   flags.h $(GGC_H) output.h $(RTL_H) $(TIMEVAR_H)
-cp/dump.o: cp/dump.c $(CXX_TREE_H)
+cp/dump.o: cp/dump.c $(CXX_TREE_H) c-dump.h
 cp/optimize.o: cp/optimize.c $(CXX_TREE_H) rtl.h integrate.h insn-config.h \
   input.h
 cp/mangle.o: cp/mangle.c $(CXX_TREE_H) toplev.h
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index e7045e5..67e4c23 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -95,7 +95,7 @@ Boston, MA 02111-1307, USA.  */
    2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL).
       DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL)
    3: DECL_IN_AGGR_P.
-   4: DECL_MAYBE_TEMPLATE.
+   4: DECL_C_BIT_FIELD
    5: DECL_INTERFACE_KNOWN.
    6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL).
    7: DECL_DEAD_FOR_LOCAL (in VAR_DECL).
@@ -1031,11 +1031,6 @@ extern int warn_ctor_dtor_privacy;
 
 extern int warn_return_type;
 
-/* If non-NULL, dump the tree structure for the entire translation
-   unit to this file.  */
-
-extern const char *flag_dump_translation_unit;
-
 /* Nonzero means warn about deprecated conversion from string constant to
    `char *'.  */
 
@@ -1237,9 +1232,7 @@ enum languages { lang_c, lang_cplusplus, lang_java };
 
 /* The type qualifiers for this type, including the qualifiers on the
    elements for an array type.  */
-#define CP_TYPE_QUALS(NODE)			\
-  ((TREE_CODE (NODE) != ARRAY_TYPE)		\
-   ? TYPE_QUALS (NODE) : cp_type_quals (NODE))
+#define CP_TYPE_QUALS(NODE) C_TYPE_QUALS (NODE)
 
 /* Nonzero if this type is const-qualified.  */
 #define CP_TYPE_CONST_P(NODE)				\
@@ -2486,14 +2479,6 @@ extern int flag_new_for_scope;
 /* Record whether a typedef for type `int' was actually `signed int'.  */
 #define C_TYPEDEF_EXPLICITLY_SIGNED(exp) DECL_LANG_FLAG_1 ((exp))
 
-/* In a FIELD_DECL, nonzero if the decl was originally a bitfield.  */
-#define DECL_C_BIT_FIELD(NODE) \
-  (DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE)) == 1)
-#define SET_DECL_C_BIT_FIELD(NODE) \
-  (DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE)) = 1)
-#define CLEAR_DECL_C_BIT_FIELD(NODE) \
-  (DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE)) = 0)
-
 /* In a FUNCTION_DECL, nonzero if the function cannot be inlined.  */
 #define DECL_UNINLINABLE(NODE) \
   (DECL_LANG_SPECIFIC (NODE)->decl_flags.uninlinable)
@@ -4213,7 +4198,6 @@ extern void do_decl_instantiation		PARAMS ((tree, tree, tree));
 extern void do_type_instantiation		PARAMS ((tree, tree, int));
 extern tree instantiate_decl			PARAMS ((tree, int));
 extern tree get_bindings			PARAMS ((tree, tree, tree));
-extern void add_maybe_template			PARAMS ((tree, tree));
 extern void pop_tinst_level			PARAMS ((void));
 extern int more_specialized_class		PARAMS ((tree, tree));
 extern int is_member_template                   PARAMS ((tree));
@@ -4546,7 +4530,6 @@ extern tree convert_for_initialization		PARAMS ((tree, tree, tree, int, const ch
 extern int comp_ptr_ttypes			PARAMS ((tree, tree));
 extern int ptr_reasonably_similar		PARAMS ((tree, tree));
 extern tree build_ptrmemfunc			PARAMS ((tree, tree, int));
-extern tree strip_array_types                   PARAMS ((tree));
 extern int cp_type_quals                        PARAMS ((tree));
 extern int cp_has_mutable_p                     PARAMS ((tree));
 extern int at_least_as_qualified_p              PARAMS ((tree, tree));
@@ -4600,9 +4583,6 @@ extern void GNU_xref_assign			PARAMS ((tree));
 extern void GNU_xref_hier			PARAMS ((tree, tree, int, int, int));
 extern void GNU_xref_member			PARAMS ((tree, tree));
 
-/* in dump.c */
-extern void dump_node_to_file                   PARAMS ((tree, const char *));
-
 /* in mangle.c */
 extern void init_mangle                         PARAMS ((void));
 extern tree mangle_decl                         PARAMS ((tree));
@@ -4617,6 +4597,9 @@ extern tree mangle_thunk                        PARAMS ((tree, tree, tree));
 extern tree mangle_conv_op_name_for_type        PARAMS ((tree));
 extern tree mangle_guard_variable               PARAMS ((tree));
 
+/* in dump.c */
+extern int cp_dump_tree                         PARAMS ((dump_info_p, tree));
+
 /* -- end of C++ */
 
 #endif /* not _CP_TREE_H */
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index ce19601..a66500f 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -6331,6 +6331,7 @@ init_decl_processing ()
   free_lang_status = &pop_cp_function_context;
   mark_lang_status = &mark_cp_function_context;
   lang_safe_from_p = &c_safe_from_p;
+  lang_dump_tree = &cp_dump_tree;
 
   cp_parse_init ();
   init_decl2 ();
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 138adc1..43874fb 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -236,11 +236,6 @@ int flag_optional_diags = 1;
 
 int flag_const_strings = 1;
 
-/* If non-NULL, dump the tree structure for the entire translation
-   unit to this file.  */
-
-const char *flag_dump_translation_unit = 0;
-
 /* Nonzero means warn about deprecated conversion from string constant to
    `char *'.  */
 
diff --git a/gcc/cp/dump.c b/gcc/cp/dump.c
index 618a714..077b333 100644
--- a/gcc/cp/dump.c
+++ b/gcc/cp/dump.c
@@ -23,489 +23,52 @@ Boston, MA 02111-1307, USA.  */
 #include "system.h"
 #include "tree.h"
 #include "cp-tree.h"
+#include "c-dump.h"
 
-/* Flags used with queue functions.  */
-#define DUMP_NONE     0
-#define DUMP_BINFO    1
-
-/* Information about a node to be dumped.  */
-
-typedef struct dump_node_info
-{
-  /* The index for the node.  */
-  unsigned int index;
-  /* Nonzero if the node is a binfo.  */
-  unsigned int binfo_p : 1;
-} *dump_node_info_p;
-
-/* A dump_queue is a link in the queue of things to be dumped.  */
-
-typedef struct dump_queue
-{
-  /* The queued tree node.  */
-  splay_tree_node node;
-  /* The next node in the queue.  */
-  struct dump_queue *next;
-} *dump_queue_p;
-
-/* A dump_info gives information about how we should perform the dump 
-   and about the current state of the dump.  */
-
-typedef struct dump_info
-{
-  /* The stream on which to dump the information.  */
-  FILE *stream;
-  /* The next unused node index.  */
-  unsigned int index;
-  /* The next column.  */
-  unsigned int column;
-  /* The first node in the queue of nodes to be written out.  */
-  dump_queue_p queue;
-  /* The last node in the queue.  */
-  dump_queue_p queue_end;
-  /* Free queue nodes.  */
-  dump_queue_p free_list;
-  /* The tree nodes which we have already written out.  The 
-     keys are the addresses of the nodes; the values are the integer
-     indices we assigned them.  */
-  splay_tree nodes;
-} *dump_info_p;
-
-static unsigned int queue PARAMS ((dump_info_p, tree, int));
-static void dump_index PARAMS ((dump_info_p, unsigned int));
-static void queue_and_dump_index PARAMS ((dump_info_p, const char *, tree, int));
-static void queue_and_dump_type PARAMS ((dump_info_p, tree));
-static void dequeue_and_dump PARAMS ((dump_info_p));
-static void dump_new_line PARAMS ((dump_info_p));
-static void dump_maybe_newline PARAMS ((dump_info_p));
-static void dump_int PARAMS ((dump_info_p, const char *, int));
-static void dump_string PARAMS ((dump_info_p, const char *));
-static void dump_string_field PARAMS ((dump_info_p, const char *, const char *));
-static void dump_node PARAMS ((tree, FILE *));
-static void dump_stmt PARAMS ((dump_info_p, tree));
-static void dump_next_stmt PARAMS ((dump_info_p, tree));
-
-/* Add T to the end of the queue of nodes to dump.  Returns the index
-   assigned to T.  */
-
-static unsigned int
-queue (di, t, flags)
-     dump_info_p di;
-     tree t;
-     int flags;
-{
-  dump_queue_p dq;
-  dump_node_info_p dni;
-  unsigned int index;
-
-  /* Assign the next available index to T.  */
-  index = ++di->index;
-
-  /* Obtain a new queue node.  */
-  if (di->free_list)
-    {
-      dq = di->free_list;
-      di->free_list = dq->next;
-    }
-  else
-    dq = (dump_queue_p) xmalloc (sizeof (struct dump_queue));
-
-  /* Create a new entry in the splay-tree.  */
-  dni = (dump_node_info_p) xmalloc (sizeof (struct dump_node_info));
-  dni->index = index;
-  dni->binfo_p = ((flags & DUMP_BINFO) != 0);
-  dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t, 
-				(splay_tree_value) dni);
-
-  /* Add it to the end of the queue.  */
-  dq->next = 0;
-  if (!di->queue_end)
-    di->queue = dq;
-  else
-    di->queue_end->next = dq;
-  di->queue_end = dq;
-
-  /* Return the index.  */
-  return index;
-}
-
-static void
-dump_index (di, index)
-     dump_info_p di;
-     unsigned int index;
-{
-  fprintf (di->stream, "@%-6u ", index);
-  di->column += 8;
-}
-
-/* If T has not already been output, queue it for subsequent output.
-   FIELD is a string to print before printing the index.  Then, the
-   index of T is printed.  */
-
-static void
-queue_and_dump_index (di, field, t, flags)
-     dump_info_p di;
-     const char *field;
-     tree t;
-     int flags;
-{
-  unsigned int index;
-  splay_tree_node n;
-
-  /* If there's no node, just return.  This makes for fewer checks in
-     our callers.  */
-  if (!t)
-    return;
-
-  /* See if we've already queued or dumped this node.  */
-  n = splay_tree_lookup (di->nodes, (splay_tree_key) t);
-  if (n)
-    index = ((dump_node_info_p) n->value)->index;
-  else
-    /* If we haven't, add it to the queue.  */
-    index = queue (di, t, flags);
-
-  /* Print the index of the node.  */
-  dump_maybe_newline (di);
-  fprintf (di->stream, "%-4s: ", field);
-  di->column += 6;
-  dump_index (di, index);
-}
-
-/* Dump the type of T.  */
-
-static void
-queue_and_dump_type (di, t)
+int
+cp_dump_tree (di, t)
      dump_info_p di;
      tree t;
 {
-  queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
-}
-
-/* Insert a new line in the dump output, and indent to an appropriate
-   place to start printing more fields.  */
-
-static void
-dump_new_line (di)
-     dump_info_p di;
-{
-  fprintf (di->stream, "\n%25s", "");
-  di->column = 25;
-}
-
-/* If necessary, insert a new line.  */
-
-static void
-dump_maybe_newline (di)
-     dump_info_p di;
-{
-  /* See if we need a new line.  */
-  if (di->column > 53)
-    dump_new_line (di);
-  /* See if we need any padding.  */
-  else if ((di->column - 25) % 14 != 0)
-    {
-      fprintf (di->stream, "%*s", 14 - ((di->column - 25) % 14), "");
-      di->column += 14 - (di->column - 25) % 14;
-    }
-}
-
-/* Dump I using FIELD to identity it.  */
-
-static void
-dump_int (di, field, i)
-     dump_info_p di;
-     const char *field;
-     int i;
-{
-  dump_maybe_newline (di);
-  fprintf (di->stream, "%-4s: %-7d ", field, i);
-  di->column += 14;
-}
-
-/* Dump the string S.  */
-
-static void
-dump_string (di, string)
-     dump_info_p di;
-     const char *string;
-{
-  dump_maybe_newline (di);
-  fprintf (di->stream, "%-13s ", string);
-  if (strlen (string) > 13)
-    di->column += strlen (string) + 1;
-  else
-    di->column += 14;
-}
-
-/* Dump the string field S.  */
-
-static void
-dump_string_field (di, field, string)
-     dump_info_p di;
-     const char *field;
-     const char *string;
-{
-  dump_maybe_newline (di);
-  fprintf (di->stream, "%-4s: %-7s ", field, string);
-  if (strlen (string) > 7)
-    di->column += 6 + strlen (string) + 1;
-  else
-    di->column += 14;
-}
-
-/* Dump information common to statements from STMT.  */
-
-static void
-dump_stmt (di, t)
-     dump_info_p di;
-     tree t;
-{
-  dump_int (di, "line", STMT_LINENO (t));
-}
-
-/* Dump the CHILD and its children.  */
-#define dump_child(field, child) \
-  queue_and_dump_index (di, field, child, DUMP_NONE)
-
-/* Dump the next statement after STMT.  */
-
-static void
-dump_next_stmt (di, t)
-     dump_info_p di;
-     tree t;
-{
-  dump_child ("next", TREE_CHAIN (t));
-}
-
-/* Dump the next node in the queue.  */
-
-static void 
-dequeue_and_dump (di)
-     dump_info_p di;
-{
-  dump_queue_p dq;
-  splay_tree_node stn;
-  dump_node_info_p dni;
-  tree t;
-  unsigned int index;
   enum tree_code code;
-  char code_class;
-  const char* code_name;
-
-  /* Get the next node from the queue.  */
-  dq = di->queue;
-  stn = dq->node;
-  t = (tree) stn->key;
-  dni = (dump_node_info_p) stn->value;
-  index = dni->index;
-
-  /* Remove the node from the queue, and put it on the free list.  */
-  di->queue = dq->next;
-  if (!di->queue)
-    di->queue_end = 0;
-  dq->next = di->free_list;
-  di->free_list = dq;
-
-  /* Print the node index.  */
-  dump_index (di, index);
-  /* And the type of node this is.  */
-  if (dni->binfo_p)
-    code_name = "binfo";
-  else
-    code_name = tree_code_name[(int) TREE_CODE (t)];
-  fprintf (di->stream, "%-16s ", code_name);
-  di->column = 25;
 
   /* Figure out what kind of node this is.  */
   code = TREE_CODE (t);
-  code_class = TREE_CODE_CLASS (code);
 
-  /* Although BINFOs are TREE_VECs, we dump them specially so as to be
-     more informative.  */
-  if (dni->binfo_p)
+  if (DECL_P (t))
     {
-      if (TREE_VIA_PUBLIC (t))
-	dump_string (di, "pub");
-      else if (TREE_VIA_PROTECTED (t))
-	dump_string (di, "prot");
-      else if (TREE_VIA_PRIVATE (t))
-	dump_string (di, "priv");
-      if (TREE_VIA_VIRTUAL (t))
-	dump_string (di, "virt");
-	    
-      dump_child ("type", BINFO_TYPE (t));
-      dump_child ("base", BINFO_BASETYPES (t));
-
-      goto done;
-    }
-
-  /* We can knock off a bunch of expression nodes in exactly the same
-     way.  */
-  if (IS_EXPR_CODE_CLASS (code_class))
-    {
-      /* If we're dumping children, dump them now.  */
-      queue_and_dump_type (di, t);
-
-      switch (code_class)
-	{
-	case '1':
-	  dump_child ("op 0", TREE_OPERAND (t, 0));
-	  break;
-	      
-	case '2':
-	case '<':
-	  dump_child ("op 0", TREE_OPERAND (t, 0));
-	  dump_child ("op 1", TREE_OPERAND (t, 1));
-	  break;
-	      
-	case 'e':
-	  /* These nodes are handled explicitly below.  */
-	  break;
-	      
-	default:
-	  my_friendly_abort (19990726);
-	}
-    }
-  else if (code_class == 'd')
-    {
-      /* All declarations have names.  */
-      if (DECL_NAME (t))
-	dump_child ("name", DECL_NAME (t));
-      /* And types.  */
-      queue_and_dump_type (di, t);
-      dump_child ("scpe", DECL_CONTEXT (t));
-      /* And a source position.  */
-      if (DECL_SOURCE_FILE (t))
-	{
-	  const char *filename = strrchr (DECL_SOURCE_FILE (t), '/');
-	  if (!filename)
-	    filename = DECL_SOURCE_FILE (t);
-	  else
-	    /* Skip the slash.  */
-	    ++filename;
-
-	  dump_maybe_newline (di);
-	  fprintf (di->stream, "srcp: %s:%-6d ", filename, 
-		   DECL_SOURCE_LINE (t));
-	  di->column += 6 + strlen (filename) + 8;
-	}
-      /* And any declaration can be compiler-generated.  */
-      if (DECL_ARTIFICIAL (t))
-	dump_string (di, "artificial");
-      if (TREE_CHAIN (t))
-	dump_child ("chan", TREE_CHAIN (t));
       if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
 	dump_string (di, language_to_string (DECL_LANGUAGE (t), 0));
     }
-  else if (code_class == 't')
-    {
-      /* All types have qualifiers.  */
-      int quals = CP_TYPE_QUALS (t);
-      if (quals != TYPE_UNQUALIFIED)
-	{
-	  fprintf (di->stream, "qual: %c%c%c     ",
-		   (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
-		   (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
-		   (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
-	  di->column += 14;
-	}
-
-      /* All types have associated declarations.  */
-      dump_child ("name", TYPE_NAME (t));
-
-      /* All types have a main variant.  */
-      if (TYPE_MAIN_VARIANT (t) != t)
-	dump_child ("unql", TYPE_MAIN_VARIANT (t));
-      
-      /* And sizes.  */
-      dump_child ("size", TYPE_SIZE (t));
-
-      /* All types have alignments.  */
-      dump_int (di, "algn", TYPE_ALIGN (t));
-    }
-  else if (code_class == 'c')
-    /* All constants can have types.  */
-    queue_and_dump_type (di, t);
 
-  /* Now handle the various kinds of nodes.  */
   switch (code)
     {
-      int i;
-
     case IDENTIFIER_NODE:
       if (IDENTIFIER_OPNAME_P (t))
-	dump_string (di, "operator");
+	{
+	  dump_string (di, "operator");
+	  return 1;
+	}
       else if (IDENTIFIER_TYPENAME_P (t))
-	dump_child ("tynm", TREE_TYPE (t));
-      else if (t == anonymous_namespace_name)
-	dump_string (di, "unnamed");
-      else
 	{
-	  dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
-	  dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
+	  dump_child ("tynm", TREE_TYPE (t));
+	  return 1;
 	}
-      break;
-
-    case TREE_LIST:
-      dump_child ("purp", TREE_PURPOSE (t));
-      dump_child ("valu", TREE_VALUE (t));
-      dump_child ("chan", TREE_CHAIN (t));
-      break;
-
-    case TREE_VEC:
-      dump_int (di, "lngt", TREE_VEC_LENGTH (t));
-      for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
+      else if (t == anonymous_namespace_name)
 	{
-	  char buffer[32];
-	  sprintf (buffer, "%u", i);
-	  dump_child (buffer, TREE_VEC_ELT (t, i));
+	  dump_string (di, "unnamed");
+	  return 1;
 	}
       break;
 
-    case INTEGER_TYPE:
-    case ENUMERAL_TYPE:
-      dump_int (di, "prec", TYPE_PRECISION (t));
-      if (TREE_UNSIGNED (t))
-	dump_string (di, "unsigned");
-      dump_child ("min", TYPE_MIN_VALUE (t));
-      dump_child ("max", TYPE_MAX_VALUE (t));
-
-      if (code == ENUMERAL_TYPE)
-	dump_child ("csts", TYPE_VALUES (t));
-      break;
-
-    case REAL_TYPE:
-      dump_int (di, "prec", TYPE_PRECISION (t));
-      break;
-
     case POINTER_TYPE:
       if (TYPE_PTRMEM_P (t))
 	{
 	  dump_string (di, "ptrmem");
 	  dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
 	  dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
+	  return 1;
 	}
-      else
-	dump_child ("ptd", TREE_TYPE (t));
-      break;
-
-    case REFERENCE_TYPE:
-      dump_child ("refd", TREE_TYPE (t));
-      break;
-
-    case METHOD_TYPE:
-      dump_child ("clas", TYPE_METHOD_BASETYPE (t));
-      /* Fall through.  */
-
-    case FUNCTION_TYPE:
-      dump_child ("retn", TREE_TYPE (t));
-      dump_child ("prms", TYPE_ARG_TYPES (t));
-      break;
-
-    case ARRAY_TYPE:
-      dump_child ("elts", TREE_TYPE (t));
-      dump_child ("domn", TYPE_DOMAIN (t));
       break;
 
     case RECORD_TYPE:
@@ -515,60 +78,13 @@ dequeue_and_dump (di)
 	  dump_string (di, "ptrmem");
 	  dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
 	  dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
+	  return 1;
 	}
-      else
-	{
-	  if (CLASSTYPE_DECLARED_CLASS (t))
-	    dump_string (di, "class");
-	  else if (TREE_CODE (t) == RECORD_TYPE)
-	    dump_string (di, "struct");
-	  else
-	    dump_string (di, "union");
-
-	  dump_child ("flds", TYPE_FIELDS (t));
-	  dump_child ("fncs", TYPE_METHODS (t));
-	  dump_child ("vfld", TYPE_VFIELD (t));
-	  queue_and_dump_index (di, "binf", TYPE_BINFO (t), 
-				DUMP_BINFO);
-	}
-      break;
-
-    case CONST_DECL:
-      dump_child ("cnst", DECL_INITIAL (t));
-      break;
 
-    case VAR_DECL:
-    case PARM_DECL:
-    case FIELD_DECL:
-    case RESULT_DECL:
-      if (TREE_CODE (t) == PARM_DECL)
-	dump_child ("argt", DECL_ARG_TYPE (t));
-      else
-	dump_child ("init", DECL_INITIAL (t));
-      dump_child ("size", DECL_SIZE (t));
-      dump_int (di, "algn", DECL_ALIGN (t));
-
-      if (TREE_CODE (t) == FIELD_DECL)
-	{
-	  if (DECL_C_BIT_FIELD (t))
-	    dump_string (di, "bitfield");
-	  if (DECL_FIELD_OFFSET (t))
-	    dump_child ("bpos", bit_position (t));
-	}
-      else if (TREE_CODE (t) == VAR_DECL 
-	       || TREE_CODE (t) == PARM_DECL)
-	dump_int (di, "used", TREE_USED (t));
+      dump_child ("vfld", TYPE_VFIELD (t));
       break;
 
     case FUNCTION_DECL:
-      dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
-      dump_child ("args", DECL_ARGUMENTS (t));
-      if (DECL_EXTERNAL (t))
-	dump_string (di, "undefined");
-      if (TREE_PUBLIC (t))
-	dump_string(di, "extern");
-      else
-	dump_string (di, "static");
       if (!DECL_THUNK_P (t))
 	{
 	  if (DECL_FUNCTION_MEMBER_P (t))
@@ -625,34 +141,36 @@ dequeue_and_dump (di)
       dump_child ("chan", OVL_CHAIN (t));
       break;
 
-    case ASM_STMT:
+    case TRY_BLOCK:
       dump_stmt (di, t);
-      if (ASM_VOLATILE_P (t))
-	dump_string (di, "volatile");
-      dump_child ("strg", ASM_STRING (t));
-      dump_child ("outs", ASM_OUTPUTS (t));
-      dump_child ("ins", ASM_INPUTS (t));
-      dump_child ("clbr", ASM_CLOBBERS (t));
+      if (CLEANUP_P (t))
+	dump_string (di, "cleanup");
+      dump_child ("body", TRY_STMTS (t));
+      dump_child ("hdlr", TRY_HANDLERS (t));
       dump_next_stmt (di, t);
       break;
 
-    case BREAK_STMT:
-    case CONTINUE_STMT:
-      dump_stmt (di, t);
-      dump_next_stmt (di, t);
+    case PTRMEM_CST:
+      dump_child ("clas", PTRMEM_CST_CLASS (t));
+      dump_child ("mbr", PTRMEM_CST_MEMBER (t));
       break;
 
-    case CASE_LABEL:
-      /* Note that a case label is not like other statments; there is
-	 no way to get the line-number of a case label.  */
-      dump_child ("low", CASE_LOW (t));
-      dump_child ("high", CASE_HIGH (t));
-      dump_next_stmt (di, t);
+    case THROW_EXPR:
+      /* These nodes are unary, but do not have code class `1'.  */
+      dump_child ("op 0", TREE_OPERAND (t, 0));
       break;
 
-    case COMPOUND_STMT:
+    case AGGR_INIT_EXPR:
+      dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
+      dump_child ("fn", TREE_OPERAND (t, 0));
+      dump_child ("args", TREE_OPERAND (t, 1));
+      dump_child ("decl", TREE_OPERAND (t, 2));
+      break;
+      
+    case CLEANUP_STMT:
       dump_stmt (di, t);
-      dump_child ("body", COMPOUND_BODY (t));
+      dump_child ("decl", CLEANUP_DECL (t));
+      dump_child ("expr", CLEANUP_EXPR (t));
       dump_next_stmt (di, t);
       break;
 
@@ -665,89 +183,12 @@ dequeue_and_dump (di)
       dump_next_stmt (di, t);
       break;
 
-    case DECL_STMT:
-      dump_stmt (di, t);
-      dump_child ("decl", DECL_STMT_DECL (t));
-      dump_next_stmt (di, t);
-      break;
-      
-    case DO_STMT:
-      dump_stmt (di, t);
-      dump_child ("body", DO_BODY (t));
-      dump_child ("cond", DO_COND (t));
-      dump_next_stmt (di, t);
-      break;
-
-    case EXPR_STMT:
-      dump_stmt (di, t);
-      dump_child ("expr", EXPR_STMT_EXPR (t));
-      dump_next_stmt (di, t);
-      break;
-
-    case FOR_STMT:
-      dump_stmt (di, t);
-      dump_child ("init", FOR_INIT_STMT (t));
-      dump_child ("cond", FOR_COND (t));
-      dump_child ("expr", FOR_EXPR (t));
-      dump_child ("body", FOR_BODY (t));
-      dump_next_stmt (di, t);
-      break;
-
-    case GOTO_STMT:
-      dump_stmt (di, t);
-      dump_child ("dest", GOTO_DESTINATION (t));
-      dump_next_stmt (di, t);
-      break;
-
     case HANDLER:
       dump_stmt (di, t);
       dump_child ("body", HANDLER_BODY (t));
       dump_next_stmt (di, t);
       break;
 
-    case IF_STMT:
-      dump_stmt (di, t);
-      dump_child ("cond", IF_COND (t));
-      dump_child ("then", THEN_CLAUSE (t));
-      dump_child ("else", ELSE_CLAUSE (t));
-      dump_next_stmt (di, t);
-      break;
-
-    case LABEL_STMT:
-      dump_stmt (di, t);
-      dump_child ("labl", LABEL_STMT_LABEL (t));
-      dump_next_stmt (di, t);
-      break;
-
-    case RETURN_STMT:
-      dump_stmt (di, t);
-      dump_child ("expr", RETURN_EXPR (t));
-      dump_next_stmt (di, t);
-      break;
-
-    case SWITCH_STMT:
-      dump_stmt (di, t);
-      dump_child ("cond", SWITCH_COND (t));
-      dump_child ("body", SWITCH_BODY (t));
-      dump_next_stmt (di, t);
-      break;
-
-    case TRY_BLOCK:
-      dump_stmt (di, t);
-      if (CLEANUP_P (t))
-	dump_string (di, "cleanup");
-      dump_child ("body", TRY_STMTS (t));
-      dump_child ("hdlr", TRY_HANDLERS (t));
-      dump_next_stmt (di, t);
-      break;
-
-    case WHILE_STMT:
-      dump_stmt (di, t);
-      dump_child ("cond", WHILE_COND (t));
-      dump_child ("body", WHILE_BODY (t));
-      dump_next_stmt (di, t);
-      break;
-
     case SUBOBJECT:
       dump_stmt (di, t);
       dump_child ("clnp", TREE_OPERAND (t, 0));
@@ -760,184 +201,10 @@ dequeue_and_dump (di)
       dump_next_stmt (di, t);
       break;
 
-    case CLEANUP_STMT:
-      dump_stmt (di, t);
-      dump_child ("decl", CLEANUP_DECL (t));
-      dump_child ("expr", CLEANUP_EXPR (t));
-      dump_next_stmt (di, t);
-      break;
-
-    case SCOPE_STMT:
-      dump_stmt (di, t);
-      if (SCOPE_BEGIN_P (t))
-	dump_string (di, "begn");
-      else
-	dump_string (di, "end");
-      if (SCOPE_NULLIFIED_P (t))
-	dump_string (di, "null");
-      if (!SCOPE_NO_CLEANUPS_P (t))
-	dump_string (di, "clnp");
-      dump_next_stmt (di, t);
-      break;
-
-    case INTEGER_CST:
-      if (TREE_INT_CST_HIGH (t))
-	dump_int (di, "high", TREE_INT_CST_HIGH (t));
-      dump_int (di, "low", TREE_INT_CST_LOW (t));
-      break;
-
-    case STRING_CST:
-      fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
-      dump_int (di, "lngt", TREE_STRING_LENGTH (t));
-      break;
-
-    case PTRMEM_CST:
-      dump_child ("clas", PTRMEM_CST_CLASS (t));
-      dump_child ("mbr", PTRMEM_CST_MEMBER (t));
-      break;
-
-    case TRUTH_NOT_EXPR:
-    case ADDR_EXPR:
-    case INDIRECT_REF:
-    case THROW_EXPR:
-    case CLEANUP_POINT_EXPR:
-    case SAVE_EXPR:
-      /* These nodes are unary, but do not have code class `1'.  */
-      dump_child ("op 0", TREE_OPERAND (t, 0));
-      break;
-
-    case TRUTH_ANDIF_EXPR:
-    case TRUTH_ORIF_EXPR:
-    case INIT_EXPR:
-    case MODIFY_EXPR:
-    case COMPONENT_REF:
-    case COMPOUND_EXPR:
-    case ARRAY_REF:
-    case PREDECREMENT_EXPR:
-    case PREINCREMENT_EXPR:
-    case POSTDECREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
-      /* These nodes are binary, but do not have code class `2'.  */
-      dump_child ("op 0", TREE_OPERAND (t, 0));
-      dump_child ("op 1", TREE_OPERAND (t, 1));
-      break;
-
-    case COND_EXPR:
-      dump_child ("op 0", TREE_OPERAND (t, 0));
-      dump_child ("op 1", TREE_OPERAND (t, 1));
-      dump_child ("op 2", TREE_OPERAND (t, 2));
-      break;
-
-    case CALL_EXPR:
-      dump_child ("fn", TREE_OPERAND (t, 0));
-      dump_child ("args", TREE_OPERAND (t, 1));
-      break;
-
-    case CONSTRUCTOR:
-      dump_child ("elts", TREE_OPERAND (t, 1));
-      break;
-
-    case STMT_EXPR:
-      dump_child ("stmt", STMT_EXPR_STMT (t));
-      break;
-
-    case BIND_EXPR:
-      dump_child ("vars", TREE_OPERAND (t, 0));
-      dump_child ("body", TREE_OPERAND (t, 1));
-      break;
-
-    case LOOP_EXPR:
-      dump_child ("body", TREE_OPERAND (t, 0));
-      break;
-
-    case EXIT_EXPR:
-      dump_child ("cond", TREE_OPERAND (t, 0));
-      break;
-
-    case TARGET_EXPR:
-      dump_child ("decl", TREE_OPERAND (t, 0));
-      dump_child ("init", TREE_OPERAND (t, 1));
-      dump_child ("clnp", TREE_OPERAND (t, 2));
-      /* There really are two possible places the initializer can be.
-	 After RTL expansion, the second operand is moved to the
-	 position of the fourth operand, and the second operand
-	 becomes NULL.  */
-      dump_child ("init", TREE_OPERAND (t, 3));
-      break;
-      
-    case AGGR_INIT_EXPR:
-      dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
-      dump_child ("fn", TREE_OPERAND (t, 0));
-      dump_child ("args", TREE_OPERAND (t, 1));
-      dump_child ("decl", TREE_OPERAND (t, 2));
-      break;
-      
-    case EXPR_WITH_FILE_LOCATION:
-      dump_child ("expr", EXPR_WFL_NODE (t));
-      break;
-
     default:
-      /* There are no additional fields to print.  */
       break;
     }
 
- done:
-  /* Terminate the line.  */
-  fprintf (di->stream, "\n");
+  return 0;
 }
 
-/* Dump T, and all its children, on STREAM.  */
-
-static void
-dump_node (t, stream)
-     tree t;
-     FILE *stream;
-{
-  struct dump_info di;
-  dump_queue_p dq;
-  dump_queue_p next_dq;
-
-  /* Initialize the dump-information structure.  */
-  di.stream = stream;
-  di.index = 0;
-  di.column = 0;
-  di.queue = 0;
-  di.queue_end = 0;
-  di.free_list = 0;
-  di.nodes = splay_tree_new (splay_tree_compare_pointers, 0, 
-			     (splay_tree_delete_value_fn) &free);
-
-  /* Queue up the first node.  */
-  queue (&di, t, DUMP_NONE);
-
-  /* Until the queue is empty, keep dumping nodes.  */
-  while (di.queue)
-    dequeue_and_dump (&di);
-
-  /* Now, clean up.  */
-  for (dq = di.free_list; dq; dq = next_dq)
-    {
-      next_dq = dq->next;
-      free (dq);
-    }
-  splay_tree_delete (di.nodes);
-}
-
-/* Dump T, and all its children, to FILE.  */
-
-void
-dump_node_to_file (t, file)
-     tree t;
-     const char *file;
-{
-  FILE *f;
-
-  f = fopen (file, "w");
-  if (!f)
-    cp_error ("could not open `%s'", file);
-  else
-    {
-      dump_node (t, f);
-      fclose (f);
-    }
-}
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 7098d7d..dd190ea 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -5654,7 +5654,7 @@ tsubst_decl (t, args, type, in_decl)
 	/* We do NOT check for matching decls pushed separately at this
            point, as they may not represent instantiations of this
            template, and in any case are considered separate under the
-           discrete model.  Instead, see add_maybe_template.  */
+           discrete model.  */
 	r = copy_decl (t);
 	DECL_USE_TEMPLATE (r) = 0;
 	TREE_TYPE (r) = type;
@@ -9871,34 +9871,6 @@ tsubst_initializer_list (t, argvec)
   return first;
 }
 
-/* D is an undefined function declaration in the presence of templates with
-   the same name, listed in FNS.  If one of them can produce D as an
-   instantiation, remember this so we can instantiate it at EOF if D has
-   not been defined by that time.  */
-
-void
-add_maybe_template (d, fns)
-     tree d, fns;
-{
-  tree t;
-
-  if (DECL_MAYBE_TEMPLATE (d))
-    return;
-
-  t = most_specialized (fns, d, NULL_TREE);
-  if (! t)
-    return;
-  if (t == error_mark_node)
-    {
-      cp_error ("ambiguous template instantiation for `%D'", d);
-      return;
-    }
-
-  *maybe_template_tail = tree_cons (t, d, NULL_TREE);
-  maybe_template_tail = &TREE_CHAIN (*maybe_template_tail);
-  DECL_MAYBE_TEMPLATE (d) = 1;
-}
-
 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL.  */
 
 static void
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index db7374b..84b648c 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -6967,19 +6967,6 @@ comp_ptr_ttypes_reinterpret (to, from)
     }
 }
 
-/* Recursively examines the array elements of TYPE, until a non-array
-   element type is found.  */
-
-tree
-strip_array_types (type)
-     tree type;
-{
-  while (TREE_CODE (type) == ARRAY_TYPE)
-    type = TREE_TYPE (type);
-
-  return type;
-}
-
 /* Returns the type-qualifier set corresponding to TYPE.  */
 
 int