* configure: Regenerate.

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

diff --git a/gcc/tree-dump.c b/gcc/tree-dump.c
index 828ed0c..6821e36 100644 (file)
--- a/gcc/tree-dump.c
+++ b/gcc/tree-dump.c
@@ -1,12 +1,13 @@
 /* Tree-dumping functionality for intermediate representation.
 /* Tree-dumping functionality for intermediate representation.

-   Copyright (C) 1999, 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006, 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,9 +16,8 @@ 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"


@@ -31,20 +31,21 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "tree-pass.h"
 #include "langhooks.h"
 #include "tree-iterator.h"
 #include "tree-pass.h"
 #include "langhooks.h"
 #include "tree-iterator.h"

+#include "real.h"
+#include "fixed-value.h"

 
 

-static unsigned int queue (dump_info_p, tree, int);
+static unsigned int queue (dump_info_p, const_tree, int);

 static void dump_index (dump_info_p, unsigned int);
 static void dequeue_and_dump (dump_info_p);
 static void dump_new_line (dump_info_p);
 static void dump_maybe_newline (dump_info_p);
 static void dump_index (dump_info_p, unsigned int);
 static void dequeue_and_dump (dump_info_p);
 static void dump_new_line (dump_info_p);
 static void dump_maybe_newline (dump_info_p);

-static void dump_string_field (dump_info_p, const char *, const char *);

 static int dump_enable_all (int, int);
 
 /* Add T to the end of the queue of nodes to dump.  Returns the index
    assigned to T.  */
 
 static unsigned int
 static int dump_enable_all (int, int);
 
 /* Add T to the end of the queue of nodes to dump.  Returns the index
    assigned to T.  */
 
 static unsigned int

-queue (dump_info_p di, tree t, int flags)
+queue (dump_info_p di, const_tree t, int flags)

 {
   dump_queue_p dq;
   dump_node_info_p dni;
 {
   dump_queue_p dq;
   dump_node_info_p dni;


@@ -60,10 +61,10 @@ queue (dump_info_p di, tree t, int flags)
       di->free_list = dq->next;
     }
   else
       di->free_list = dq->next;
     }
   else

-    dq = xmalloc (sizeof (struct dump_queue));
+    dq = XNEW (struct dump_queue);

 
   /* Create a new entry in the splay-tree.  */
 
   /* Create a new entry in the splay-tree.  */

-  dni = xmalloc (sizeof (struct dump_node_info));
+  dni = XNEW (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,
   dni->index = index;
   dni->binfo_p = ((flags & DUMP_BINFO) != 0);
   dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t,


@@ -93,7 +94,7 @@ dump_index (dump_info_p di, unsigned int index)
    index of T is printed.  */
 
 void
    index of T is printed.  */
 
 void

-queue_and_dump_index (dump_info_p di, const char *field, tree t, int flags)
+queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags)

 {
   unsigned int index;
   splay_tree_node n;
 {
   unsigned int index;
   splay_tree_node n;


@@ -121,7 +122,7 @@ queue_and_dump_index (dump_info_p di, const char *field, tree t, int flags)
 /* Dump the type of T.  */
 
 void
 /* Dump the type of T.  */
 
 void

-queue_and_dump_type (dump_info_p di, tree t)
+queue_and_dump_type (dump_info_p di, const_tree t)

 {
   queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
 }
 {
   queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
 }


@@ -165,7 +166,7 @@ void
 dump_pointer (dump_info_p di, const char *field, void *ptr)
 {
   dump_maybe_newline (di);
 dump_pointer (dump_info_p di, const char *field, void *ptr)
 {
   dump_maybe_newline (di);

-  fprintf (di->stream, "%-4s: %-8lx ", field, (long) ptr);
+  fprintf (di->stream, "%-4s: %-8lx ", field, (unsigned long) ptr);

   di->column += 15;
 }
 
   di->column += 15;
 }
 


@@ -179,6 +180,31 @@ dump_int (dump_info_p di, const char *field, int i)
   di->column += 14;
 }
 
   di->column += 14;
 }
 

