* tree-pretty-print.c (dump_location): New.

[pf3gnuchains/gcc-fork.git] / gcc / tree-pretty-print.c

diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index 17de6f3..02b6365 100644 (file)
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -1,12 +1,13 @@
 /* Pretty formatting of GENERIC trees in C syntax.
 /* Pretty formatting of GENERIC trees in C syntax.

-   Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+   Free Software Foundation, Inc.

    Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.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
    Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.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,15 +16,15 @@ 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, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */

 
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
 #include "tree.h"
 
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
 #include "tree.h"

+#include "output.h"

 #include "diagnostic.h"
 #include "real.h"
 #include "hashtab.h"
 #include "diagnostic.h"
 #include "real.h"
 #include "hashtab.h"


@@ -32,19 +33,18 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #include "tree-iterator.h"
 #include "tree-chrec.h"
 #include "tree-pass.h"
 #include "tree-iterator.h"
 #include "tree-chrec.h"
 #include "tree-pass.h"

+#include "fixed-value.h"
+#include "value-prof.h"
+#include "predict.h"

 
 /* Local functions, macros and variables.  */
 
 /* Local functions, macros and variables.  */

-static int op_prio (tree);
-static const char *op_symbol (tree);
+static const char *op_symbol (const_tree);

 static void pretty_print_string (pretty_printer *, const char*);
 static void pretty_print_string (pretty_printer *, const char*);

-static void print_call_name (pretty_printer *, tree);
+static void print_call_name (pretty_printer *, const_tree);

 static void newline_and_indent (pretty_printer *, int);
 static void maybe_init_pretty_print (FILE *);
 static void newline_and_indent (pretty_printer *, int);
 static void maybe_init_pretty_print (FILE *);

-static void print_declaration (pretty_printer *, tree, int, int);
-static void print_struct_decl (pretty_printer *, tree, int, int);
-static void do_niy (pretty_printer *, tree);
-static void dump_vops (pretty_printer *, tree, int, int);
-static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
+static void print_struct_decl (pretty_printer *, const_tree, int, int);
+static void do_niy (pretty_printer *, const_tree);

 
 #define INDENT(SPACE) do { \
   int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
 
 #define INDENT(SPACE) do { \
   int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)


@@ -58,12 +58,11 @@ static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
 
 static pretty_printer buffer;
 static int initialized = 0;
 
 static pretty_printer buffer;
 static int initialized = 0;

-static bool dumping_stmts;

 
 /* Try to print something for an unknown tree code.  */
 
 static void
 
 /* Try to print something for an unknown tree code.  */
 
 static void

-do_niy (pretty_printer *buffer, tree node)
+do_niy (pretty_printer *buffer, const_tree node)

 {
   int i, len;
 
 {
   int i, len;
 


@@ -72,7 +71,7 @@ do_niy (pretty_printer *buffer, tree node)
 
   if (EXPR_P (node))
     {
 
   if (EXPR_P (node))
     {

-      len = TREE_CODE_LENGTH (TREE_CODE (node));
+      len = TREE_OPERAND_LENGTH (node);

       for (i = 0; i < len; ++i)
        {
          newline_and_indent (buffer, 2);
       for (i = 0; i < len; ++i)
        {
          newline_and_indent (buffer, 2);


@@ -83,17 +82,35 @@ do_niy (pretty_printer *buffer, tree node)
   pp_string (buffer, " >>>\n");
 }
 
   pp_string (buffer, " >>>\n");
 }
 

+/* Debugging function to print out a generic expression.  */
+

 void
 debug_generic_expr (tree t)
 {
 void
 debug_generic_expr (tree t)
 {

-  print_generic_expr (stderr, t, TDF_VOPS|TDF_UID);
+  print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);

   fprintf (stderr, "\n");
 }
 
   fprintf (stderr, "\n");
 }
 

+/* Debugging function to print out a generic statement.  */
+

 void
 debug_generic_stmt (tree t)
 {
 void
 debug_generic_stmt (tree t)
 {

-  print_generic_stmt (stderr, t, TDF_VOPS|TDF_UID);
+  print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
+  fprintf (stderr, "\n");
+}
+
+/* Debugging function to print out a chain of trees .  */
+
+void
+debug_tree_chain (tree t)
+{
+  while (t)
+  {
+    print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
+    fprintf(stderr, " ");
+    t = TREE_CHAIN (t);
+  }

   fprintf (stderr, "\n");
 }
 
   fprintf (stderr, "\n");
 }
 


@@ -102,25 +119,23 @@ void
 print_generic_decl (FILE *file, tree decl, int flags)
 {
   maybe_init_pretty_print (file);
 print_generic_decl (FILE *file, tree decl, int flags)
 {
   maybe_init_pretty_print (file);

-  dumping_stmts = true;

   print_declaration (&buffer, decl, 2, flags);
   pp_write_text_to_stream (&buffer);
 }
 
 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
   print_declaration (&buffer, decl, 2, flags);
   pp_write_text_to_stream (&buffer);
 }
 
 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details

-   to show in the dump.  See TDF_* in tree.h.  */
+   to show in the dump.  See TDF_* in tree-pass.h.  */

 
 void
 print_generic_stmt (FILE *file, tree t, int flags)
 {
   maybe_init_pretty_print (file);
 
 void
 print_generic_stmt (FILE *file, tree t, int flags)
 {
   maybe_init_pretty_print (file);

-  dumping_stmts = true;

   dump_generic_node (&buffer, t, 0, flags, true);
   pp_flush (&buffer);
 }
 
 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
   dump_generic_node (&buffer, t, 0, flags, true);
   pp_flush (&buffer);
 }
 
 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details

-   to show in the dump.  See TDF_* in tree.h.  The output is indented by
+   to show in the dump.  See TDF_* in tree-pass.h.  The output is indented by

    INDENT spaces.  */
 
 void
    INDENT spaces.  */
 
 void


@@ -129,7 +144,6 @@ print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
   int i;
 
   maybe_init_pretty_print (file);
   int i;
 
   maybe_init_pretty_print (file);

-  dumping_stmts = true;

 
   for (i = 0; i < indent; i++)
     pp_space (&buffer);
 
   for (i = 0; i < indent; i++)
     pp_space (&buffer);


@@ -138,13 +152,12 @@ print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
 }
 
 /* Print a single expression T on file FILE.  FLAGS specifies details to show
 }
 
 /* Print a single expression T on file FILE.  FLAGS specifies details to show

-   in the dump.  See TDF_* in tree.h.  */
+   in the dump.  See TDF_* in tree-pass.h.  */

 
 void
 print_generic_expr (FILE *file, tree t, int flags)
 {
   maybe_init_pretty_print (file);
 
 void
 print_generic_expr (FILE *file, tree t, int flags)
 {
   maybe_init_pretty_print (file);

-  dumping_stmts = false;

   dump_generic_node (&buffer, t, 0, flags, false);
 }
 
   dump_generic_node (&buffer, t, 0, flags, false);
 }
 


@@ -154,20 +167,20 @@ print_generic_expr (FILE *file, tree t, int flags)
 static void
 dump_decl_name (pretty_printer *buffer, tree node, int flags)
 {
 static void
 dump_decl_name (pretty_printer *buffer, tree node, int flags)
 {

-  if (DECL_NAME (node))
-    pp_tree_identifier (buffer, DECL_NAME (node));
+  tree t = node;

 
 

+  if (DECL_NAME (t))
+    pp_tree_identifier (buffer, DECL_NAME (t));

   if ((flags & TDF_UID)
   if ((flags & TDF_UID)

-      || DECL_NAME (node) == NULL_TREE)
+      || DECL_NAME (t) == NULL_TREE)

     {
     {

-      if (TREE_CODE (node) == LABEL_DECL
-         && LABEL_DECL_UID (node) != -1)
-       pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
-                  LABEL_DECL_UID (node));
+      if (TREE_CODE (t) == LABEL_DECL
+          && LABEL_DECL_UID (t) != -1)
+        pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (t));

       else
        {
       else
        {

-         char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
-         pp_printf (buffer, "%c.%u", c, DECL_UID (node));
+         char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
+         pp_printf (buffer, "%c.%u", c, DECL_UID (t));

        }
     }
 }
        }
     }
 }


@@ -246,10 +259,303 @@ dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
   pp_character (buffer, ']');
 }
 
   pp_character (buffer, ']');
 }
 

