2008-12-12 Benjamin Kosnik <bkoz@redhat.com>

[pf3gnuchains/gcc-fork.git] / gcc / c-dump.c

diff --git a/gcc/c-dump.c b/gcc/c-dump.c
index 7f3dbdd..f970b39 100644 (file)
--- a/gcc/c-dump.c
+++ b/gcc/c-dump.c
@@ -1,12 +1,12 @@
-/* Tree-dumping functionality for intermediate representation.
-   Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+/* Tree-dumping functionality for C-family languages.
+   Copyright (C) 2002, 2004, 2005, 2007 Free Software Foundation, Inc.

    Written by Mark Mitchell <mark@codesourcery.com>
 
 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
    Written by Mark Mitchell <mark@codesourcery.com>
 
 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
+Software Foundation; either version 3, or (at your option) any later

 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY


@@ -15,919 +15,47 @@ 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
 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.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */

 
 #include "config.h"
 #include "system.h"
 
 #include "config.h"
 #include "system.h"

+#include "coretypes.h"
+#include "tm.h"

 #include "tree.h"
 #include "tree.h"

-#include "c-common.h"
-#include "splay-tree.h"
-#include "diagnostic.h"
-#include "toplev.h"
-#include "c-dump.h"
-
-/* A callback function used dump language-specific parts of tree
-   nodes.  Returns non-zero if it does not want the usual dumping of
-   the second argument.  */
-
-dump_tree_fn lang_dump_tree;
-
-static unsigned int queue PARAMS ((dump_info_p, tree, int));
-static void dump_index PARAMS ((dump_info_p, unsigned int));
-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_string_field PARAMS ((dump_info_p, const char *, const char *));
-
-/* 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.  */
-
-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.  */
-
-void
-queue_and_dump_type (di, t)
-     dump_info_p di;
-     tree t;
-{
-  queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
-}
-
-/* Dump column control */
-#define SOL_COLUMN 25          /* Start of line column.  */
-#define EOL_COLUMN 55          /* End of line column.  */
-#define COLUMN_ALIGNMENT 15    /* Alignment.  */
-
-/* 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%*s", SOL_COLUMN, "");
-  di->column = SOL_COLUMN;
-}
-
-/* If necessary, insert a new line.  */
-
-static void
-dump_maybe_newline (di)
-     dump_info_p di;
-{
-  int extra;
-  
-  /* See if we need a new line.  */
-  if (di->column > EOL_COLUMN)
-    dump_new_line (di);
-  /* See if we need any padding.  */
-  else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0)
-    {
-      fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, "");
-      di->column += COLUMN_ALIGNMENT - extra;
-    }
-}
-
-/* Dump pointer PTR using FIELD to identify it.  */
-
-void
-dump_pointer (di, field, ptr)
-     dump_info_p di;
-     const char *field;
-     void *ptr;
-{
-  dump_maybe_newline (di);
-  fprintf (di->stream, "%-4s: %-8lx ", field, (long) ptr);
-  di->column += 15;
-}
-
-/* Dump integer I using FIELD to identify it.  */
-
-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.  */
-
-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;
-}
+#include "c-tree.h"
+#include "tree-dump.h"

 
 /* Dump information common to statements from STMT.  */
 
 void
 
 /* Dump information common to statements from STMT.  */
 
 void

-dump_stmt (di, t)
-     dump_info_p di;
-     tree t;
+dump_stmt (dump_info_p di, const_tree t)

 {
 {

-  dump_int (di, "line", STMT_LINENO (t));
+  if (EXPR_HAS_LOCATION (t))
+    dump_int (di, "line", EXPR_LINENO (t));

 }
 
 }
 

-/* Dump the next statement after STMT.  */
+/* Dump any C-specific tree codes and attributes of common codes.  */

 
 

