* gcc.target/i386/sse-13.c: Include <mm_malloc.h>

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

diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index ab637a8..8b5f847 100644 (file)
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -1,5 +1,5 @@
 /* Pretty formatting of GENERIC trees in C syntax.
 /* Pretty formatting of GENERIC trees in C syntax.

-   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008

    Free Software Foundation, Inc.
    Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
 
    Free Software Foundation, Inc.
    Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
 


@@ -7,7 +7,7 @@ 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
 
 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


@@ -16,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"


@@ -33,19 +33,20 @@ 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 "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_1 (enum tree_code);
-static const char *op_symbol (tree);
+static int op_prio (const_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 print_declaration (pretty_printer *, tree, int, int);
 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 print_struct_decl (pretty_printer *, const_tree, int, int);
+static void do_niy (pretty_printer *, const_tree);

 static void dump_vops (pretty_printer *, tree, int, int);
 static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
 
 static void dump_vops (pretty_printer *, tree, int, int);
 static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
 


@@ -65,7 +66,7 @@ static int initialized = 0;
 /* 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;
 


@@ -85,6 +86,8 @@ 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)
 {


@@ -92,6 +95,8 @@ debug_generic_expr (tree t)
   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)
 {


@@ -99,6 +104,8 @@ debug_generic_stmt (tree t)
   fprintf (stderr, "\n");
 }
 
   fprintf (stderr, "\n");
 }
 

+/* Debugging function to print out a chain of trees .  */
+

 void
 debug_tree_chain (tree t)
 {
 void
 debug_tree_chain (tree t)
 {


@@ -121,7 +128,7 @@ print_generic_decl (FILE *file, tree decl, int flags)
 }
 
 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 }
 
 /* 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)
 
 void
 print_generic_stmt (FILE *file, tree t, int flags)


@@ -132,7 +139,7 @@ print_generic_stmt (FILE *file, tree t, int flags)
 }
 
 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 }
 
 /* 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


@@ -149,7 +156,7 @@ 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)
 
 void
 print_generic_expr (FILE *file, tree t, int flags)


@@ -173,8 +180,7 @@ dump_decl_name (pretty_printer *buffer, tree node, int flags)
     {
       if (TREE_CODE (t) == LABEL_DECL
           && LABEL_DECL_UID (t) != -1)
     {
       if (TREE_CODE (t) == LABEL_DECL
           && LABEL_DECL_UID (t) != -1)

-        pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
-                  LABEL_DECL_UID (t));
+        pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (t));

       else
        {
          char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
       else
        {
          char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';


@@ -296,7 +302,7 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
 
     case OMP_CLAUSE_REDUCTION:
       pp_string (buffer, "reduction(");
 
     case OMP_CLAUSE_REDUCTION:
       pp_string (buffer, "reduction(");

-      pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause)));
+      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, ':');
       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
          spc, flags, false);


@@ -431,8 +437,8 @@ dump_symbols (pretty_printer *buffer, bitmap syms, int flags)
 
 
 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
 
 
 /* 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
+   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
    and it is terminated by ';' if appropriate.  */
 
 int


@@ -529,6 +535,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     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 COMPLEX_TYPE:
     case VECTOR_TYPE:
     case ENUMERAL_TYPE:


@@ -615,9 +622,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))


@@ -711,17 +718,26 @@ 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
+         print_struct_decl (buffer, node, spc, flags);
+        break;
+      }

 
     case LANG_TYPE:
       NIY;
 
     case LANG_TYPE:
       NIY;


@@ -806,6 +822,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);


@@ -846,10 +870,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:


@@ -1064,6 +1087,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
                         false);
       pp_space (buffer);
       pp_character (buffer, '=');
                         false);
       pp_space (buffer);
       pp_character (buffer, '=');

+      if (TREE_CODE (node) == GIMPLE_MODIFY_STMT
+         && MOVE_NONTEMPORAL (node))
+       pp_string (buffer, "{nt}");
+      if (TREE_CODE (node) == GIMPLE_MODIFY_STMT)
+       {
+       stmt_ann_t ann;
+        if ((ann = stmt_ann (node))
+           && ann->has_volatile_ops)
+         pp_string (buffer, "{v}");
+        }

       pp_space (buffer);
       dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
                         false);
       pp_space (buffer);
       dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
                         false);