-/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
-   FLAGS specifies details to show in the dump (see TDF_* in tree.h).  If
-   IS_STMT is true, the object printed is considered to be a statement
-   and it is terminated by ';' if appropriate.  */
+
+/* Dump OpenMP clause CLAUSE.  BUFFER, CLAUSE, SPC and FLAGS are as in
+   dump_generic_node.  */
+
+static void
+dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
+{
+  const char *name;
+
+  switch (OMP_CLAUSE_CODE (clause))
+    {
+    case OMP_CLAUSE_PRIVATE:
+      name = "private";
+      goto print_remap;
+    case OMP_CLAUSE_SHARED:
+      name = "shared";
+      goto print_remap;
+    case OMP_CLAUSE_FIRSTPRIVATE:
+      name = "firstprivate";
+      goto print_remap;
+    case OMP_CLAUSE_LASTPRIVATE:
+      name = "lastprivate";
+      goto print_remap;
+    case OMP_CLAUSE_COPYIN:
+      name = "copyin";
+      goto print_remap;
+    case OMP_CLAUSE_COPYPRIVATE:
+      name = "copyprivate";
+      goto print_remap;
+  print_remap:
+      pp_string (buffer, name);
+      pp_character (buffer, '(');
+      dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
+         spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+
+    case OMP_CLAUSE_REDUCTION:
+      pp_string (buffer, "reduction(");
+      pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
+      pp_character (buffer, ':');
+      dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
+         spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+
+    case OMP_CLAUSE_IF:
+      pp_string (buffer, "if(");
+      dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
+         spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+
+    case OMP_CLAUSE_NUM_THREADS:
+      pp_string (buffer, "num_threads(");
+      dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
+         spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+
+    case OMP_CLAUSE_NOWAIT:
+      pp_string (buffer, "nowait");
+      break;
+    case OMP_CLAUSE_ORDERED:
+      pp_string (buffer, "ordered");
+      break;
+
+    case OMP_CLAUSE_DEFAULT:
+      pp_string (buffer, "default(");
+      switch (OMP_CLAUSE_DEFAULT_KIND (clause))
+       {
+       case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
+         break;
+       case OMP_CLAUSE_DEFAULT_SHARED:
+         pp_string (buffer, "shared");
+         break;
+       case OMP_CLAUSE_DEFAULT_NONE:
+         pp_string (buffer, "none");
+         break;
+       case OMP_CLAUSE_DEFAULT_PRIVATE:
+         pp_string (buffer, "private");
+         break;
+       case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
+         pp_string (buffer, "firstprivate");
+         break;
+       default:
+         gcc_unreachable ();
+       }
+      pp_character (buffer, ')');
+      break;
+
+    case OMP_CLAUSE_SCHEDULE:
+      pp_string (buffer, "schedule(");
+      switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
+       {
+      case OMP_CLAUSE_SCHEDULE_STATIC:
+       pp_string (buffer, "static");
+       break;
+      case OMP_CLAUSE_SCHEDULE_DYNAMIC:
+       pp_string (buffer, "dynamic");
+       break;
+      case OMP_CLAUSE_SCHEDULE_GUIDED:
+       pp_string (buffer, "guided");
+       break;
+      case OMP_CLAUSE_SCHEDULE_RUNTIME:
+       pp_string (buffer, "runtime");
+       break;
+      case OMP_CLAUSE_SCHEDULE_AUTO:
+       pp_string (buffer, "auto");
+       break;
+      default:
+       gcc_unreachable ();
+       }
+      if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
+       {
+         pp_character (buffer, ',');
+         dump_generic_node (buffer,
+             OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
+             spc, flags, false);
+       }
+      pp_character (buffer, ')');
+      break;
+
+    case OMP_CLAUSE_UNTIED:
+      pp_string (buffer, "untied");
+      break;
+
+    case OMP_CLAUSE_COLLAPSE:
+      pp_string (buffer, "collapse(");
+      dump_generic_node (buffer,
+                        OMP_CLAUSE_COLLAPSE_EXPR (clause),
+                        spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+
+    default:
+      /* Should never happen.  */
+      dump_generic_node (buffer, clause, spc, flags, false);
+      break;
+    }
+}
+
+
+/* Dump the list of OpenMP clauses.  BUFFER, SPC and FLAGS are as in
+   dump_generic_node.  */
+
+void
+dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
+{
+  if (clause == NULL)
+    return;
+
+  pp_space (buffer);
+  while (1)
+    {
+      dump_omp_clause (buffer, clause, spc, flags);
+      clause = OMP_CLAUSE_CHAIN (clause);
+      if (clause == NULL)
+       return;
+      pp_space (buffer);
+    }
+}
+
+
+/* Dump location LOC to BUFFER.  */
+
+static void
+dump_location (pretty_printer *buffer, location_t loc)
+{
+  expanded_location xloc = expand_location (loc);
+
+  pp_character (buffer, '[');
+  if (xloc.file)
+    {
+      pp_string (buffer, xloc.file);
+      pp_string (buffer, " : ");
+    }
+  pp_decimal_int (buffer, xloc.line);
+  pp_string (buffer, "] ");
+}
+
+
+/* Dump lexical block BLOCK.  BUFFER, SPC and FLAGS are as in
+   dump_generic_node.  */
+
+static void
+dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)
+{
+  tree t;
+
+  pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block));
+
+  if (flags & TDF_ADDRESS)
+    pp_printf (buffer, "[%p] ", (void *) block);
+
+  if (BLOCK_ABSTRACT (block))
+    pp_string (buffer, "[abstract] ");
+
+  if (TREE_ASM_WRITTEN (block))
+    pp_string (buffer, "[written] ");
+
+  if (flags & TDF_SLIM)
+    return;
+
+  if (BLOCK_SOURCE_LOCATION (block))
+    dump_location (buffer, BLOCK_SOURCE_LOCATION (block));
+
+  newline_and_indent (buffer, spc + 2);
+
+  if (BLOCK_SUPERCONTEXT (block))
+    {
+      pp_string (buffer, "SUPERCONTEXT: ");
+      dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0,
+                        flags | TDF_SLIM, false);
+      newline_and_indent (buffer, spc + 2);
+    }
+
+  if (BLOCK_SUBBLOCKS (block))
+    {
+      pp_string (buffer, "SUBBLOCKS: ");
+      for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
+       {
+         dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
+         pp_string (buffer, " ");
+       }
+      newline_and_indent (buffer, spc + 2);
+    }
+
+  if (BLOCK_CHAIN (block))
+    {
+      pp_string (buffer, "SIBLINGS: ");
+      for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
+       {
+         dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
+         pp_string (buffer, " ");
+       }
+      newline_and_indent (buffer, spc + 2);
+    }
+
+  if (BLOCK_VARS (block))
+    {
+      pp_string (buffer, "VARS: ");
+      for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
+       {
+         dump_generic_node (buffer, t, 0, flags, false);
+         pp_string (buffer, " ");
+       }
+      newline_and_indent (buffer, spc + 2);
+    }
+
+  if (VEC_length (tree, BLOCK_NONLOCALIZED_VARS (block)) > 0)
+    {
+      unsigned i;
+      VEC(tree,gc) *nlv = BLOCK_NONLOCALIZED_VARS (block);
+
+      pp_string (buffer, "NONLOCALIZED_VARS: ");
+      for (i = 0; VEC_iterate (tree, nlv, i, t); i++)
+       {
+         dump_generic_node (buffer, t, 0, flags, false);
+         pp_string (buffer, " ");
+       }
+      newline_and_indent (buffer, spc + 2);
+    }
+
+  if (BLOCK_ABSTRACT_ORIGIN (block))
+    {
+      pp_string (buffer, "ABSTRACT_ORIGIN: ");
+      dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0,
+                        flags | TDF_SLIM, false);
+      newline_and_indent (buffer, spc + 2);
+    }
+
+  if (BLOCK_FRAGMENT_ORIGIN (block))
+    {
+      pp_string (buffer, "FRAGMENT_ORIGIN: ");
+      dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0,
+                        flags | TDF_SLIM, false);
+      newline_and_indent (buffer, spc + 2);
+    }
+
+  if (BLOCK_FRAGMENT_CHAIN (block))
+    {
+      pp_string (buffer, "FRAGMENT_CHAIN: ");
+      for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
+       {
+         dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
+         pp_string (buffer, " ");
+       }
+      newline_and_indent (buffer, spc + 2);
+    }
+}
+
+
+/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
+   indent.  FLAGS specifies details to show in the dump (see TDF_* in
+   tree-pass.h).  If IS_STMT is true, the object printed is considered
+   to be a statement and it is terminated by ';' if appropriate.  */

 
 int
 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
 int
 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,


@@ -265,30 +571,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
   is_expr = EXPR_P (node);
 
 
   is_expr = EXPR_P (node);
 