+/* Dump the floating point value R, using FIELD to identify it.  */
+
+static void
+dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r)
+{
+  char buf[32];
+  real_to_decimal (buf, r, sizeof (buf), 0, true);
+  dump_maybe_newline (di);
+  fprintf (di->stream, "%-4s: %s ", field, buf);
+  di->column += strlen (buf) + 7;
+}
+
+/* Dump the fixed-point value F, using FIELD to identify it.  */
+
+static void
+dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f)
+{
+  char buf[32];
+  fixed_to_decimal (buf, f, sizeof (buf));
+  dump_maybe_newline (di);
+  fprintf (di->stream, "%-4s: %s ", field, buf);
+  di->column += strlen (buf) + 7;
+}
+
+

 /* Dump the string S.  */
 
 void
 /* Dump the string S.  */
 
 void


@@ -194,7 +220,7 @@ dump_string (dump_info_p di, const char *string)
 
 /* Dump the string field S.  */
 
 
 /* Dump the string field S.  */
 

-static void
+void

 dump_string_field (dump_info_p di, const char *field, const char *string)
 {
   dump_maybe_newline (di);
 dump_string_field (dump_info_p di, const char *field, const char *string)
 {
   dump_maybe_newline (di);


@@ -253,12 +279,12 @@ dequeue_and_dump (dump_info_p di)
     {
       unsigned ix;
       tree base;
     {
       unsigned ix;
       tree base;

-      VEC (tree) *accesses = BINFO_BASE_ACCESSES (t);
+      VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);

 
       dump_child ("type", BINFO_TYPE (t));
 
       if (BINFO_VIRTUAL_P (t))
 
       dump_child ("type", BINFO_TYPE (t));
 
       if (BINFO_VIRTUAL_P (t))

-       dump_string (di, "virt");
+       dump_string_field (di, "spec", "virt");

 
       dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
       for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
 
       dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
       for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)


@@ -276,7 +302,7 @@ dequeue_and_dump (dump_info_p di)
          else
            gcc_unreachable ();
 
          else
            gcc_unreachable ();
 

-         dump_string (di, string);
+         dump_string_field (di, "accs", string);

          queue_and_dump_index (di, "binf", base, DUMP_BINFO);
        }
 
          queue_and_dump_index (di, "binf", base, DUMP_BINFO);
        }
 


@@ -305,6 +331,7 @@ dequeue_and_dump (dump_info_p di)
        case tcc_expression:
        case tcc_reference:
        case tcc_statement:
        case tcc_expression:
        case tcc_reference:
        case tcc_statement:

+       case tcc_vl_exp:

          /* These nodes are handled explicitly below.  */
          break;
 
          /* These nodes are handled explicitly below.  */
          break;
 


@@ -321,6 +348,8 @@ dequeue_and_dump (dump_info_p di)
       if (DECL_ASSEMBLER_NAME_SET_P (t)
          && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
        dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
       if (DECL_ASSEMBLER_NAME_SET_P (t)
          && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
        dump_child ("mngl", DECL_ASSEMBLER_NAME (t));

+      if (DECL_ABSTRACT_ORIGIN (t))
+        dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));

       /* And types.  */
       queue_and_dump_type (di, t);
       dump_child ("scpe", DECL_CONTEXT (t));
       /* And types.  */
       queue_and_dump_type (di, t);
       dump_child ("scpe", DECL_CONTEXT (t));


@@ -341,8 +370,9 @@ dequeue_and_dump (dump_info_p di)
          di->column += 6 + strlen (filename) + 8;
        }
       /* And any declaration can be compiler-generated.  */
          di->column += 6 + strlen (filename) + 8;
        }
       /* And any declaration can be compiler-generated.  */