@@ -1194,6 +1227,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
              }
          }
       }
              }
          }
       }

+      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, ')');
 
       op1 = CALL_EXPR_STATIC_CHAIN (node);
       pp_character (buffer, ')');
 
       op1 = CALL_EXPR_STATIC_CHAIN (node);


@@ -1231,6 +1273,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case WIDEN_MULT_EXPR:
     case MULT_EXPR:
     case PLUS_EXPR:
     case WIDEN_MULT_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:


@@ -1376,6 +1419,7 @@ 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 FLOAT_EXPR:
     case CONVERT_EXPR:
     case FIX_TRUNC_EXPR:
     case FLOAT_EXPR:
     case CONVERT_EXPR:


@@ -1403,6 +1447,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);


@@ -1494,6 +1544,17 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       is_expr = false;
       break;
 
       is_expr = false;
       break;
 

+    case CHANGE_DYNAMIC_TYPE_EXPR:
+      pp_string (buffer, "<<<change_dynamic_type (");
+      dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_NEW_TYPE (node), spc + 2,
+                        flags, false);
+      pp_string (buffer, ") ");
+      dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_LOCATION (node), spc + 2,
+                        flags, false);
+      pp_string (buffer, ")>>>");
+      is_expr = false;
+      break;
+

     case LABEL_EXPR:
       op0 = TREE_OPERAND (node, 0);
       /* If this is for break or continue, don't bother printing it.  */
     case LABEL_EXPR:
       op0 = TREE_OPERAND (node, 0);
       /* If this is for break or continue, don't bother printing it.  */


@@ -1532,6 +1593,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);


@@ -1838,9 +1909,21 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
     case OMP_SECTIONS:
       pp_string (buffer, "#pragma omp sections");
 
     case OMP_SECTIONS:
       pp_string (buffer, "#pragma omp sections");

+      if (OMP_SECTIONS_CONTROL (node))
+       {
+         pp_string (buffer, " <");
+         dump_generic_node (buffer, OMP_SECTIONS_CONTROL (node), spc,
+                            flags, false);
+         pp_string (buffer, ">");
+       }

       dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
       goto dump_omp_body;
 
       dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
       goto dump_omp_body;
 

+    case OMP_SECTIONS_SWITCH:
+      pp_string (buffer, "OMP_SECTIONS_SWITCH");
+      is_expr = false;
+      break;
+ 

     case OMP_SECTION:
       pp_string (buffer, "#pragma omp section");
       goto dump_omp_body;
     case OMP_SECTION:
       pp_string (buffer, "#pragma omp section");
       goto dump_omp_body;


@@ -1875,6 +1958,23 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
       break;
 
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
       break;
 

+    case OMP_ATOMIC_LOAD:
+      pp_string (buffer, "#pragma omp atomic_load");
+      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);
+      pp_character (buffer, '*');
+      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      break;
+
+    case OMP_ATOMIC_STORE:
+      pp_string (buffer, "#pragma omp atomic_store (");
+      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+

     case OMP_SINGLE:
       pp_string (buffer, "#pragma omp single");
       dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
     case OMP_SINGLE:
       pp_string (buffer, "#pragma omp single");
       dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);


@@ -1888,7 +1988,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       break;
 
     case OMP_CONTINUE:
       break;
 
     case OMP_CONTINUE:

-      pp_string (buffer, "OMP_CONTINUE");
+      pp_string (buffer, "OMP_CONTINUE <");
+      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, ">");

       is_expr = false;
       break;
 
       is_expr = false;
       break;
 


@@ -1943,6 +2047,18 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_string (buffer, " > ");
       break;
 
       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);
     case VEC_PACK_TRUNC_EXPR:
       pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);


@@ -1950,7 +2066,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
       pp_string (buffer, " > ");
       break;
       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);
     case VEC_PACK_SAT_EXPR:
       pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);


@@ -1958,7 +2074,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
       pp_string (buffer, " > ");
       break;
       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:
       {
        tree t;
     case BLOCK:
       {
        tree t;


@@ -2055,7 +2179,11 @@ 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;
 }
 
   return spc;
 }