-  if (TREE_CODE (node) != ERROR_MARK
-      && is_gimple_stmt (node)
-      && (flags & TDF_VOPS)
-      && stmt_ann (node)
-      && TREE_CODE (node) != PHI_NODE)
-    dump_vops (buffer, node, spc, flags);
-

   if (is_stmt && (flags & TDF_STMTADDR))
     pp_printf (buffer, "<&%p> ", (void *)node);
 
   if (is_stmt && (flags & TDF_STMTADDR))
     pp_printf (buffer, "<&%p> ", (void *)node);
 

-  if (dumping_stmts
-      && (flags & TDF_LINENO)
-      && EXPR_HAS_LOCATION (node))
-    {
-      expanded_location xloc = expand_location (EXPR_LOCATION (node));
-      pp_character (buffer, '[');
-      if (xloc.file)
-       {
-         pp_string (buffer, xloc.file);
-         pp_string (buffer, " : ");
-       }
-      pp_decimal_int (buffer, xloc.line);
-      pp_string (buffer, "] ");
-    }
+  if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
+    dump_location (buffer, EXPR_LOCATION (node));

 
   switch (TREE_CODE (node))
     {
 
   switch (TREE_CODE (node))
     {


@@ -320,6 +607,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
     case TREE_BINFO:
       dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
 
     case TREE_BINFO:
       dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);

+      break;

 
     case TREE_VEC:
       {
 
     case TREE_VEC:
       {


@@ -340,21 +628,17 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       }
       break;
 
       }
       break;
 

-    case BLOCK:
-      NIY;
-      break;
-

     case VOID_TYPE:
     case INTEGER_TYPE:
     case REAL_TYPE:
     case VOID_TYPE:
     case INTEGER_TYPE:
     case REAL_TYPE:

+    case FIXED_POINT_TYPE:

     case COMPLEX_TYPE:
     case VECTOR_TYPE:
     case ENUMERAL_TYPE:
     case BOOLEAN_TYPE:
     case COMPLEX_TYPE:
     case VECTOR_TYPE:
     case ENUMERAL_TYPE:
     case BOOLEAN_TYPE:

-    case CHAR_TYPE:

       {
        unsigned int quals = TYPE_QUALS (node);
       {
        unsigned int quals = TYPE_QUALS (node);

-       enum tree_code_class class;
+       enum tree_code_class tclass;

 
        if (quals & TYPE_QUAL_CONST)
          pp_string (buffer, "const ");
 
        if (quals & TYPE_QUAL_CONST)
          pp_string (buffer, "const ");


@@ -363,16 +647,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
        else if (quals & TYPE_QUAL_RESTRICT)
          pp_string (buffer, "restrict ");
 
        else if (quals & TYPE_QUAL_RESTRICT)
          pp_string (buffer, "restrict ");
 

-       class = TREE_CODE_CLASS (TREE_CODE (node));
+       tclass = TREE_CODE_CLASS (TREE_CODE (node));

 
 

-       if (class == tcc_declaration)
+       if (tclass == tcc_declaration)

          {
            if (DECL_NAME (node))
              dump_decl_name (buffer, node, flags);
            else
               pp_string (buffer, "<unnamed type decl>");
          }
          {
            if (DECL_NAME (node))
              dump_decl_name (buffer, node, flags);
            else
               pp_string (buffer, "<unnamed type decl>");
          }

-       else if (class == tcc_type)
+       else if (tclass == tcc_type)

          {
            if (TYPE_NAME (node))
              {
          {
            if (TYPE_NAME (node))
              {


@@ -387,8 +671,33 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
            else if (TREE_CODE (node) == VECTOR_TYPE)
              {
                pp_string (buffer, "vector ");
            else if (TREE_CODE (node) == VECTOR_TYPE)
              {
                pp_string (buffer, "vector ");

-               dump_generic_node (buffer, TREE_TYPE (node), 
-                                  spc, flags, false);
+               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
+             }
+           else if (TREE_CODE (node) == INTEGER_TYPE)
+             {
+               pp_string (buffer, (TYPE_UNSIGNED (node)
+                                   ? "<unnamed-unsigned:"
+                                   : "<unnamed-signed:"));
+               pp_decimal_int (buffer, TYPE_PRECISION (node));
+               pp_string (buffer, ">");
+             }
+           else if (TREE_CODE (node) == COMPLEX_TYPE)
+             {
+               pp_string (buffer, "__complex__ ");
+               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
+             }
+           else if (TREE_CODE (node) == REAL_TYPE)
+             {
+               pp_string (buffer, "<float:");
+               pp_decimal_int (buffer, TYPE_PRECISION (node));
+               pp_string (buffer, ">");
+             }
+           else if (TREE_CODE (node) == FIXED_POINT_TYPE)
+             {
+               pp_string (buffer, "<fixed-point-");
+               pp_string (buffer, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
+               pp_decimal_int (buffer, TYPE_PRECISION (node));
+               pp_string (buffer, ">");

              }
            else
               pp_string (buffer, "<unnamed type>");
              }
            else
               pp_string (buffer, "<unnamed type>");


@@ -400,7 +709,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case REFERENCE_TYPE:
       str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
 
     case REFERENCE_TYPE:
       str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
 

-      if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
+      if (TREE_TYPE (node) == NULL)
+        {
+         pp_string (buffer, str);
+          pp_string (buffer, "<null type>");
+        }
+      else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)

         {
          tree fnode = TREE_TYPE (node);
 
         {
          tree fnode = TREE_TYPE (node);
 


@@ -426,9 +740,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
          if (quals & TYPE_QUAL_CONST)
            pp_string (buffer, " const");
 
          if (quals & TYPE_QUAL_CONST)
            pp_string (buffer, " const");

-         else if (quals & TYPE_QUAL_VOLATILE)
-           pp_string (buffer,  "volatile");
-         else if (quals & TYPE_QUAL_RESTRICT)
+         if (quals & TYPE_QUAL_VOLATILE)
+           pp_string (buffer, " volatile");
+         if (quals & TYPE_QUAL_RESTRICT)

            pp_string (buffer, " restrict");
 
          if (TYPE_REF_CAN_ALIAS_ALL (node))
            pp_string (buffer, " restrict");
 
          if (TYPE_REF_CAN_ALIAS_ALL (node))


@@ -440,11 +754,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       NIY;
       break;
 
       NIY;
       break;
 

-    case METHOD_TYPE:
-      dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
-      pp_string (buffer, "::");
-      break;
-

     case TARGET_MEM_REF:
       {
        const char *sep = "";
     case TARGET_MEM_REF:
       {
        const char *sep = "";


@@ -522,17 +831,31 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case RECORD_TYPE:
     case UNION_TYPE:
     case QUAL_UNION_TYPE:
     case RECORD_TYPE:
     case UNION_TYPE:
     case QUAL_UNION_TYPE:

-      /* Print the name of the structure.  */
-      if (TREE_CODE (node) == RECORD_TYPE)
-       pp_string (buffer, "struct ");
-      else if (TREE_CODE (node) == UNION_TYPE)
-       pp_string (buffer, "union ");
+      {
+       unsigned int quals = TYPE_QUALS (node);

 
 

-      if (TYPE_NAME (node))
-       dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
-      else
-       print_struct_decl (buffer, node, spc, flags);
-      break;
+       if (quals & TYPE_QUAL_CONST)
+         pp_string (buffer, "const ");
+       if (quals & TYPE_QUAL_VOLATILE)
+         pp_string (buffer, "volatile ");
+
+        /* Print the name of the structure.  */
+        if (TREE_CODE (node) == RECORD_TYPE)
+         pp_string (buffer, "struct ");
+        else if (TREE_CODE (node) == UNION_TYPE)
+         pp_string (buffer, "union ");
+
+        if (TYPE_NAME (node))
+         dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
+       else if (!(flags & TDF_SLIM))
+         /* FIXME: If we eliminate the 'else' above and attempt
+            to show the fields for named types, we may get stuck
+            following a cycle of pointers to structs.  The alleged
+            self-reference check in print_struct_decl will not detect
+            cycles involving more than one pointer or struct type.  */
+         print_struct_decl (buffer, node, spc, flags);
+        break;
+      }

 
     case LANG_TYPE:
       NIY;
 
     case LANG_TYPE:
       NIY;


@@ -567,26 +890,21 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       else if (! host_integerp (node, 0))
        {
          tree val = node;
       else if (! host_integerp (node, 0))
        {
          tree val = node;

+         unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
+         HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);

 
          if (tree_int_cst_sgn (val) < 0)
            {
              pp_character (buffer, '-');
 
          if (tree_int_cst_sgn (val) < 0)
            {
              pp_character (buffer, '-');

-             val = build_int_cst_wide (NULL_TREE,
-                                       -TREE_INT_CST_LOW (val),
-                                       ~TREE_INT_CST_HIGH (val)
-                                       + !TREE_INT_CST_LOW (val));
+             high = ~high + !low;
+             low = -low;

            }
          /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
             systems?  */
            }
          /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
             systems?  */

-         {
-           static char format[10]; /* "%x%09999x\0" */
-           if (!format[0])
-             sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
-           sprintf (pp_buffer (buffer)->digit_buffer, format,
-                    TREE_INT_CST_HIGH (val),
-                    TREE_INT_CST_LOW (val));
-           pp_string (buffer, pp_buffer (buffer)->digit_buffer);
-         }
+         sprintf (pp_buffer (buffer)->digit_buffer,
+                  HOST_WIDE_INT_PRINT_DOUBLE_HEX,
+                  (unsigned HOST_WIDE_INT) high, low);
+         pp_string (buffer, pp_buffer (buffer)->digit_buffer);

        }
       else
        pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
        }
       else
        pp_wide_integer (buffer, TREE_INT_CST_LOW (node));


@@ -602,7 +920,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
        d = TREE_REAL_CST (node);
        if (REAL_VALUE_ISINF (d))
 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
        d = TREE_REAL_CST (node);
        if (REAL_VALUE_ISINF (d))

-         pp_string (buffer, " Inf");
+         pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");

        else if (REAL_VALUE_ISNAN (d))
          pp_string (buffer, " Nan");
        else
        else if (REAL_VALUE_ISNAN (d))
          pp_string (buffer, " Nan");
        else


@@ -623,6 +941,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
        break;
       }
 
        break;
       }
 

+    case FIXED_CST:
+      {
+       char string[100];
+       fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
+       pp_string (buffer, string);
+       break;
+      }
+

     case COMPLEX_CST:
       pp_string (buffer, "__complex__ (");
       dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
     case COMPLEX_CST:
       pp_string (buffer, "__complex__ (");
       dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);


@@ -652,6 +978,23 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       break;
 
     case FUNCTION_TYPE:
       break;
 
     case FUNCTION_TYPE:

+    case METHOD_TYPE:
+      dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
+      pp_space (buffer);
+      if (TREE_CODE (node) == METHOD_TYPE)
+       {
+         if (TYPE_METHOD_BASETYPE (node))
+           dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
+                           flags);
+         else
+           pp_string (buffer, "<null method basetype>");
+         pp_string (buffer, "::");
+       }
+      if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
+       dump_decl_name (buffer, TYPE_NAME (node), flags);
+      else
+       pp_printf (buffer, "<T%x>", TYPE_UID (node));
+      dump_function_declaration (buffer, node, spc, flags);

       break;
 
     case FUNCTION_DECL:
       break;
 
     case FUNCTION_DECL:


@@ -663,10 +1006,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       if (DECL_NAME (node))
        dump_decl_name (buffer, node, flags);
       else if (LABEL_DECL_UID (node) != -1)
       if (DECL_NAME (node))
        dump_decl_name (buffer, node, flags);
       else if (LABEL_DECL_UID (node) != -1)

-        pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
-                  LABEL_DECL_UID (node));
+        pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));

       else
       else

-        pp_printf (buffer, "<D%u>", DECL_UID (node));
+        pp_printf (buffer, "<D.%u>", DECL_UID (node));

       break;
 
     case TYPE_DECL:
       break;
 
     case TYPE_DECL:


@@ -724,16 +1066,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
        pp_character (buffer, ')');
       pp_string (buffer, str);
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
        pp_character (buffer, ')');
       pp_string (buffer, str);
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);

-
-      if (TREE_CODE (op0) != VALUE_HANDLE)
+      op0 = component_ref_field_offset (node);
+      if (op0 && TREE_CODE (op0) != INTEGER_CST)

        {
        {

-         op0 = component_ref_field_offset (node);
-         if (op0 && TREE_CODE (op0) != INTEGER_CST)
-           {
-             pp_string (buffer, "{off: ");
+         pp_string (buffer, "{off: ");

              dump_generic_node (buffer, op0, spc, flags, false);
              pp_character (buffer, '}');
              dump_generic_node (buffer, op0, spc, flags, false);
              pp_character (buffer, '}');

-           }

        }
       break;
 
        }
       break;
 


@@ -765,8 +1103,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       op1 = array_ref_element_size (node);
 
       if (!integer_zerop (op0)
       op1 = array_ref_element_size (node);
 
       if (!integer_zerop (op0)

-         || (TYPE_SIZE_UNIT (TREE_TYPE (node))
-             && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
+         || TREE_OPERAND (node, 2)
+         || TREE_OPERAND (node, 3))

        {
          pp_string (buffer, "{lb: ");
          dump_generic_node (buffer, op0, spc, flags, false);
        {
          pp_string (buffer, "{lb: ");
          dump_generic_node (buffer, op0, spc, flags, false);


@@ -778,36 +1116,29 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
     case CONSTRUCTOR:
       {
 
     case CONSTRUCTOR:
       {

-       tree lnode;
+       unsigned HOST_WIDE_INT ix;
+       tree field, val;

        bool is_struct_init = FALSE;
        pp_character (buffer, '{');
        bool is_struct_init = FALSE;
        pp_character (buffer, '{');

-       lnode = CONSTRUCTOR_ELTS (node);

        if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
            || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
          is_struct_init = TRUE;
        if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
            || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
          is_struct_init = TRUE;

-       while (lnode && lnode != error_mark_node)
+       FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)

          {
          {

-           tree val;
-           if (TREE_PURPOSE (lnode) && is_struct_init)
+           if (field && is_struct_init)

              {
                pp_character (buffer, '.');
              {
                pp_character (buffer, '.');

-               dump_generic_node (buffer, TREE_PURPOSE (lnode), spc, flags, false);
+               dump_generic_node (buffer, field, spc, flags, false);

                pp_string (buffer, "=");
              }
                pp_string (buffer, "=");
              }

-           val = TREE_VALUE (lnode);

            if (val && TREE_CODE (val) == ADDR_EXPR)
              if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
                val = TREE_OPERAND (val, 0);
            if (val && TREE_CODE (val) == FUNCTION_DECL)
            if (val && TREE_CODE (val) == ADDR_EXPR)
              if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
                val = TREE_OPERAND (val, 0);
            if (val && TREE_CODE (val) == FUNCTION_DECL)

-             {

                dump_decl_name (buffer, val, flags);
                dump_decl_name (buffer, val, flags);

-             }

            else
            else

-             {
-               dump_generic_node (buffer, TREE_VALUE (lnode), spc, flags, false);
-             }
-           lnode = TREE_CHAIN (lnode);
-           if (lnode && TREE_CODE (lnode) == TREE_LIST)
+               dump_generic_node (buffer, val, spc, flags, false);
+           if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)

              {
                pp_character (buffer, ',');
                pp_space (buffer);
              {
                pp_character (buffer, ',');
                pp_space (buffer);


@@ -827,8 +1158,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
          }
 
        dump_generic_node (buffer, TREE_OPERAND (node, 0),
          }
 
        dump_generic_node (buffer, TREE_OPERAND (node, 0),

-                          spc, flags, dumping_stmts);
-       if (dumping_stmts)
+                          spc, flags, !(flags & TDF_SLIM));
+       if (flags & TDF_SLIM)

          newline_and_indent (buffer, spc);
        else
          {
          newline_and_indent (buffer, spc);
        else
          {


@@ -841,8 +1172,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
             tp = &TREE_OPERAND (*tp, 1))
          {
            dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
             tp = &TREE_OPERAND (*tp, 1))
          {
            dump_generic_node (buffer, TREE_OPERAND (*tp, 0),

-                              spc, flags, dumping_stmts);
-           if (dumping_stmts)
+                              spc, flags, !(flags & TDF_SLIM));
+           if (flags & TDF_SLIM)

              newline_and_indent (buffer, spc);
            else
              {
              newline_and_indent (buffer, spc);
            else
              {


@@ -851,7 +1182,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
              }
          }
 
              }
          }
 

-       dump_generic_node (buffer, *tp, spc, flags, dumping_stmts);
+       dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));

       }
       break;
 
       }
       break;
 


@@ -860,7 +1191,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
        tree_stmt_iterator si;
        bool first = true;
 
        tree_stmt_iterator si;
        bool first = true;
 

-       if ((flags & TDF_SLIM) || !dumping_stmts)
+       if (flags & TDF_SLIM)

          {
            pp_string (buffer, "<STATEMENT_LIST>");
            break;
          {
            pp_string (buffer, "<STATEMENT_LIST>");
            break;


@@ -879,11 +1210,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
     case MODIFY_EXPR:
     case INIT_EXPR:
 
     case MODIFY_EXPR:
     case INIT_EXPR:

-      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,
+                        false);

       pp_space (buffer);
       pp_character (buffer, '=');
       pp_space (buffer);
       pp_character (buffer, '=');

+      if (TREE_CODE (node) == MODIFY_EXPR
+         && MOVE_NONTEMPORAL (node))
+       pp_string (buffer, "{nt}");

       pp_space (buffer);
       pp_space (buffer);

-      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,
+                        false);

       break;
 
     case TARGET_EXPR:
       break;
 
     case TARGET_EXPR:


@@ -915,9 +1251,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
                  || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
            {
              pp_space (buffer);
                  || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
            {
              pp_space (buffer);

-             dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
-             pp_string (buffer, " else ");
-             dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
+             dump_generic_node (buffer, COND_EXPR_THEN (node),
+                                0, flags, true);
+             if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
+               {
+                 pp_string (buffer, " else ");
+                 dump_generic_node (buffer, COND_EXPR_ELSE (node),
+                                    0, flags, true);
+               }

            }
          else if (!(flags & TDF_SLIM))
            {
            }
          else if (!(flags & TDF_SLIM))
            {


@@ -934,7 +1275,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
                }
 
              /* Output COND_EXPR_ELSE.  */
                }
 
              /* Output COND_EXPR_ELSE.  */

-             if (COND_EXPR_ELSE (node))
+             if (COND_EXPR_ELSE (node)
+                 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))

                {
                  newline_and_indent (buffer, spc);
                  pp_string (buffer, "else");
                {
                  newline_and_indent (buffer, spc);
                  pp_string (buffer, "else");


@@ -992,12 +1334,31 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       /* Print parameters.  */
       pp_space (buffer);
       pp_character (buffer, '(');
       /* Print parameters.  */
       pp_space (buffer);
       pp_character (buffer, '(');

-      op1 = TREE_OPERAND (node, 1);
-      if (op1)
-       dump_generic_node (buffer, op1, spc, flags, false);
+      {
+       tree arg;
+       call_expr_arg_iterator iter;
+       FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
+         {
+           dump_generic_node (buffer, arg, spc, flags, false);
+           if (more_call_expr_args_p (&iter))
+             {
+               pp_character (buffer, ',');
+               pp_space (buffer);
+             }
+         }
+      }
+      if (CALL_EXPR_VA_ARG_PACK (node))
+       {
+         if (call_expr_nargs (node) > 0)
+           {
+             pp_character (buffer, ',');
+             pp_space (buffer);
+           }
+         pp_string (buffer, "__builtin_va_arg_pack ()");
+       }

       pp_character (buffer, ')');
 
       pp_character (buffer, ')');
 

-      op1 = TREE_OPERAND (node, 2);
+      op1 = CALL_EXPR_STATIC_CHAIN (node);

       if (op1)
        {
          pp_string (buffer, " [static-chain: ");
       if (op1)
        {
          pp_string (buffer, " [static-chain: ");


@@ -1028,8 +1389,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       break;
 
       /* Binary arithmetic and logic expressions.  */
       break;
 
       /* Binary arithmetic and logic expressions.  */

+    case WIDEN_SUM_EXPR:
+    case WIDEN_MULT_EXPR:

     case MULT_EXPR:
     case PLUS_EXPR:
     case MULT_EXPR:
     case PLUS_EXPR:

+    case POINTER_PLUS_EXPR:

     case MINUS_EXPR:
     case TRUNC_DIV_EXPR:
     case CEIL_DIV_EXPR:
     case MINUS_EXPR:
     case TRUNC_DIV_EXPR:
     case CEIL_DIV_EXPR:


@@ -1076,7 +1440,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
        /* When the operands are expressions with less priority,
           keep semantics of the tree representation.  */
 
        /* When the operands are expressions with less priority,
           keep semantics of the tree representation.  */

-       if (op_prio (op0) < op_prio (node))
+       if (op_prio (op0) <= op_prio (node))

          {
            pp_character (buffer, '(');
            dump_generic_node (buffer, op0, spc, flags, false);
          {
            pp_character (buffer, '(');
            dump_generic_node (buffer, op0, spc, flags, false);


@@ -1091,7 +1455,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
        /* When the operands are expressions with less priority,
           keep semantics of the tree representation.  */
 
        /* When the operands are expressions with less priority,
           keep semantics of the tree representation.  */

-       if (op_prio (op1) < op_prio (node))
+       if (op_prio (op1) <= op_prio (node))

          {
            pp_character (buffer, '(');
            dump_generic_node (buffer, op1, spc, flags, false);
          {
            pp_character (buffer, '(');
            dump_generic_node (buffer, op1, spc, flags, false);


@@ -1175,13 +1539,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       NIY;
       break;
 
       NIY;
       break;
 

+    case FIXED_CONVERT_EXPR:

     case FIX_TRUNC_EXPR:
     case FIX_TRUNC_EXPR:

-    case FIX_CEIL_EXPR:
-    case FIX_FLOOR_EXPR:
-    case FIX_ROUND_EXPR:

     case FLOAT_EXPR:
     case FLOAT_EXPR:

-    case CONVERT_EXPR:
-    case NOP_EXPR:
+    CASE_CONVERT:

       type = TREE_TYPE (node);
       op0 = TREE_OPERAND (node, 0);
       if (type != TREE_TYPE (op0))
       type = TREE_TYPE (node);
       op0 = TREE_OPERAND (node, 0);
       if (type != TREE_TYPE (op0))


@@ -1205,6 +1566,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_character (buffer, ')');
       break;
 
       pp_character (buffer, ')');
       break;
 

+    case PAREN_EXPR:
+      pp_string (buffer, "((");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, "))");
+      break;
+

     case NON_LVALUE_EXPR:
       pp_string (buffer, "NON_LVALUE_EXPR <");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
     case NON_LVALUE_EXPR:
       pp_string (buffer, "NON_LVALUE_EXPR <");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);


@@ -1334,6 +1701,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       is_expr = false;
       break;
 
       is_expr = false;
       break;
 

+    case PREDICT_EXPR:
+      pp_string (buffer, "// predicted ");
+      if (PREDICT_EXPR_OUTCOME (node))
+        pp_string (buffer, "likely by ");
+      else
+        pp_string (buffer, "unlikely by ");
+      pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
+      pp_string (buffer, " predictor.");
+      break;
+

     case RETURN_EXPR:
       pp_string (buffer, "return");
       op0 = TREE_OPERAND (node, 0);
     case RETURN_EXPR:
       pp_string (buffer, "return");
       op0 = TREE_OPERAND (node, 0);


@@ -1341,7 +1718,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
        {
          pp_space (buffer);
          if (TREE_CODE (op0) == MODIFY_EXPR)
        {
          pp_space (buffer);
          if (TREE_CODE (op0) == MODIFY_EXPR)

-           dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
+           dump_generic_node (buffer, TREE_OPERAND (op0, 1),
+                              spc, flags, false);

          else
            dump_generic_node (buffer, op0, spc, flags, false);
        }
          else
            dump_generic_node (buffer, op0, spc, flags, false);
        }


@@ -1364,7 +1742,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
          if (SWITCH_BODY (node))
            {
              newline_and_indent (buffer, spc+4);
          if (SWITCH_BODY (node))
            {
              newline_and_indent (buffer, spc+4);

-             dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, true);
+             dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
+                                true);

            }
          else
            {
            }
          else
            {


@@ -1374,10 +1753,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
                {
                  tree elt = TREE_VEC_ELT (vec, i);
                  newline_and_indent (buffer, spc+4);
                {
                  tree elt = TREE_VEC_ELT (vec, i);
                  newline_and_indent (buffer, spc+4);

-                 dump_generic_node (buffer, elt, spc+4, flags, false);
-                 pp_string (buffer, " goto ");
-                 dump_generic_node (buffer, CASE_LABEL (elt), spc+4, flags, true);
-                 pp_semicolon (buffer);
+                 if (elt)
+                   {
+                     dump_generic_node (buffer, elt, spc+4, flags, false);
+                     pp_string (buffer, " goto ");
+                     dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
+                                        flags, true);
+                     pp_semicolon (buffer);
+                   }
+                 else
+                   pp_string (buffer, "case ???: goto ???;");

                }
            }
          newline_and_indent (buffer, spc+2);
                }
            }
          newline_and_indent (buffer, spc+2);


@@ -1403,8 +1788,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       break;
 
     case RESX_EXPR:
       break;
 
     case RESX_EXPR:

-      pp_string (buffer, "resx");
-      /* ??? Any sensible way to present the eh region?  */
+      pp_string (buffer, "resx ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);

       break;
 
     case ASM_EXPR:
       break;
 
     case ASM_EXPR:


@@ -1439,7 +1824,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
          dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
        }
       else
          dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
        }
       else

-       pp_string (buffer, "default ");
+       pp_string (buffer, "default");

       pp_character (buffer, ':');
       break;
 
       pp_character (buffer, ':');
       break;
 


@@ -1454,31 +1839,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_character (buffer, ')');
       break;
 
       pp_character (buffer, ')');
       break;
 

-    case PHI_NODE:
-      {
-       int i;
-
-       dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
-       pp_string (buffer, " = PHI <");
-       for (i = 0; i < PHI_NUM_ARGS (node); i++)
-         {
-           dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
-           pp_string (buffer, "(");
-           pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
-           pp_string (buffer, ")");
-           if (i < PHI_NUM_ARGS (node) - 1)
-             pp_string (buffer, ", ");
-         }
-       pp_string (buffer, ">;");
-      }
-      break;
-

     case SSA_NAME:
       dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
       pp_string (buffer, "_");
       pp_decimal_int (buffer, SSA_NAME_VERSION (node));
       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
        pp_string (buffer, "(ab)");
     case SSA_NAME:
       dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
       pp_string (buffer, "_");
       pp_decimal_int (buffer, SSA_NAME_VERSION (node));
       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
        pp_string (buffer, "(ab)");

+      else if (SSA_NAME_IS_DEFAULT_DEF (node))
+       pp_string (buffer, "(D)");

       break;
 
     case WITH_SIZE_EXPR:
       break;
 
     case WITH_SIZE_EXPR:


@@ -1489,10 +1857,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_string (buffer, ">");
       break;
 
       pp_string (buffer, ">");
       break;
 

-    case VALUE_HANDLE:
-      pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
-      break;
-

     case ASSERT_EXPR:
       pp_string (buffer, "ASSERT_EXPR <");
       dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
     case ASSERT_EXPR:
       pp_string (buffer, "ASSERT_EXPR <");
       dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);


@@ -1539,21 +1903,256 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_string (buffer, " > ");
       break;
 
       pp_string (buffer, " > ");
       break;
 

-    case REDUC_MAX_EXPR:
-      pp_string (buffer, " REDUC_MAX_EXPR < ");
+    case DOT_PROD_EXPR:
+      pp_string (buffer, " DOT_PROD_EXPR < ");

       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);

+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);

       pp_string (buffer, " > ");
       break;
 
       pp_string (buffer, " > ");
       break;
 

-    case REDUC_MIN_EXPR:
-      pp_string (buffer, " REDUC_MIN_EXPR < ");
-      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-      pp_string (buffer, " > ");
+    case OMP_PARALLEL:
+      pp_string (buffer, "#pragma omp parallel");
+      dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
+
+    dump_omp_body:
+      if (!(flags & TDF_SLIM) && OMP_BODY (node))
+       {
+         newline_and_indent (buffer, spc + 2);
+         pp_character (buffer, '{');
+         newline_and_indent (buffer, spc + 4);
+         dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
+         newline_and_indent (buffer, spc + 2);
+         pp_character (buffer, '}');
+       }
+      is_expr = false;

       break;
 
       break;
 

-    case REDUC_PLUS_EXPR:
-      pp_string (buffer, " REDUC_PLUS_EXPR < ");
-      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+    case OMP_TASK:
+      pp_string (buffer, "#pragma omp task");
+      dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags);
+      goto dump_omp_body;
+
+    case OMP_FOR:
+      pp_string (buffer, "#pragma omp for");
+      dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
+
+      if (!(flags & TDF_SLIM))
+       {
+         int i;
+
+         if (OMP_FOR_PRE_BODY (node))
+           {
+             newline_and_indent (buffer, spc + 2);
+             pp_character (buffer, '{');
+             spc += 4;
+             newline_and_indent (buffer, spc);
+             dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
+                 spc, flags, false);
+           }
+         spc -= 2;
+         for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
+           {
+             spc += 2;
+             newline_and_indent (buffer, spc);
+             pp_string (buffer, "for (");
+             dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i),
+                                spc, flags, false);
+             pp_string (buffer, "; ");
+             dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i),
+                                spc, flags, false);
+             pp_string (buffer, "; ");
+             dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),
+                                spc, flags, false);
+             pp_string (buffer, ")");
+           }
+         if (OMP_FOR_BODY (node))
+           {
+             newline_and_indent (buffer, spc + 2);
+             pp_character (buffer, '{');
+             newline_and_indent (buffer, spc + 4);
+             dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
+                 false);
+             newline_and_indent (buffer, spc + 2);
+             pp_character (buffer, '}');
+           }
+         spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
+         if (OMP_FOR_PRE_BODY (node))
+           {
+             spc -= 4;
+             newline_and_indent (buffer, spc + 2);
+             pp_character (buffer, '}');
+           }
+       }
+      is_expr = false;
+      break;
+
+    case OMP_SECTIONS:
+      pp_string (buffer, "#pragma omp sections");
+      dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
+      goto dump_omp_body;
+
+    case OMP_SECTION:
+      pp_string (buffer, "#pragma omp section");
+      goto dump_omp_body;
+ 
+    case OMP_MASTER:
+      pp_string (buffer, "#pragma omp master");
+      goto dump_omp_body;
+
+    case OMP_ORDERED:
+      pp_string (buffer, "#pragma omp ordered");
+      goto dump_omp_body;
+
+    case OMP_CRITICAL:
+      pp_string (buffer, "#pragma omp critical");
+      if (OMP_CRITICAL_NAME (node))
+       {
+         pp_space (buffer);
+         pp_character (buffer, '(');
+          dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
+                            flags, false);
+         pp_character (buffer, ')');
+       }
+      goto dump_omp_body;
+
+    case OMP_ATOMIC:
+      pp_string (buffer, "#pragma omp atomic");
+      newline_and_indent (buffer, spc + 2);
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_space (buffer);
+      pp_character (buffer, '=');
+      pp_space (buffer);
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      break;
+
+    case OMP_SINGLE:
+      pp_string (buffer, "#pragma omp single");
+      dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
+      goto dump_omp_body;
+
+    case OMP_CLAUSE:
+      dump_omp_clause (buffer, node, spc, flags);
+      is_expr = false;
+      break;
+
+    case REDUC_MAX_EXPR:
+      pp_string (buffer, " REDUC_MAX_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case REDUC_MIN_EXPR:
+      pp_string (buffer, " REDUC_MIN_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case REDUC_PLUS_EXPR:
+      pp_string (buffer, " REDUC_PLUS_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_WIDEN_MULT_HI_EXPR:
+      pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_WIDEN_MULT_LO_EXPR:
+      pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_UNPACK_HI_EXPR:
+      pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_UNPACK_LO_EXPR:
+      pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_UNPACK_FLOAT_HI_EXPR:
+      pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_UNPACK_FLOAT_LO_EXPR:
+      pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_PACK_TRUNC_EXPR:
+      pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_PACK_SAT_EXPR:
+      pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_PACK_FIX_TRUNC_EXPR:
+      pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case BLOCK:
+      dump_block_node (buffer, node, spc, flags);
+      break;
+
+    case VEC_EXTRACT_EVEN_EXPR:
+      pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+  
+    case VEC_EXTRACT_ODD_EXPR:
+      pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_INTERLEAVE_HIGH_EXPR:
+      pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case VEC_INTERLEAVE_LOW_EXPR:
+      pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);

       pp_string (buffer, " > ");
       break;
 
       pp_string (buffer, " > ");
       break;
 


@@ -1563,14 +2162,18 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
   if (is_stmt && is_expr)
     pp_semicolon (buffer);
 
   if (is_stmt && is_expr)
     pp_semicolon (buffer);

-  pp_write_text_to_stream (buffer);
+
+  /* If we're building a diagnostic, the formatted text will be written
+     into BUFFER's stream by the caller; otherwise, write it now.  */
+  if (!(flags & TDF_DIAGNOSTIC))
+    pp_write_text_to_stream (buffer);

 
   return spc;
 }
 
 /* Print the declaration of a variable.  */
 
 
   return spc;
 }
 
 /* Print the declaration of a variable.  */
 