-      if (DECL_ARTIFICIAL (t))
-       dump_string (di, "artificial");
+      if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
+         && DECL_ARTIFICIAL (t))
+       dump_string_field (di, "note", "artificial");

       if (TREE_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
        dump_child ("chan", TREE_CHAIN (t));
     }
       if (TREE_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
        dump_child ("chan", TREE_CHAIN (t));
     }


@@ -424,8 +454,7 @@ dequeue_and_dump (dump_info_p di)
     case INTEGER_TYPE:
     case ENUMERAL_TYPE:
       dump_int (di, "prec", TYPE_PRECISION (t));
     case INTEGER_TYPE:
     case ENUMERAL_TYPE:
       dump_int (di, "prec", TYPE_PRECISION (t));

-      if (TYPE_UNSIGNED (t))
-       dump_string (di, "unsigned");
+      dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");

       dump_child ("min", TYPE_MIN_VALUE (t));
       dump_child ("max", TYPE_MAX_VALUE (t));
 
       dump_child ("min", TYPE_MIN_VALUE (t));
       dump_child ("max", TYPE_MAX_VALUE (t));
 


@@ -437,6 +466,13 @@ dequeue_and_dump (dump_info_p di)
       dump_int (di, "prec", TYPE_PRECISION (t));
       break;
 
       dump_int (di, "prec", TYPE_PRECISION (t));
       break;
 

+    case FIXED_POINT_TYPE:
+      dump_int (di, "prec", TYPE_PRECISION (t));
+      dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
+      dump_string_field (di, "saturating",
+                        TYPE_SATURATING (t) ? "saturating": "non-saturating");
+      break;
+

     case POINTER_TYPE:
       dump_child ("ptd", TREE_TYPE (t));
       break;
     case POINTER_TYPE:
       dump_child ("ptd", TREE_TYPE (t));
       break;


@@ -462,9 +498,9 @@ dequeue_and_dump (dump_info_p di)
     case RECORD_TYPE:
     case UNION_TYPE:
       if (TREE_CODE (t) == RECORD_TYPE)
     case RECORD_TYPE:
     case UNION_TYPE:
       if (TREE_CODE (t) == RECORD_TYPE)

-       dump_string (di, "struct");
+       dump_string_field (di, "tag", "struct");

       else
       else

-       dump_string (di, "union");
+       dump_string_field (di, "tag", "union");

 
       dump_child ("flds", TYPE_FIELDS (t));
       dump_child ("fncs", TYPE_METHODS (t));
 
       dump_child ("flds", TYPE_FIELDS (t));
       dump_child ("fncs", TYPE_METHODS (t));


@@ -475,6 +511,11 @@ dequeue_and_dump (dump_info_p di)
     case CONST_DECL:
       dump_child ("cnst", DECL_INITIAL (t));
       break;
     case CONST_DECL:
       dump_child ("cnst", DECL_INITIAL (t));
       break;

+      
+    case SYMBOL_MEMORY_TAG:
+    case NAME_MEMORY_TAG:
+    case STRUCT_FIELD_TAG:
+      break;

 
     case VAR_DECL:
     case PARM_DECL:
 
     case VAR_DECL:
     case PARM_DECL:


@@ -497,18 +538,18 @@ dequeue_and_dump (dump_info_p di)
        {
          dump_int (di, "used", TREE_USED (t));
          if (DECL_REGISTER (t))
        {
          dump_int (di, "used", TREE_USED (t));
          if (DECL_REGISTER (t))

-           dump_string (di, "register");
+           dump_string_field (di, "spec", "register");

        }
       break;
 
     case FUNCTION_DECL:
       dump_child ("args", DECL_ARGUMENTS (t));
       if (DECL_EXTERNAL (t))
        }
       break;
 
     case FUNCTION_DECL:
       dump_child ("args", DECL_ARGUMENTS (t));
       if (DECL_EXTERNAL (t))

-       dump_string (di, "undefined");
+       dump_string_field (di, "body", "undefined");

       if (TREE_PUBLIC (t))
       if (TREE_PUBLIC (t))

-       dump_string (di, "extern");
+       dump_string_field (di, "link", "extern");

       else
       else