-void
-dump_next_stmt (di, t)
-     dump_info_p di;
-     tree t;
+bool
+c_dump_tree (void *dump_info, 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;
   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;
+  dump_info_p di = (dump_info_p) dump_info;

 
   /* Figure out what kind of node this is.  */
   code = TREE_CODE (t);
 
   /* 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 (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:
-         abort();
-       }
-    }
-  else if (DECL_P (t))
-    {
-      /* All declarations have names.  */
-      if (DECL_NAME (t))
-       dump_child ("name", DECL_NAME (t));
-      if (DECL_ASSEMBLER_NAME_SET_P (t) 
-         && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
-       dump_child ("mngl", DECL_ASSEMBLER_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_flag (di, TDF_SLIM, NULL))
-       dump_child ("chan", TREE_CHAIN (t));
-    }
-  else if (code_class == 't')
-    {
-      /* All types have qualifiers.  */
-      int quals = C_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);
-
-  /* Give the language-specific code a chance to print something.  If
-     it's completely taken care of things, don't bother printing
-     anything more ourselves.  */
-  if (lang_dump_tree && (*lang_dump_tree) (di, t))
-    goto done;
-
-  /* Now handle the various kinds of nodes.  */

   switch (code)
     {
   switch (code)
     {

-      int i;
-
-    case IDENTIFIER_NODE:
-      dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
-      dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
-      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)
-       {
-         char buffer[32];
-         sprintf (buffer, "%u", i);
-         dump_child (buffer, TREE_VEC_ELT (t, i));
-       }
-      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:
-      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:
-    case UNION_TYPE:
-      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));
-      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 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));
-         if (DECL_REGISTER (t))
-           dump_string (di, "register");
-       }
-      break;
-
-    case FUNCTION_DECL:
-      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_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
-       dump_child ("body", DECL_SAVED_TREE (t));
-      break;
-
-    case ASM_STMT:
-      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));
-      dump_next_stmt (di, t);
-      break;
-
-    case BREAK_STMT:
-    case CONTINUE_STMT:
-      dump_stmt (di, t);
-      dump_next_stmt (di, t);
-      break;
-
-    case CASE_LABEL:
-      /* Note that a case label is not like other statements; 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);
-      break;
-
-    case COMPOUND_STMT:
-      dump_stmt (di, t);
-      dump_child ("body", COMPOUND_BODY (t));
-      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 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 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 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 TRUTH_NOT_EXPR:
-    case ADDR_EXPR:
-    case INDIRECT_REF:
-    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 EXPR_WITH_FILE_LOCATION:
-      dump_child ("expr", EXPR_WFL_NODE (t));
+      if (DECL_C_BIT_FIELD (t))
+       dump_string (di, "bitfield");

       break;
 
     default:
       break;
 
     default:

-      /* There are no additional fields to print.  */

       break;
     }
 
       break;
     }
 