-static void
+void

 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
 {
   INDENT (spc);
 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
 {
   INDENT (spc);


@@ -1578,7 +2181,7 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
   if (TREE_CODE (t) == TYPE_DECL)
     pp_string (buffer, "typedef ");
 
   if (TREE_CODE (t) == TYPE_DECL)
     pp_string (buffer, "typedef ");
 

-  if (DECL_REGISTER (t))
+  if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))

     pp_string (buffer, "register ");
 
   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
     pp_string (buffer, "register ");
 
   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))


@@ -1634,7 +2237,7 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
       pp_character (buffer, ')');
     }
 
       pp_character (buffer, ')');
     }
 

-  /* The initial value of a function serves to determine wether the function
+  /* The initial value of a function serves to determine whether the function

      is declared or defined.  So the following does not apply to function
      nodes.  */
   if (TREE_CODE (t) != FUNCTION_DECL)
      is declared or defined.  So the following does not apply to function
      nodes.  */
   if (TREE_CODE (t) != FUNCTION_DECL)


@@ -1649,6 +2252,13 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
        }
     }
 
        }
     }
 

+  if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
+    {
+      pp_string (buffer, " [value-expr: ");
+      dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
+      pp_character (buffer, ']');
+    }
+

   pp_character (buffer, ';');
 }
 
   pp_character (buffer, ';');
 }
 