-       dump_string (di, "static");
+       dump_string_field (di, "link", "static");

       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
        dump_child ("body", DECL_SAVED_TREE (t));
       break;
       if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
        dump_child ("body", DECL_SAVED_TREE (t));
       break;


@@ -524,6 +565,14 @@ dequeue_and_dump (dump_info_p di)
       dump_int (di, "lngt", TREE_STRING_LENGTH (t));
       break;
 
       dump_int (di, "lngt", TREE_STRING_LENGTH (t));
       break;
 

+    case REAL_CST:
+      dump_real (di, "valu", TREE_REAL_CST_PTR (t));
+      break;
+
+    case FIXED_CST:
+      dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
+      break;
+

     case TRUTH_NOT_EXPR:
     case ADDR_EXPR:
     case INDIRECT_REF:
     case TRUTH_NOT_EXPR:
     case ADDR_EXPR:
     case INDIRECT_REF:


@@ -551,6 +600,11 @@ dequeue_and_dump (dump_info_p di)
       dump_child ("op 1", TREE_OPERAND (t, 1));
       break;
 
       dump_child ("op 1", TREE_OPERAND (t, 1));
       break;
 

+    case GIMPLE_MODIFY_STMT:
+      dump_child ("op 0", GIMPLE_STMT_OPERAND (t, 0));
+      dump_child ("op 1", GIMPLE_STMT_OPERAND (t, 1));
+      break;
+

     case COMPONENT_REF:
       dump_child ("op 0", TREE_OPERAND (t, 0));
       dump_child ("op 1", TREE_OPERAND (t, 1));
     case COMPONENT_REF:
       dump_child ("op 0", TREE_OPERAND (t, 0));
       dump_child ("op 1", TREE_OPERAND (t, 1));


@@ -571,13 +625,39 @@ dequeue_and_dump (dump_info_p di)
       dump_child ("op 2", TREE_OPERAND (t, 2));
       break;
 
       dump_child ("op 2", TREE_OPERAND (t, 2));
       break;
 

+    case TRY_FINALLY_EXPR:
+      dump_child ("op 0", TREE_OPERAND (t, 0));
+      dump_child ("op 1", TREE_OPERAND (t, 1));
+      break;
+

     case CALL_EXPR:
     case CALL_EXPR:

-      dump_child ("fn", TREE_OPERAND (t, 0));
-      dump_child ("args", TREE_OPERAND (t, 1));
+      {
+       int i = 0;
+       tree arg;
+       call_expr_arg_iterator iter;
+       dump_child ("fn", CALL_EXPR_FN (t));
+       FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
+         {
+           char buffer[32];
+           sprintf (buffer, "%u", i);
+           dump_child (buffer, arg);
+           i++;
+         }
+      }

       break;
 
     case CONSTRUCTOR:
       break;
 
     case CONSTRUCTOR:

-      dump_child ("elts", CONSTRUCTOR_ELTS (t));
+      {
+       unsigned HOST_WIDE_INT cnt;
+       tree index, value;
+       dump_int (di, "lngt", VEC_length (constructor_elt,
+                                         CONSTRUCTOR_ELTS (t)));
+       FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
+         {
+           dump_child ("idx", index);
+           dump_child ("val", value);
+         }
+      }

       break;
 
     case BIND_EXPR:
       break;
 
     case BIND_EXPR:


@@ -593,6 +673,10 @@ dequeue_and_dump (dump_info_p di)
       dump_child ("cond", TREE_OPERAND (t, 0));
       break;
 
       dump_child ("cond", TREE_OPERAND (t, 0));
       break;
 

+    case RETURN_EXPR:
+      dump_child ("expr", TREE_OPERAND (t, 0));
+      break;
+

     case TARGET_EXPR:
       dump_child ("decl", TREE_OPERAND (t, 0));
       dump_child ("init", TREE_OPERAND (t, 1));
     case TARGET_EXPR:
       dump_child ("decl", TREE_OPERAND (t, 0));
       dump_child ("init", TREE_OPERAND (t, 1));