@@ -2156,7 +2284,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))


@@ -2227,7 +2355,7 @@ print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
    operators.  */
 
 static int
    operators.  */
 
 static int

-op_prio (tree op)
+op_prio (const_tree op)

 {
   if (op == NULL)
     return 9999;
 {
   if (op == NULL)
     return 9999;


@@ -2291,6 +2419,7 @@ op_prio (tree op)
 
     case WIDEN_SUM_EXPR:
     case PLUS_EXPR:
 
     case WIDEN_SUM_EXPR:
     case PLUS_EXPR:

+    case POINTER_PLUS_EXPR:

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


@@ -2348,6 +2477,8 @@ op_prio (tree op)
     case VEC_RSHIFT_EXPR:
     case VEC_UNPACK_HI_EXPR:
     case VEC_UNPACK_LO_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;
     case VEC_PACK_TRUNC_EXPR:
     case VEC_PACK_SAT_EXPR:
       return 16;


@@ -2364,10 +2495,10 @@ op_prio (tree op)
 }
 
 
 }
 
 

-/* Return the symbol associated with operator OP.  */
+/* Return the symbol associated with operator CODE.  */

 
 

-static const char *
-op_symbol_1 (enum tree_code code)
+const char *
+op_symbol_code (enum tree_code code)

 {
   switch (code)
     {
 {
   switch (code)
     {


@@ -2447,6 +2578,9 @@ op_symbol_1 (enum tree_code code)
 
     case VEC_RSHIFT_EXPR:
       return "v>>";
 
     case VEC_RSHIFT_EXPR:
       return "v>>";

+
+    case POINTER_PLUS_EXPR:
+      return "+";

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


@@ -2531,16 +2665,18 @@ op_symbol_1 (enum tree_code code)
     }
 }
 
     }
 }
 

+/* Return the symbol associated with operator OP.  */
+

 static const char *
 static const char *

-op_symbol (tree op)
+op_symbol (const_tree op)

 {
 {

-  return op_symbol_1 (TREE_CODE (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;
 
 {
   tree op0;
 


@@ -2954,6 +3090,29 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
 {
   edge e;
   edge_iterator ei;
 {
   edge e;
   edge_iterator ei;

+  tree stmt;
+
+  stmt = last_stmt (bb);
+  if (stmt && TREE_CODE (stmt) == COND_EXPR)
+    {
+      edge true_edge, false_edge;
+
+      /* When we are emitting the code or changing CFG, it is possible that
+        the edges are not yet created.  When we are using debug_bb in such
+        a situation, we do not want it to crash.  */
+      if (EDGE_COUNT (bb->succs) != 2)
+       return;
+      extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
+
+      INDENT (indent + 2);
+      pp_cfg_jump (buffer, true_edge->dest);
+      newline_and_indent (buffer, indent);
+      pp_string (buffer, "else");
+      newline_and_indent (buffer, indent + 2);
+      pp_cfg_jump (buffer, false_edge->dest);
+      pp_newline (buffer);
+      return;
+    }

 
   /* If there is a fallthru edge, we may need to add an artificial goto to the
      dump.  */
 
   /* If there is a fallthru edge, we may need to add an artificial goto to the
      dump.  */


@@ -2964,20 +3123,10 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
     {
       INDENT (indent);
 
     {
       INDENT (indent);
 

-      if ((flags & TDF_LINENO)
-#ifdef USE_MAPPED_LOCATION
-         && e->goto_locus != UNKNOWN_LOCATION
-#else
-         && e->goto_locus
-#endif
-         )
+      if ((flags & TDF_LINENO) && e->goto_locus != UNKNOWN_LOCATION)

        {
          expanded_location goto_xloc;
        {
          expanded_location goto_xloc;

-#ifdef USE_MAPPED_LOCATION

          goto_xloc = expand_location (e->goto_locus);
          goto_xloc = expand_location (e->goto_locus);

-#else
-         goto_xloc = *e->goto_locus;
-#endif

          pp_character (buffer, '[');
          if (goto_xloc.file)
            {
          pp_character (buffer, '[');
          if (goto_xloc.file)
            {