@@ -1657,7 +2267,7 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
    FIXME: Still incomplete.  */
 
 static void
    FIXME: Still incomplete.  */
 
 static void

-print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
+print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)

 {
   /* Print the name of the structure.  */
   if (TYPE_NAME (node))
 {
   /* Print the name of the structure.  */
   if (TYPE_NAME (node))


@@ -1690,8 +2300,8 @@ print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
           Maybe this could be solved by looking at the scope in which the
           structure was declared.  */
        if (TREE_TYPE (tmp) != node
           Maybe this could be solved by looking at the scope in which the
           structure was declared.  */
        if (TREE_TYPE (tmp) != node

-           || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
-               && TREE_TYPE (TREE_TYPE (tmp)) != node))
+           && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
+               || TREE_TYPE (TREE_TYPE (tmp)) != node))

          {
            print_declaration (buffer, tmp, spc+2, flags);
            pp_newline (buffer);
          {
            print_declaration (buffer, tmp, spc+2, flags);
            pp_newline (buffer);


@@ -1703,7 +2313,7 @@ print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
   pp_character (buffer, '}');
 }
 
   pp_character (buffer, '}');
 }
 

-/* Return the priority of the operator OP.
+/* Return the priority of the operator CODE.

 
    From lowest to highest precedence with either left-to-right (L-R)
    or right-to-left (R-L) associativity]:
 
    From lowest to highest precedence with either left-to-right (L-R)
    or right-to-left (R-L) associativity]:


@@ -1727,13 +2337,10 @@ print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
    unary +, - and * have higher precedence than the corresponding binary
    operators.  */
 
    unary +, - and * have higher precedence than the corresponding binary
    operators.  */
 