@@ -604,6 +688,37 @@ dequeue_and_dump (dump_info_p di)
       dump_child ("init", TREE_OPERAND (t, 3));
       break;
 
       dump_child ("init", TREE_OPERAND (t, 3));
       break;
 

+    case CASE_LABEL_EXPR:
+      dump_child ("name", CASE_LABEL (t));
+      if (CASE_LOW (t))
+       {
+         dump_child ("low ", CASE_LOW (t));
+         if (CASE_HIGH (t))
+           dump_child ("high", CASE_HIGH (t));
+       }
+      break;
+    case LABEL_EXPR:
+      dump_child ("name", TREE_OPERAND (t,0));
+      break;
+    case GOTO_EXPR:
+      dump_child ("labl", TREE_OPERAND (t, 0));
+      break;
+    case SWITCH_EXPR:
+      dump_child ("cond", TREE_OPERAND (t, 0));
+      dump_child ("body", TREE_OPERAND (t, 1));
+      if (TREE_OPERAND (t, 2))
+        {
+         dump_child ("labl", TREE_OPERAND (t,2));
+        }
+      break;
+    case OMP_CLAUSE:
+      {
+       int i;
+       fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]);
+       for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
+         dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i));
+      }
+      break;

     default:
       /* There are no additional fields to print.  */
       break;
     default:
       /* There are no additional fields to print.  */
       break;


@@ -620,7 +735,7 @@ dequeue_and_dump (dump_info_p di)
 /* Return nonzero if FLAG has been specified for the dump, and NODE
    is not the root node of the dump.  */
 
 /* Return nonzero if FLAG has been specified for the dump, and NODE
    is not the root node of the dump.  */
 

-int dump_flag (dump_info_p di, int flag, tree node)
+int dump_flag (dump_info_p di, int flag, const_tree node)

 {
   return (di->flags & flag) && (node != di->node);
 }
 {
   return (di->flags & flag) && (node != di->node);
 }


@@ -628,7 +743,7 @@ int dump_flag (dump_info_p di, int flag, tree node)
 /* Dump T, and all its children, on STREAM.  */
 
 void
 /* Dump T, and all its children, on STREAM.  */
 
 void