- done:
-  if (dump_flag (di, TDF_ADDRESS, NULL))
-    dump_pointer (di, "addr", (void *)t);
-  
-  /* Terminate the line.  */
-  fprintf (di->stream, "\n");
-}
-
-/* Return non-zero if FLAG has been specified for the dump, and NODE
-   is not the root node of the dump.  */
-
-int dump_flag (di, flag, node)
-     dump_info_p di;
-     int flag;
-     tree node;
-{
-  return (di->flags & flag) && (node != di->node);
-}
-
-/* Dump T, and all its children, on STREAM.  */
-
-void
-dump_node (t, flags, stream)
-     tree t;
-     int flags;
-     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.flags = flags;
-  di.node = t;
-  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);
-}
-
-/* Define a tree dump switch.  */
-struct dump_file_info
-{
-  const char *suffix;          /* suffix to give output file.  */
-  const char *swtch;           /* command line switch */
-  int flags;                   /* user flags */
-  int state;                   /* state of play */
-};
-
-/* Table of tree dump switches. This must be consistent with the
-   TREE_DUMP_INDEX enumeration in c-common.h */
-static struct dump_file_info dump_files[TDI_end] =
-{
-  {".tu", "dump-translation-unit", 0, 0},
-  {".class", "dump-class-hierarchy", 0, 0},
-  {".original", "dump-tree-original", 0, 0},
-  {".optimized", "dump-tree-optimized", 0, 0},
-  {".inlined", "dump-tree-inlined", 0, 0},
-};
-
-/* Define a name->number mapping for a dump flag value.  */
-struct dump_option_value_info
-{
-  const char *const name;      /* the name of the value */
-  const int value;             /* the value of the name */
-};
-
-/* Table of dump options. This must be consistent with the TDF_* flags
-   in c-common.h */
-static const struct dump_option_value_info dump_options[] =
-{
-  {"address", TDF_ADDRESS},
-  {"slim", TDF_SLIM},
-  {"all", ~0},
-  {NULL, 0}
-};
-
-/* Begin a tree dump for PHASE. Stores any user supplied flag in
-   *FLAG_PTR and returns a stream to write to. If the dump is not
-   enabled, returns NULL.
-   Multiple calls will reopen and append to the dump file.  */
-
-FILE *
-dump_begin (phase, flag_ptr)
-     enum tree_dump_index phase;
-     int *flag_ptr;
-{
-  FILE *stream;
-  char *name;
-  
-  if (!dump_files[phase].state)
-    return NULL;
-  
-  name = concat (dump_base_name, dump_files[phase].suffix, NULL);
-  stream = fopen (name, dump_files[phase].state < 0 ? "w" : "a");
-  if (!stream)
-    error ("could not open dump file `%s'", name);
-  else
-    dump_files[phase].state = 1;
-  free (name);
-  if (flag_ptr)
-    *flag_ptr = dump_files[phase].flags;
-  
-  return stream;
-}
-
-/* Returns non-zero if tree dump PHASE is enabled.  */
-
-int
-dump_enabled_p (phase)
-     enum tree_dump_index phase;
-{
-  return dump_files[phase].state;
-}
-
-/* Returns the switch name of PHASE.  */
-
-const char *
-dump_flag_name (phase)
-     enum tree_dump_index phase;
-{
-  return dump_files[phase].swtch;
-}
-
-/* Finish a tree dump for PHASE. STREAM is the stream created by
-   dump_begin.  */
-
-void
-dump_end (phase, stream)
-     enum tree_dump_index phase ATTRIBUTE_UNUSED;
-     FILE *stream;
-{
-  fclose (stream);
-}
-
-/* Parse ARG as a dump switch. Return non-zero if it is, and store the
-   relevant details in the dump_files array.  */
-
-int
-dump_switch_p (arg)
-     const char *arg;
-{
-  unsigned ix;
-  const char *option_value;
-  
-  for (ix = 0; ix != TDI_end; ix++)
-    if ((option_value = skip_leading_substring (arg, dump_files[ix].swtch)))
-      {
-       const char *ptr = option_value;
-       int flags = 0;
-       
-       while (*ptr)
-         {
-           const struct dump_option_value_info *option_ptr;
-           const char *end_ptr;
-           unsigned length;
-           
-           while (*ptr == '-')
-             ptr++;
-           end_ptr = strchr (ptr, '-');
-           if (!end_ptr)
-             end_ptr = ptr + strlen (ptr);
-           length = end_ptr - ptr;
-           
-           for (option_ptr = dump_options; option_ptr->name;
-                option_ptr++)
-             if (strlen (option_ptr->name) == length
-                 && !memcmp (option_ptr->name, ptr, length))
-               {
-                 flags |= option_ptr->value;
-                 goto found;
-               }
-           warning ("ignoring unknown option `%.*s' in `-f%s'",
-                    length, ptr, dump_files[ix].swtch);
-         found:;
-           ptr = end_ptr;
-         }
-       
-       dump_files[ix].state = -1;
-       dump_files[ix].flags = flags;
-       
-       return 1;
-      }
-  return 0;
+  return false;

 }
 }