-static int
-op_prio (tree op)
+int
+op_code_prio (enum tree_code code)

 {
 {

-  if (op == NULL)
-    return 9999;
-
-  switch (TREE_CODE (op))
+  switch (code)

     {
     case TREE_LIST:
     case COMPOUND_EXPR:
     {
     case TREE_LIST:
     case COMPOUND_EXPR:


@@ -1789,10 +2396,16 @@ op_prio (tree op)
     case RROTATE_EXPR:
       return 11;
 
     case RROTATE_EXPR:
       return 11;
 

+    case WIDEN_SUM_EXPR:

     case PLUS_EXPR:
     case PLUS_EXPR:

+    case POINTER_PLUS_EXPR:

     case MINUS_EXPR:
       return 12;
 
     case MINUS_EXPR:
       return 12;
 

+    case VEC_WIDEN_MULT_HI_EXPR:
+    case VEC_WIDEN_MULT_LO_EXPR:
+    case WIDEN_MULT_EXPR:
+    case DOT_PROD_EXPR:

     case MULT_EXPR:
     case TRUNC_DIV_EXPR:
     case CEIL_DIV_EXPR:
     case MULT_EXPR:
     case TRUNC_DIV_EXPR:
     case CEIL_DIV_EXPR:


@@ -1818,12 +2431,8 @@ op_prio (tree op)
     case INDIRECT_REF:
     case ADDR_EXPR:
     case FLOAT_EXPR:
     case INDIRECT_REF:
     case ADDR_EXPR:
     case FLOAT_EXPR:

-    case NOP_EXPR:
-    case CONVERT_EXPR:
+    CASE_CONVERT:

     case FIX_TRUNC_EXPR:
     case FIX_TRUNC_EXPR:

-    case FIX_CEIL_EXPR:
-    case FIX_FLOOR_EXPR:
-    case FIX_ROUND_EXPR:

     case TARGET_EXPR:
       return 14;
 
     case TARGET_EXPR:
       return 14;
 


@@ -1844,12 +2453,14 @@ op_prio (tree op)
     case REDUC_PLUS_EXPR:
     case VEC_LSHIFT_EXPR:
     case VEC_RSHIFT_EXPR:
     case REDUC_PLUS_EXPR:
     case VEC_LSHIFT_EXPR:
     case VEC_RSHIFT_EXPR:

+    case VEC_UNPACK_HI_EXPR:
+    case VEC_UNPACK_LO_EXPR:
+    case VEC_UNPACK_FLOAT_HI_EXPR:
+    case VEC_UNPACK_FLOAT_LO_EXPR:
+    case VEC_PACK_TRUNC_EXPR:
+    case VEC_PACK_SAT_EXPR:

       return 16;
 
       return 16;
 

-    case SAVE_EXPR:
-    case NON_LVALUE_EXPR:
-      return op_prio (TREE_OPERAND (op, 0));
-

     default:
       /* Return an arbitrarily high precedence to avoid surrounding single
         VAR_DECLs in ()s.  */
     default:
       /* Return an arbitrarily high precedence to avoid surrounding single
         VAR_DECLs in ()s.  */


@@ -1857,15 +2468,29 @@ op_prio (tree op)
     }
 }
 
     }
 }
 