-dump_node (tree t, int flags, FILE *stream)
+dump_node (const_tree t, int flags, FILE *stream)

 {
   struct dump_info di;
   dump_queue_p dq;
 {
   struct dump_info di;
   dump_queue_p dq;


@@ -664,59 +779,23 @@ dump_node (tree t, int flags, FILE *stream)
 \f
 
 /* Table of tree dump switches. This must be consistent with the
 \f
 
 /* Table of tree dump switches. This must be consistent with the

-   TREE_DUMP_INDEX enumeration in tree.h */
+   tree_dump_index enumeration in tree-pass.h.  */

 static struct dump_file_info dump_files[TDI_end] =
 {
   {NULL, NULL, NULL, 0, 0, 0, 0},
 static struct dump_file_info dump_files[TDI_end] =
 {
   {NULL, NULL, NULL, 0, 0, 0, 0},

-  {".tu", "translation-unit", NULL, TDF_TREE, 0, 0, 0},
-  {".class", "class-hierarchy", NULL, TDF_TREE, 0, 1, 0},
-  {".original", "tree-original", NULL, TDF_TREE, 0, 2, 0},
-  {".generic", "tree-generic", NULL, TDF_TREE, 0, 3, 0},
-  {".nested", "tree-nested", NULL, TDF_TREE, 0, 4, 0},
-  {".inlined", "tree-inlined", NULL, TDF_TREE, 0, 5, 0},
-  {".vcg", "tree-vcg", NULL, TDF_TREE, 0, 6, 0},
+  {".cgraph", "ipa-cgraph", NULL, TDF_IPA, 0,  0, 0},
+  {".tu", "translation-unit", NULL, TDF_TREE, 0, 1, 0},
+  {".class", "class-hierarchy", NULL, TDF_TREE, 0, 2, 0},
+  {".original", "tree-original", NULL, TDF_TREE, 0, 3, 0},
+  {".gimple", "tree-gimple", NULL, TDF_TREE, 0, 4, 0},
+  {".nested", "tree-nested", NULL, TDF_TREE, 0, 5, 0},
+  {".inlined", "tree-inlined", NULL, TDF_TREE, 0, 6, 0},
+  {".vcg", "tree-vcg", NULL, TDF_TREE, 0, 7, 0},
+#define FIRST_AUTO_NUMBERED_DUMP 8
+

   {NULL, "tree-all", NULL, TDF_TREE, 0, 0, 0},
   {NULL, "rtl-all", NULL, TDF_RTL, 0, 0, 0},
   {NULL, "ipa-all", NULL, TDF_IPA, 0, 0, 0},
   {NULL, "tree-all", NULL, TDF_TREE, 0, 0, 0},
   {NULL, "rtl-all", NULL, TDF_RTL, 0, 0, 0},
   {NULL, "ipa-all", NULL, TDF_IPA, 0, 0, 0},

-
-  { ".cgraph", "ipa-cgraph", NULL,     TDF_IPA, 0,  1, 0},
-
-  { ".sibling", "rtl-sibling", NULL,   TDF_RTL, 0,  1, 'i'},
-  { ".eh", "rtl-eh", NULL,             TDF_RTL, 0,  2, 'h'},
-  { ".jump", "rtl-jump", NULL,         TDF_RTL, 0,  3, 'j'},
-  { ".cse", "rtl-cse", NULL,            TDF_RTL, 0,  4, 's'},
-  { ".gcse", "rtl-gcse", NULL,         TDF_RTL, 0,  5, 'G'},
-  { ".loop", "rtl-loop", NULL,         TDF_RTL, 0,  6, 'L'},
-  { ".bypass", "rtl-bypass", NULL,             TDF_RTL, 0,  7, 'G'},
-  { ".cfg", "rtl-cfg", NULL,                   TDF_RTL, 0,  8, 'f'},
-  { ".bp", "rtl-bp", NULL,                     TDF_RTL, 0,  9, 'b'},
-  { ".vpt", "rtl-vpt", NULL,                   TDF_RTL, 0, 10, 'V'},
-  { ".ce1", "rtl-ce1", NULL,                   TDF_RTL, 0, 11, 'C'},
-  { ".tracer", "rtl-tracer", NULL,             TDF_RTL, 0, 12, 'T'},
-  { ".loop2", "rtl-loop2", NULL,               TDF_RTL, 0, 13, 'L'},
-  { ".web", "rtl-web", NULL,                   TDF_RTL, 0, 14, 'Z'},
-  { ".cse2", "rtl-cse2", NULL,         TDF_RTL, 0, 15, 't'},
-  { ".life", "rtl-life", NULL,         TDF_RTL, 0, 16, 'f'},
-  { ".combine", "rtl-combine", NULL,           TDF_RTL, 0, 17, 'c'},
-  { ".ce2", "rtl-ce2", NULL,                   TDF_RTL, 0, 18, 'C'},
-  { ".regmove", "rtl-regmove", NULL,           TDF_RTL, 0, 19, 'N'},
-  { ".sms", "rtl-sms", NULL,                   TDF_RTL, 0, 20, 'm'},
-  { ".sched", "rtl-sched", NULL,               TDF_RTL, 0, 21, 'S'},
-  { ".lreg", "rtl-lreg", NULL,         TDF_RTL, 0, 22, 'l'},
-  { ".greg", "rtl-greg", NULL,         TDF_RTL, 0, 23, 'g'},
-  { ".postreload", "rtl-postreload", NULL,     TDF_RTL, 0, 24, 'o'},
-  { ".gcse2", "rtl-gcse2", NULL,               TDF_RTL, 0, 25, 'J'},
-  { ".flow2", "rtl-flow2", NULL,               TDF_RTL, 0, 26, 'w'},
-  { ".peephole2", "rtl-peephole2", NULL,       TDF_RTL, 0, 27, 'z'},
-  { ".ce3", "rtl-ce3", NULL,                   TDF_RTL, 0, 28, 'E'},
-  { ".rnreg", "rtl-rnreg", NULL,               TDF_RTL, 0, 29, 'n'},
-  { ".bbro", "rtl-bbro", NULL,         TDF_RTL, 0, 30, 'B'},
-  { ".btl", "rtl-btl", NULL,                   TDF_RTL, 0, 31, 'd'},
-  { ".sched2", "rtl-sched2", NULL,             TDF_RTL, 0, 32, 'R'},
-  { ".stack", "rtl-stack", NULL,               TDF_RTL, 0, 33, 'k'},
-  { ".vartrack", "rtl-vartrack", NULL, TDF_RTL, 0, 34, 'V'},
-  { ".mach", "rtl-mach", NULL,         TDF_RTL, 0, 35, 'M'},
-  { ".dbr", "rtl-dbr", NULL,                   TDF_RTL, 0, 36, 'd'}

 };
 
 /* Dynamically registered tree dump files and switches.  */
 };
 
 /* Dynamically registered tree dump files and switches.  */


@@ -744,14 +823,20 @@ static const struct dump_option_value_info dump_options[] =
   {"vops", TDF_VOPS},
   {"lineno", TDF_LINENO},
   {"uid", TDF_UID},
   {"vops", TDF_VOPS},
   {"lineno", TDF_LINENO},
   {"uid", TDF_UID},

-  {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA)},
+  {"stmtaddr", TDF_STMTADDR},
+  {"memsyms", TDF_MEMSYMS},
+  {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA 
+           | TDF_STMTADDR | TDF_GRAPH | TDF_DIAGNOSTIC)},

   {NULL, 0}
 };
 
 unsigned int
 dump_register (const char *suffix, const char *swtch, const char *glob,
   {NULL, 0}
 };
 
 unsigned int
 dump_register (const char *suffix, const char *swtch, const char *glob,

-              int flags, unsigned int num, int letter)
+              int flags, int letter)

 {
 {

+  static int next_dump = FIRST_AUTO_NUMBERED_DUMP;
+  int num = next_dump++;
+

   size_t this = extra_dump_files_in_use++;
 
   if (this >= extra_dump_files_alloced)
   size_t this = extra_dump_files_in_use++;
 
   if (this >= extra_dump_files_alloced)


@@ -797,7 +882,7 @@ get_dump_file_info (enum tree_dump_index phase)
 char *
 get_dump_file_name (enum tree_dump_index phase)
 {
 char *
 get_dump_file_name (enum tree_dump_index phase)
 {

-  char dump_id[7];
+  char dump_id[10];

   struct dump_file_info *dfi;
 
   if (phase == TDI_none)
   struct dump_file_info *dfi;
 
   if (phase == TDI_none)


@@ -811,15 +896,15 @@ get_dump_file_name (enum tree_dump_index phase)
     dump_id[0] = '\0';
   else
     {
     dump_id[0] = '\0';
   else
     {

-      const char *template;
+      char suffix;

       if (dfi->flags & TDF_TREE)
       if (dfi->flags & TDF_TREE)

-       template = ".t%02d";
+       suffix = 't';

       else if (dfi->flags & TDF_IPA)
       else if (dfi->flags & TDF_IPA)

-       template = ".i%02d";
+       suffix = 'i';

       else
       else

-       template = ".%02d";
+       suffix = 'r';

 
 

-      if (snprintf (dump_id, sizeof (dump_id), template, dfi->num) < 0)
+      if (snprintf (dump_id, sizeof (dump_id), ".%03d%c", dfi->num, suffix) < 0)

        dump_id[0] = '\0';
     }
 
        dump_id[0] = '\0';
     }
 


@@ -856,13 +941,28 @@ dump_begin (enum tree_dump_index phase, int *flag_ptr)
   return stream;
 }
 
   return stream;
 }
 

-/* Returns nonzero if tree dump PHASE is enabled.  */
+/* Returns nonzero if tree dump PHASE is enabled.  If PHASE is
+   TDI_tree_all, return nonzero if any dump is enabled.  */

 
 int
 dump_enabled_p (enum tree_dump_index phase)
 {
 
 int
 dump_enabled_p (enum tree_dump_index phase)
 {

-  struct dump_file_info *dfi = get_dump_file_info (phase);
-  return dfi->state;
+  if (phase == TDI_tree_all)
+    {
+      size_t i;
+      for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
+       if (dump_files[i].state)
+         return 1;
+      for (i = 0; i < extra_dump_files_in_use; i++)
+       if (extra_dump_files[i].state)
+         return 1;
+      return 0;
+    }
+  else
+    {
+      struct dump_file_info *dfi = get_dump_file_info (phase);
+      return dfi->state;
+    }

 }
 
 /* Returns nonzero if tree dump PHASE has been initialized.  */
 }
 
 /* Returns nonzero if tree dump PHASE has been initialized.  */


@@ -897,24 +997,25 @@ dump_end (enum tree_dump_index phase ATTRIBUTE_UNUSED, FILE *stream)
 static int
 dump_enable_all (int flags, int letter)
 {
 static int
 dump_enable_all (int flags, int letter)
 {

+  int ir_dump_type = (flags & (TDF_TREE | TDF_RTL | TDF_IPA));

   int n = 0;
   size_t i;
 
   for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
   int n = 0;
   size_t i;
 
   for (i = TDI_none + 1; i < (size_t) TDI_end; i++)

-    if ((dump_files[i].flags & flags)
+    if ((dump_files[i].flags & ir_dump_type)

        && (letter == 0 || letter == dump_files[i].letter))
       {
         dump_files[i].state = -1;
        && (letter == 0 || letter == dump_files[i].letter))
       {
         dump_files[i].state = -1;

-        dump_files[i].flags = flags;
+        dump_files[i].flags |= flags;

         n++;
       }
 
   for (i = 0; i < extra_dump_files_in_use; i++)
         n++;
       }
 
   for (i = 0; i < extra_dump_files_in_use; i++)

-    if ((extra_dump_files[i].flags & flags)
+    if ((extra_dump_files[i].flags & ir_dump_type)

        && (letter == 0 || letter == extra_dump_files[i].letter))
       {
         extra_dump_files[i].state = -1;
        && (letter == 0 || letter == extra_dump_files[i].letter))
       {
         extra_dump_files[i].state = -1;

-        extra_dump_files[i].flags = flags;
+        extra_dump_files[i].flags |= flags;

        n++;
       }
 
        n++;
       }
 


@@ -938,6 +1039,9 @@ dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob)
   if (!option_value)
     return 0;
 
   if (!option_value)
     return 0;
 

+  if (*option_value && *option_value != '-')
+    return 0;
+

   ptr = option_value;
   flags = 0;
 
   ptr = option_value;
   flags = 0;
 


@@ -961,7 +1065,7 @@ dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob)
            flags |= option_ptr->value;
            goto found;
          }
            flags |= option_ptr->value;
            goto found;
          }

-      warning ("ignoring unknown option %q.*s in %<-fdump-%s%>",
+      warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",

               length, ptr, dfi->swtch);
     found:;
       ptr = end_ptr;
               length, ptr, dfi->swtch);
     found:;
       ptr = end_ptr;


@@ -1025,7 +1129,7 @@ enable_rtl_dump_file (int letter)
   if (letter == 'a')
     letter = 0;
 
   if (letter == 'a')
     letter = 0;
 

-  return dump_enable_all (TDF_RTL, letter) > 0;
+  return dump_enable_all (TDF_RTL | TDF_DETAILS | TDF_BLOCKS, letter) > 0;

 }
 
 
 }