+/* Return the priority of the operator OP.  */

 
 

-/* Return the symbol associated with operator OP.  */
-
-static const char *
-op_symbol (tree op)
+int
+op_prio (const_tree op)

 {
 {

-  gcc_assert (op);
+  enum tree_code code;
+
+  if (op == NULL)
+    return 9999;
+
+  code = TREE_CODE (op);
+  if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
+    return op_prio (TREE_OPERAND (op, 0));
+
+  return op_code_prio (code);
+}
+
+/* Return the symbol associated with operator CODE.  */

 
 

-  switch (TREE_CODE (op))
+const char *
+op_symbol_code (enum tree_code code)
+{
+  switch (code)

     {
     case MODIFY_EXPR:
       return "=";
     {
     case MODIFY_EXPR:
       return "=";


@@ -1931,11 +2556,20 @@ op_symbol (tree op)
     case RSHIFT_EXPR:
       return ">>";
 
     case RSHIFT_EXPR:
       return ">>";
 

+    case LROTATE_EXPR:
+      return "r<<";
+
+    case RROTATE_EXPR:
+      return "r>>";
+

     case VEC_LSHIFT_EXPR:
       return "v<<";
 
     case VEC_RSHIFT_EXPR:
       return "v>>";
     case VEC_LSHIFT_EXPR:
       return "v<<";
 
     case VEC_RSHIFT_EXPR:
       return "v>>";

+
+    case POINTER_PLUS_EXPR:
+      return "+";

  
     case PLUS_EXPR:
       return "+";
  
     case PLUS_EXPR:
       return "+";


@@ -1943,6 +2577,12 @@ op_symbol (tree op)
     case REDUC_PLUS_EXPR:
       return "r+";
 
     case REDUC_PLUS_EXPR:
       return "r+";
 

+    case WIDEN_SUM_EXPR:
+      return "w+";
+
+    case WIDEN_MULT_EXPR:
+      return "w*";
+

     case NEGATE_EXPR:
     case MINUS_EXPR:
       return "-";
     case NEGATE_EXPR:
     case MINUS_EXPR:
       return "-";


@@ -2003,21 +2643,35 @@ op_symbol (tree op)
     case POSTINCREMENT_EXPR:
       return "++ ";
 
     case POSTINCREMENT_EXPR:
       return "++ ";
 

+    case MAX_EXPR:
+      return "max";
+
+    case MIN_EXPR:
+      return "min";
+

     default:
       return "<<< ??? >>>";
     }
 }
 
     default:
       return "<<< ??? >>>";
     }
 }
 

+/* Return the symbol associated with operator OP.  */
+
+static const char *
+op_symbol (const_tree op)
+{
+  return op_symbol_code (TREE_CODE (op));
+}
+

 /* Prints the name of a CALL_EXPR.  */
 
 static void
 /* Prints the name of a CALL_EXPR.  */
 
 static void

-print_call_name (pretty_printer *buffer, tree node)
+print_call_name (pretty_printer *buffer, const_tree node)

 {
   tree op0;
 
   gcc_assert (TREE_CODE (node) == CALL_EXPR);
 
 {
   tree op0;
 
   gcc_assert (TREE_CODE (node) == CALL_EXPR);
 

-  op0 = TREE_OPERAND (node, 0);
+  op0 = CALL_EXPR_FN (node);

 
   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
     op0 = TREE_OPERAND (op0, 0);
 
   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
     op0 = TREE_OPERAND (op0, 0);


@@ -2122,9 +2776,7 @@ pretty_print_string (pretty_printer *buffer, const char *str)
          pp_string (buffer, "\\'");
          break;
 
          pp_string (buffer, "\\'");
          break;
 

-       case '\0':
-         pp_string (buffer, "\\0");
-         break;
+         /* No need to handle \0; the loop terminates on \0.  */

 
        case '\1':
          pp_string (buffer, "\\1");
 
        case '\1':
          pp_string (buffer, "\\1");


@@ -2169,6 +2821,7 @@ maybe_init_pretty_print (FILE *file)
     {
       pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
       pp_needs_newline (&buffer) = true;
     {
       pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
       pp_needs_newline (&buffer) = true;

+      pp_translate_identifiers (&buffer) = false;

       initialized = 1;
     }
 
       initialized = 1;
     }
 


@@ -2181,276 +2834,3 @@ newline_and_indent (pretty_printer *buffer, int spc)
   pp_newline (buffer);
   INDENT (spc);
 }
   pp_newline (buffer);
   INDENT (spc);
 }

-
-static void
-dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
-{
-  tree use;
-  use_operand_p use_p;
-  def_operand_p def_p;
-  use_operand_p kill_p;
-  ssa_op_iter iter;
-
-  if (!ssa_operands_active ())
-    return;
-
-  FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
-    {
-      pp_string (buffer, "#   ");
-      dump_generic_node (buffer, DEF_FROM_PTR (def_p),
-                         spc + 2, flags, false);
-      pp_string (buffer, " = V_MAY_DEF <");
-      dump_generic_node (buffer, USE_FROM_PTR (use_p),
-                         spc + 2, flags, false);
-      pp_string (buffer, ">;");
-      newline_and_indent (buffer, spc);
-    }
-
-  FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)
-    {
-      pp_string (buffer, "#   ");
-      dump_generic_node (buffer, DEF_FROM_PTR (def_p),
-                         spc + 2, flags, false);
-      pp_string (buffer, " = V_MUST_DEF <");
-      dump_generic_node (buffer, USE_FROM_PTR (kill_p),
-                         spc + 2, flags, false);
-      pp_string (buffer, ">;");
-      newline_and_indent (buffer, spc);
-    }
-
-  FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
-    {
-      pp_string (buffer, "#   VUSE <");
-      dump_generic_node (buffer, use, spc + 2, flags, false);
-      pp_string (buffer, ">;");
-      newline_and_indent (buffer, spc);
-    }
-}
-
-/* Dumps basic block BB to FILE with details described by FLAGS and
-   indented by INDENT spaces.  */
-
-void
-dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
-{
-  maybe_init_pretty_print (file);
-  dumping_stmts = true;
-  dump_generic_bb_buff (&buffer, bb, indent, flags);
-  pp_flush (&buffer);
-}
-
-/* Dumps header of basic block BB to buffer BUFFER indented by INDENT
-   spaces and details described by flags.  */
-
-static void
-dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
-{
-  edge e;
-  tree stmt;
-  edge_iterator ei;
-
-  if (flags & TDF_BLOCKS)
-    {
-      INDENT (indent);
-      pp_string (buffer, "# BLOCK ");
-      pp_decimal_int (buffer, bb->index);
-
-      if (flags & TDF_LINENO)
-       {
-         block_stmt_iterator bsi;
-
-         for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
-           if (get_lineno (bsi_stmt (bsi)) != -1)
-             {
-               pp_string (buffer, ", starting at line ");
-               pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
-               break;
-             }
-       }
-      newline_and_indent (buffer, indent);
-
-      pp_string (buffer, "# PRED:");
-      pp_write_text_to_stream (buffer);
-      FOR_EACH_EDGE (e, ei, bb->preds)
-       if (flags & TDF_SLIM)
-         {
-           pp_string (buffer, " ");
-           if (e->src == ENTRY_BLOCK_PTR)
-             pp_string (buffer, "ENTRY");
-           else
-             pp_decimal_int (buffer, e->src->index);
-         }
-       else
-         dump_edge_info (buffer->buffer->stream, e, 0);
-      pp_newline (buffer);
-    }
-  else
-    {
-      stmt = first_stmt (bb);
-      if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
-       {
-         INDENT (indent - 2);
-         pp_string (buffer, "<bb ");
-         pp_decimal_int (buffer, bb->index);
-         pp_string (buffer, ">:");
-         pp_newline (buffer);
-       }
-    }
-  pp_write_text_to_stream (buffer);
-  check_bb_profile (bb, buffer->buffer->stream);
-}
-
-/* Dumps end of basic block BB to buffer BUFFER indented by INDENT
-   spaces.  */
-
-static void
-dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
-{
-  edge e;
-  edge_iterator ei;
-
-  INDENT (indent);
-  pp_string (buffer, "# SUCC:");
-  pp_write_text_to_stream (buffer);
-  FOR_EACH_EDGE (e, ei, bb->succs)
-    if (flags & TDF_SLIM)
-      {
-       pp_string (buffer, " ");
-       if (e->dest == EXIT_BLOCK_PTR)
-         pp_string (buffer, "EXIT");
-       else
-         pp_decimal_int (buffer, e->dest->index);
-      }
-    else
-      dump_edge_info (buffer->buffer->stream, e, 1);
-  pp_newline (buffer);
-}
-
-/* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
-   FLAGS indented by INDENT spaces.  */
-
-static void
-dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
-{
-  tree phi = phi_nodes (bb);
-  if (!phi)
-    return;
-
-  for (; phi; phi = PHI_CHAIN (phi))
-    {
-      if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
-        {
-          INDENT (indent);
-          pp_string (buffer, "# ");
-          dump_generic_node (buffer, phi, indent, flags, false);
-          pp_newline (buffer);
-        }
-    }
-}
-
-/* Dump jump to basic block BB that is represented implicitly in the cfg
-   to BUFFER.  */
-
-static void
-pp_cfg_jump (pretty_printer *buffer, basic_block bb)
-{
-  tree stmt;
-
-  stmt = first_stmt (bb);
-
-  pp_string (buffer, "goto <bb ");
-  pp_decimal_int (buffer, bb->index);
-  pp_string (buffer, ">");
-  if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
-    {
-      pp_string (buffer, " (");
-      dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
-      pp_string (buffer, ")");
-    }
-  pp_semicolon (buffer);
-}
-
-/* Dump edges represented implicitly in basic block BB to BUFFER, indented
-   by INDENT spaces, with details given by FLAGS.  */
-
-static void
-dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
-                    int flags)
-{
-  edge e;
-  edge_iterator ei;
-
-  /* If there is a fallthru edge, we may need to add an artificial goto to the
-     dump.  */
-  FOR_EACH_EDGE (e, ei, bb->succs)
-    if (e->flags & EDGE_FALLTHRU)
-      break;
-  if (e && e->dest != bb->next_bb)
-    {
-      INDENT (indent);
-
-      if ((flags & TDF_LINENO)
-#ifdef USE_MAPPED_LOCATION
-         && e->goto_locus != UNKNOWN_LOCATION
-#else
-         && e->goto_locus
-#endif
-         )
-       {
-         expanded_location goto_xloc;
-#ifdef USE_MAPPED_LOCATION
-         goto_xloc = expand_location (e->goto_locus);
-#else
-         goto_xloc = *e->goto_locus;
-#endif
-         pp_character (buffer, '[');
-         if (goto_xloc.file)
-           {
-             pp_string (buffer, goto_xloc.file);
-             pp_string (buffer, " : ");
-           }
-         pp_decimal_int (buffer, goto_xloc.line);
-         pp_string (buffer, "] ");
-       }
-
-      pp_cfg_jump (buffer, e->dest);
-      pp_newline (buffer);
-    }
-}
-
-/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
-   indented by INDENT spaces.  */
-
-static void
-dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
-                     int indent, int flags)
-{
-  block_stmt_iterator bsi;
-  tree stmt;
-  int label_indent = indent - 2;
-
-  if (label_indent < 0)
-    label_indent = 0;
-
-  dump_bb_header (buffer, bb, indent, flags);
-
-  dump_phi_nodes (buffer, bb, indent, flags);
-
-  for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
-    {
-      int curr_indent;
-
-      stmt = bsi_stmt (bsi);
-
-      curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
-
-      INDENT (curr_indent);
-      dump_generic_node (buffer, stmt, curr_indent, flags, true);
-      pp_newline (buffer);
-    }
-
-  dump_implicit_edges (buffer, bb, indent, flags);
-
-  if (flags & TDF_BLOCKS)
-    dump_bb_end (buffer, bb, indent, flags);
-}