X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-pretty-print.c;h=8d5ca276ae83f06bb428623d4a37b65da764ed3c;hb=1b7fd1d90f9ed8ed108ecac8c2cf12a80c3f9728;hp=d0b9aedc1566a8f0b487aafec090ec3b5888786e;hpb=a1080ab2d44eb7cb0dac6b2d6a54ecbc632a0646;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index d0b9aedc156..8d5ca276ae8 100644
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -1,5 +1,6 @@
 /* Pretty formatting of GENERIC trees in C syntax.
-   Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
+   Free Software Foundation, Inc.
    Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
 
 This file is part of GCC.
@@ -16,14 +17,13 @@ for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
 
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
-#include "errors.h"
 #include "tree.h"
 #include "diagnostic.h"
 #include "real.h"
@@ -32,9 +32,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "langhooks.h"
 #include "tree-iterator.h"
 #include "tree-chrec.h"
+#include "tree-pass.h"
+#include "value-prof.h"
 
 /* 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 void pretty_print_string (pretty_printer *, const char*);
 static void print_call_name (pretty_printer *, tree);
@@ -58,7 +61,6 @@ static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
 
 static pretty_printer buffer;
 static int initialized = 0;
-static bool dumping_stmts;
 
 /* Try to print something for an unknown tree code.  */
 
@@ -70,9 +72,9 @@ do_niy (pretty_printer *buffer, tree node)
   pp_string (buffer, "<<< Unknown tree: ");
   pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
 
-  if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (node))))
+  if (EXPR_P (node))
     {
-      len = first_rtl_op (TREE_CODE (node));
+      len = TREE_OPERAND_LENGTH (node);
       for (i = 0; i < len; ++i)
 	{
 	  newline_and_indent (buffer, 2);
@@ -86,14 +88,26 @@ do_niy (pretty_printer *buffer, tree node)
 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");
 }
 
 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");
+}
+
+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");
 }
 
@@ -102,7 +116,6 @@ void
 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);
 }
@@ -114,7 +127,6 @@ 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);
 }
@@ -129,7 +141,6 @@ print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
   int i;
 
   maybe_init_pretty_print (file);
-  dumping_stmts = true;
 
   for (i = 0; i < indent; i++)
     pp_space (&buffer);
@@ -144,7 +155,6 @@ 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);
 }
 
@@ -154,20 +164,21 @@ print_generic_expr (FILE *file, tree t, 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)
-      || 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." HOST_WIDE_INT_PRINT_DEC,
+		   LABEL_DECL_UID (t));
       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));
 	}
     }
 }
@@ -217,6 +228,208 @@ dump_function_declaration (pretty_printer *buffer, tree node,
   pp_character (buffer, ')');
 }
 
+/* Dump the domain associated with an array.  */
+
+static void
+dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
+{
+  pp_character (buffer, '[');
+  if (domain)
+    {
+      tree min = TYPE_MIN_VALUE (domain);
+      tree max = TYPE_MAX_VALUE (domain);
+
+      if (min && max
+	  && integer_zerop (min)
+	  && host_integerp (max, 0))
+	pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
+      else
+	{
+	  if (min)
+	    dump_generic_node (buffer, min, spc, flags, false);
+	  pp_character (buffer, ':');
+	  if (max)
+	    dump_generic_node (buffer, max, spc, flags, false);
+	}
+    }
+  else
+    pp_string (buffer, "<unknown>");
+  pp_character (buffer, ']');
+}
+
+
+/* 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_1 (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;
+      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;
+      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;
+
+    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.  */
+
+static 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 the set of decls SYMS.  BUFFER, SPC and FLAGS are as in
+   dump_generic_node.  */
+
+static void
+dump_symbols (pretty_printer *buffer, bitmap syms, int flags)
+{
+  unsigned i;
+  bitmap_iterator bi;
+
+  if (syms == NULL)
+    pp_string (buffer, "NIL");
+  else
+    {
+      pp_string (buffer, " { ");
+
+      EXECUTE_IF_SET_IN_BITMAP (syms, 0, i, bi)
+	{
+	  tree sym = referenced_var_lookup (i);
+	  dump_generic_node (buffer, sym, 0, flags, false);
+	  pp_string (buffer, " ");
+	}
+
+      pp_string (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
@@ -234,17 +447,23 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
   if (node == NULL_TREE)
     return spc;
 
-  is_expr = EXPR_P (node);
+  is_expr = EXPR_P (node) || GIMPLE_STMT_P (node);
 
+  /* We use has_stmt_ann because CALL_EXPR can be both an expression
+     and a statement, and we have no guarantee that it will have a
+     stmt_ann when it is used as an RHS expression.  stmt_ann will assert
+     if you call it on something with a non-stmt annotation attached.  */
   if (TREE_CODE (node) != ERROR_MARK
       && is_gimple_stmt (node)
-      && (flags & TDF_VOPS)
-      && stmt_ann (node))
+      && (flags & (TDF_VOPS|TDF_MEMSYMS))
+      && has_stmt_ann (node)
+      && TREE_CODE (node) != PHI_NODE)
     dump_vops (buffer, node, spc, flags);
 
-  if (dumping_stmts
-      && (flags & TDF_LINENO)
-      && EXPR_HAS_LOCATION (node))
+  if (is_stmt && (flags & TDF_STMTADDR))
+    pp_printf (buffer, "<&%p> ", (void *)node);
+
+  if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
     {
       expanded_location xloc = expand_location (EXPR_LOCATION (node));
       pp_character (buffer, '[');
@@ -285,12 +504,26 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	}
       break;
 
-    case TREE_VEC:
+    case TREE_BINFO:
       dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
-      break;
 
-    case BLOCK:
-      NIY;
+    case TREE_VEC:
+      {
+	size_t i;
+	if (TREE_VEC_LENGTH (node) > 0)
+	  {
+	    size_t len = TREE_VEC_LENGTH (node);
+	    for (i = 0; i < len - 1; i++)
+	      {	    
+		dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
+				   false);
+		pp_character (buffer, ',');
+		pp_space (buffer);
+	      }
+	    dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc, 
+			       flags, false);
+	  }
+      }
       break;
 
     case VOID_TYPE:
@@ -300,10 +533,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case VECTOR_TYPE:
     case ENUMERAL_TYPE:
     case BOOLEAN_TYPE:
-    case CHAR_TYPE:
       {
 	unsigned int quals = TYPE_QUALS (node);
-	char class;
+	enum tree_code_class class;
 
 	if (quals & TYPE_QUAL_CONST)
 	  pp_string (buffer, "const ");
@@ -314,14 +546,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
 	class = TREE_CODE_CLASS (TREE_CODE (node));
 
-	if (class == 'd')
+	if (class == tcc_declaration)
 	  {
 	    if (DECL_NAME (node))
 	      dump_decl_name (buffer, node, flags);
 	    else
               pp_string (buffer, "<unnamed type decl>");
 	  }
-	else if (class == 't')
+	else if (class == tcc_type)
 	  {
 	    if (TYPE_NAME (node))
 	      {
@@ -331,7 +563,13 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 			 && DECL_NAME (TYPE_NAME (node)))
 		  dump_decl_name (buffer, TYPE_NAME (node), flags);
 		else
-                  pp_string (buffer, "<unnamed type>");
+		  pp_string (buffer, "<unnamed type>");
+	      }
+	    else if (TREE_CODE (node) == VECTOR_TYPE)
+	      {
+		pp_string (buffer, "vector ");
+		dump_generic_node (buffer, TREE_TYPE (node), 
+				   spc, flags, false);
 	      }
 	    else
               pp_string (buffer, "<unnamed type>");
@@ -373,6 +611,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	    pp_string (buffer,  "volatile");
 	  else if (quals & TYPE_QUAL_RESTRICT)
 	    pp_string (buffer, " restrict");
+
+	  if (TYPE_REF_CAN_ALIAS_ALL (node))
+	    pp_string (buffer, " {ref-all}");
 	}
       break;
 
@@ -385,8 +626,62 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_string (buffer, "::");
       break;
 
-    case FILE_TYPE:
-      NIY;
+    case TARGET_MEM_REF:
+      {
+	const char *sep = "";
+	tree tmp;
+
+	pp_string (buffer, "MEM[");
+
+	tmp = TMR_SYMBOL (node);
+	if (tmp)
+	  {
+	    pp_string (buffer, sep);
+	    sep = ", ";
+	    pp_string (buffer, "symbol: ");
+	    dump_generic_node (buffer, tmp, spc, flags, false);
+	  }
+	tmp = TMR_BASE (node);
+	if (tmp)
+	  {
+	    pp_string (buffer, sep);
+	    sep = ", ";
+	    pp_string (buffer, "base: ");
+	    dump_generic_node (buffer, tmp, spc, flags, false);
+	  }
+	tmp = TMR_INDEX (node);
+	if (tmp)
+	  {
+	    pp_string (buffer, sep);
+	    sep = ", ";
+	    pp_string (buffer, "index: ");
+	    dump_generic_node (buffer, tmp, spc, flags, false);
+	  }
+	tmp = TMR_STEP (node);
+	if (tmp)
+	  {
+	    pp_string (buffer, sep);
+	    sep = ", ";
+	    pp_string (buffer, "step: ");
+	    dump_generic_node (buffer, tmp, spc, flags, false);
+	  }
+	tmp = TMR_OFFSET (node);
+	if (tmp)
+	  {
+	    pp_string (buffer, sep);
+	    sep = ", ";
+	    pp_string (buffer, "offset: ");
+	    dump_generic_node (buffer, tmp, spc, flags, false);
+	  }
+	pp_string (buffer, "]");
+	if (flags & TDF_DETAILS)
+	  {
+	    pp_string (buffer, "{");
+	    dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
+			       false);
+	    pp_string (buffer, "}");
+	  }
+      }
       break;
 
     case ARRAY_TYPE:
@@ -400,38 +695,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	dump_generic_node (buffer, tmp, spc, flags, false);
 
 	/* Print the dimensions.  */
-	for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE;
-	     tmp = TREE_TYPE (tmp))
-	  {
-	    tree domain = TYPE_DOMAIN (tmp);
-
-	    pp_character (buffer, '[');
-	    if (domain)
-	      {
-		if (TYPE_MIN_VALUE (domain)
-		    && !integer_zerop (TYPE_MIN_VALUE (domain)))
-		  {
-		    dump_generic_node (buffer, TYPE_MIN_VALUE (domain),
-				       spc, flags, false);
-		    pp_string (buffer, " .. ");
-		  }
-
-		if (TYPE_MAX_VALUE (domain))
-		  dump_generic_node (buffer, TYPE_MAX_VALUE (domain),
-				     spc, flags, false);
-	      }
-	    else
-	      pp_string (buffer, "<unknown>");
-
-	    pp_character (buffer, ']');
-	  }
+	for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
+	  dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
 	break;
       }
 
-    case SET_TYPE:
-      NIY;
-      break;
-
     case RECORD_TYPE:
     case UNION_TYPE:
     case QUAL_UNION_TYPE:
@@ -480,26 +748,20 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       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, '-');
-	      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?  */
-	  {
-	    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, high, low);
+	  pp_string (buffer, pp_buffer (buffer)->digit_buffer);
 	}
       else
 	pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
@@ -515,7 +777,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))
-	  pp_string (buffer, " Inf");
+	  pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
 	else if (REAL_VALUE_ISNAN (d))
 	  pp_string (buffer, " Nan");
 	else
@@ -611,10 +873,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	}
       break;
 
+    case SYMBOL_MEMORY_TAG:
+    case NAME_MEMORY_TAG:
+    case STRUCT_FIELD_TAG:
     case VAR_DECL:
     case PARM_DECL:
     case FIELD_DECL:
     case NAMESPACE_DECL:
+    case MEMORY_PARTITION_TAG:
       dump_decl_name (buffer, node, flags);
       break;
 
@@ -691,36 +957,29 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
     case CONSTRUCTOR:
       {
-	tree lnode;
+	unsigned HOST_WIDE_INT ix;
+	tree field, val;
 	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;
-	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, '.');
-		dump_generic_node (buffer, TREE_PURPOSE (lnode), spc, flags, false);
+		dump_generic_node (buffer, field, spc, flags, false);
 		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)
-	      {
 		dump_decl_name (buffer, val, flags);
-	      }
 	    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);
@@ -740,8 +999,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  }
 
 	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
 	  {
@@ -754,8 +1013,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),
-			       spc, flags, dumping_stmts);
-	    if (dumping_stmts)
+			       spc, flags, !(flags & TDF_SLIM));
+	    if (flags & TDF_SLIM)
 	      newline_and_indent (buffer, spc);
 	    else
 	      {
@@ -764,7 +1023,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;
 
@@ -773,7 +1032,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	tree_stmt_iterator si;
 	bool first = true;
 
-	if ((flags & TDF_SLIM) || !dumping_stmts)
+	if (flags & TDF_SLIM)
 	  {
 	    pp_string (buffer, "<STATEMENT_LIST>");
 	    break;
@@ -791,12 +1050,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       break;
 
     case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
     case INIT_EXPR:
-      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      dump_generic_node (buffer, GENERIC_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);
+      dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
+	  		 false);
       break;
 
     case TARGET_EXPR:
@@ -821,14 +1083,21 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  pp_character (buffer, ')');
 	  /* The lowered cond_exprs should always be printed in full.  */
 	  if (COND_EXPR_THEN (node)
-	      && TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR
+	      && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
+		  || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
 	      && COND_EXPR_ELSE (node)
-	      && TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)
+	      && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
+		  || 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))
 	    {
@@ -845,7 +1114,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 		}
 
 	      /* 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");
@@ -903,12 +1173,22 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       /* 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);
+	      }
+	  }
+      }
       pp_character (buffer, ')');
 
-      op1 = TREE_OPERAND (node, 2);
+      op1 = CALL_EXPR_STATIC_CHAIN (node);
       if (op1)
 	{
 	  pp_string (buffer, " [static-chain: ");
@@ -916,8 +1196,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  pp_character (buffer, ']');
 	}
 
-      if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (node))
-	pp_string (buffer, " [return slot addr]");
+      if (CALL_EXPR_RETURN_SLOT_OPT (node))
+	pp_string (buffer, " [return slot optimization]");
       if (CALL_EXPR_TAILCALL (node))
 	pp_string (buffer, " [tail call]");
       break;
@@ -939,6 +1219,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       break;
 
       /* Binary arithmetic and logic expressions.  */
+    case WIDEN_SUM_EXPR:
+    case WIDEN_MULT_EXPR:
     case MULT_EXPR:
     case PLUS_EXPR:
     case MINUS_EXPR:
@@ -956,6 +1238,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case RSHIFT_EXPR:
     case LROTATE_EXPR:
     case RROTATE_EXPR:
+    case VEC_LSHIFT_EXPR:
+    case VEC_RSHIFT_EXPR:
     case BIT_IOR_EXPR:
     case BIT_XOR_EXPR:
     case BIT_AND_EXPR:
@@ -985,7 +1269,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.  */
-	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);
@@ -1000,7 +1284,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.  */
-	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);
@@ -1018,6 +1302,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case ADDR_EXPR:
     case PREDECREMENT_EXPR:
     case PREINCREMENT_EXPR:
+    case ALIGN_INDIRECT_REF:
+    case MISALIGNED_INDIRECT_REF:
     case INDIRECT_REF:
       if (TREE_CODE (node) == ADDR_EXPR
 	  && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
@@ -1034,6 +1320,13 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	}
       else
 	dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+
+      if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
+        {
+          pp_string (buffer, "{misalignment: ");
+          dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+          pp_character (buffer, '}');
+        }
       break;
 
     case POSTDECREMENT_EXPR:
@@ -1076,9 +1369,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       break;
 
     case FIX_TRUNC_EXPR:
-    case FIX_CEIL_EXPR:
-    case FIX_FLOOR_EXPR:
-    case FIX_ROUND_EXPR:
     case FLOAT_EXPR:
     case CONVERT_EXPR:
     case NOP_EXPR:
@@ -1212,48 +1502,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	pp_string (buffer, " [non-local]");
       break;
 
-    case LABELED_BLOCK_EXPR:
-      op0 = LABELED_BLOCK_LABEL (node);
-      /* If this is for break or continue, don't bother printing it.  */
-      if (DECL_NAME (op0))
-	{
-	  const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
-	  if (strcmp (name, "break") == 0
-	      || strcmp (name, "continue") == 0)
-	    {
-	      dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc, flags, false);
-	      break;
-	    }
-	}
-      dump_generic_node (buffer, LABELED_BLOCK_LABEL (node), spc, flags, false);
-      pp_string (buffer, ": {");
-      if (!(flags & TDF_SLIM))
-	newline_and_indent (buffer, spc+2);
-      dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc+2, flags, true);
-      if (!flags)
-	newline_and_indent (buffer, spc);
-      pp_character (buffer, '}');
-      is_expr = false;
-      break;
-
-    case EXIT_BLOCK_EXPR:
-      op0 = LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (node));
-      /* If this is for a break or continue, print it accordingly.  */
-      if (DECL_NAME (op0))
-	{
-	  const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
-	  if (strcmp (name, "break") == 0
-	      || strcmp (name, "continue") == 0)
-	    {
-	      pp_string (buffer, name);
-	      break;
-	    }
-	}
-      pp_string (buffer, "<<<exit block ");
-      dump_generic_node (buffer, op0, spc, flags, false);
-      pp_string (buffer, ">>>");
-      break;
-
     case EXC_PTR_EXPR:
       pp_string (buffer, "<<<exception object>>>");
       break;
@@ -1282,8 +1530,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       if (op0)
 	{
 	  pp_space (buffer);
-	  if (TREE_CODE (op0) == MODIFY_EXPR)
-	    dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
+	  if (TREE_CODE (op0) == MODIFY_EXPR
+	      || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
+	    dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
+			       spc, flags, false);
 	  else
 	    dump_generic_node (buffer, op0, spc, flags, false);
 	}
@@ -1306,7 +1556,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  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
 	    {
@@ -1316,10 +1567,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);
-		  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);
@@ -1330,9 +1587,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
     case GOTO_EXPR:
       op0 = GOTO_DESTINATION (node);
-      if (TREE_CODE (op0) != SSA_NAME
-	  && DECL_P (op0)
-	  && DECL_NAME (op0))
+      if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
 	{
 	  const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
 	  if (strcmp (name, "break") == 0
@@ -1347,8 +1602,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       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:
@@ -1413,7 +1668,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	    if (i < PHI_NUM_ARGS (node) - 1)
 	      pp_string (buffer, ", ");
 	  }
-	pp_string (buffer, ">;");
+	pp_string (buffer, ">");
+
+	if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS))
+	  dump_symbols (buffer, STORED_SYMS (node), flags);
       }
       break;
 
@@ -1421,6 +1679,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       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:
@@ -1435,6 +1697,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       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);
+      pp_string (buffer, ", ");
+      dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
+      pp_string (buffer, ">");
+      break;
+
     case SCEV_KNOWN:
       pp_string (buffer, "scev_known");
       break;
@@ -1453,6 +1723,324 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       is_stmt = false;
       break;
 
+    case REALIGN_LOAD_EXPR:
+      pp_string (buffer, "REALIGN_LOAD <");
+      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;
+      
+    case VEC_COND_EXPR:
+      pp_string (buffer, " VEC_COND_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, " , ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case DOT_PROD_EXPR:
+      pp_string (buffer, " DOT_PROD_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, ", ");
+      dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
+      pp_string (buffer, " > ");
+      break;
+
+    case OMP_PARALLEL:
+      pp_string (buffer, "#pragma omp parallel");
+      dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
+      if (OMP_PARALLEL_FN (node))
+	{
+	  pp_string (buffer, " [child fn: ");
+	  dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
+
+	  pp_string (buffer, " (");
+
+	  if (OMP_PARALLEL_DATA_ARG (node))
+	    dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
+		               false);
+	  else
+	    pp_string (buffer, "???");
+
+	  pp_string (buffer, ")]");
+	}
+
+    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;
+
+    case OMP_FOR:
+      pp_string (buffer, "#pragma omp for");
+      dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
+
+      if (!(flags & TDF_SLIM))
+	{
+	  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);
+	    }
+	  newline_and_indent (buffer, spc);
+	  pp_string (buffer, "for (");
+	  dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
+	  pp_string (buffer, "; ");
+	  dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
+	  pp_string (buffer, "; ");
+	  dump_generic_node (buffer, OMP_FOR_INCR (node), 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, '}');
+	    }
+	  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_RETURN:
+      pp_string (buffer, "OMP_RETURN");
+      if (OMP_RETURN_NOWAIT (node))
+	pp_string (buffer, " [nowait]");
+      is_expr = false;
+      break;
+
+    case OMP_CONTINUE:
+      pp_string (buffer, "OMP_CONTINUE");
+      is_expr = false;
+      break;
+
+    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_PACK_MOD_EXPR:
+      pp_string (buffer, " VEC_PACK_MOD_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 BLOCK:
+      {
+	tree t;
+	pp_string (buffer, "BLOCK");
+
+	if (BLOCK_ABSTRACT (node))
+	  pp_string (buffer, " [abstract]");
+
+	if (TREE_ASM_WRITTEN (node))
+	  pp_string (buffer, " [written]");
+
+	newline_and_indent (buffer, spc + 2);
+
+	if (BLOCK_SUPERCONTEXT (node))
+	  {
+	    pp_string (buffer, "SUPERCONTEXT: ");
+	    if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
+	      pp_printf (buffer, "BLOCK %p",
+		         (void *)BLOCK_SUPERCONTEXT (node));
+	    else
+	      dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
+				 false);
+	    newline_and_indent (buffer, spc + 2);
+	  }
+
+	if (BLOCK_SUBBLOCKS (node))
+	  {
+	    pp_string (buffer, "SUBBLOCKS: ");
+	    for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
+	      pp_printf (buffer, "%p ", (void *)t);
+	    newline_and_indent (buffer, spc + 2);
+	  }
+
+	if (BLOCK_VARS (node))
+	  {
+	    pp_string (buffer, "VARS: ");
+	    for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
+	      {
+		dump_generic_node (buffer, t, 0, flags, false);
+		pp_string (buffer, " ");
+	      }
+	    newline_and_indent (buffer, spc + 2);
+	  }
+
+	if (BLOCK_ABSTRACT_ORIGIN (node))
+	  {
+	    pp_string (buffer, "ABSTRACT_ORIGIN: ");
+	    if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
+	      pp_printf (buffer, "BLOCK %p",
+			 (void *)BLOCK_ABSTRACT_ORIGIN (node));
+	    else
+	      dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
+				 false);
+	    newline_and_indent (buffer, spc + 2);
+	  }
+      }
+    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;
+
     default:
       NIY;
     }
@@ -1474,7 +2062,7 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
   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))
@@ -1501,18 +2089,7 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
       tmp = TREE_TYPE (t);
       while (TREE_CODE (tmp) == ARRAY_TYPE)
 	{
-	  pp_character (buffer, '[');
-	  if (TYPE_DOMAIN (tmp))
-	    {
-	      if (TREE_CODE (TYPE_SIZE (tmp)) == INTEGER_CST)
-		pp_wide_integer (buffer,
-				TREE_INT_CST_LOW (TYPE_SIZE (tmp)) /
-				TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp))));
-	      else
-		dump_generic_node (buffer, TYPE_SIZE_UNIT (tmp), spc, flags,
-				   false);
-	    }
-	  pp_character (buffer, ']');
+	  dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
 	  tmp = TREE_TYPE (tmp);
 	}
     }
@@ -1533,6 +2110,14 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
       dump_generic_node (buffer, t, spc, flags, false);
     }
 
+  if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
+    {
+      pp_string (buffer, " __asm__ ");
+      pp_character (buffer, '(');
+      dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
+      pp_character (buffer, ')');
+    }
+
   /* The initial value of a function serves to determine wether the function
      is declared or defined.  So the following does not apply to function
      nodes.  */
@@ -1548,6 +2133,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, ';');
 }
 
@@ -1640,6 +2232,7 @@ op_prio (tree op)
       return 1;
 
     case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
     case INIT_EXPR:
       return 2;
 
@@ -1688,10 +2281,15 @@ op_prio (tree op)
     case RROTATE_EXPR:
       return 11;
 
+    case WIDEN_SUM_EXPR:
     case PLUS_EXPR:
     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:
@@ -1712,15 +2310,14 @@ op_prio (tree op)
     case PREINCREMENT_EXPR:
     case PREDECREMENT_EXPR:
     case NEGATE_EXPR:
+    case ALIGN_INDIRECT_REF:
+    case MISALIGNED_INDIRECT_REF:
     case INDIRECT_REF:
     case ADDR_EXPR:
     case FLOAT_EXPR:
     case NOP_EXPR:
     case CONVERT_EXPR:
     case FIX_TRUNC_EXPR:
-    case FIX_CEIL_EXPR:
-    case FIX_FLOOR_EXPR:
-    case FIX_ROUND_EXPR:
     case TARGET_EXPR:
       return 14;
 
@@ -1736,6 +2333,15 @@ op_prio (tree op)
     case ABS_EXPR:
     case REALPART_EXPR:
     case IMAGPART_EXPR:
+    case REDUC_MAX_EXPR:
+    case REDUC_MIN_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_PACK_MOD_EXPR:
+    case VEC_PACK_SAT_EXPR:
       return 16;
 
     case SAVE_EXPR:
@@ -1753,13 +2359,12 @@ op_prio (tree op)
 /* Return the symbol associated with operator OP.  */
 
 static const char *
-op_symbol (tree op)
+op_symbol_1 (enum tree_code code)
 {
-  gcc_assert (op);
-
-  switch (TREE_CODE (op))
+  switch (code)
     {
     case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       return "=";
 
     case TRUTH_OR_EXPR:
@@ -1823,9 +2428,30 @@ op_symbol (tree op)
     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 PLUS_EXPR:
       return "+";
 
+    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 "-";
@@ -1840,6 +2466,12 @@ op_symbol (tree op)
     case INDIRECT_REF:
       return "*";
 
+    case ALIGN_INDIRECT_REF:
+      return "A*";
+
+    case MISALIGNED_INDIRECT_REF:
+      return "M*";
+
     case TRUNC_DIV_EXPR:
     case RDIV_EXPR:
       return "/";
@@ -1880,11 +2512,23 @@ op_symbol (tree op)
     case POSTINCREMENT_EXPR:
       return "++ ";
 
+    case MAX_EXPR:
+      return "max";
+
+    case MIN_EXPR:
+      return "min";
+
     default:
       return "<<< ??? >>>";
     }
 }
 
+static const char *
+op_symbol (tree op)
+{
+  return op_symbol_1 (TREE_CODE (op));
+}
+
 /* Prints the name of a CALL_EXPR.  */
 
 static void
@@ -1894,7 +2538,7 @@ print_call_name (pretty_printer *buffer, tree node)
 
   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);
@@ -1999,9 +2643,7 @@ pretty_print_string (pretty_printer *buffer, const char *str)
 	  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");
@@ -2059,43 +2701,89 @@ newline_and_indent (pretty_printer *buffer, int spc)
   INDENT (spc);
 }
 
+
 static void
 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
 {
-  tree use, def;
-  use_operand_p use_p;
-  def_operand_p def_p;
-  ssa_op_iter iter;
+  struct voptype_d *vdefs;
+  struct voptype_d *vuses;
+  int i, n;
 
-  FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
+  if (!ssa_operands_active () || !stmt_references_memory_p (stmt))
+    return;
+
+  /* Even if the statement doesn't have virtual operators yet, it may
+     contain symbol information (this happens before aliases have been
+     computed).  */
+  if ((flags & TDF_MEMSYMS)
+      && VUSE_OPS (stmt) == NULL
+      && VDEF_OPS (stmt) == NULL)
     {
-      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);
+      if (LOADED_SYMS (stmt))
+	{
+	  pp_string (buffer, "# LOADS: ");
+	  dump_symbols (buffer, LOADED_SYMS (stmt), flags);
+	  newline_and_indent (buffer, spc);
+	}
+
+      if (STORED_SYMS (stmt))
+	{
+	  pp_string (buffer, "# STORES: ");
+	  dump_symbols (buffer, STORED_SYMS (stmt), flags);
+	  newline_and_indent (buffer, spc);
+	}
+
+      return;
     }
 
-  FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMUSTDEF)
+  vuses = VUSE_OPS (stmt);
+  while (vuses)
     {
-      pp_string (buffer, "#   V_MUST_DEF <");
-      dump_generic_node (buffer, def, spc + 2, flags, false);
-      pp_string (buffer, ">;");
+      pp_string (buffer, "# VUSE <");
+
+      n = VUSE_NUM (vuses);
+      for (i = 0; i < n; i++)
+	{
+	  dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false);
+	  if (i < n - 1)
+	    pp_string (buffer, ", ");
+	}
+
+      pp_string (buffer, ">");
+
+      if (flags & TDF_MEMSYMS)
+	dump_symbols (buffer, LOADED_SYMS (stmt), flags);
+
       newline_and_indent (buffer, spc);
+      vuses = vuses->next;
     }
 
-  FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
+  vdefs = VDEF_OPS (stmt);
+  while (vdefs)
     {
-      pp_string (buffer, "#   VUSE <");
-      dump_generic_node (buffer, use, spc + 2, flags, false);
-      pp_string (buffer, ">;");
+      pp_string (buffer, "# ");
+      dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
+      pp_string (buffer, " = VDEF <");
+
+      n = VDEF_NUM (vdefs);
+      for (i = 0; i < n; i++)
+	{
+	  dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
+	  if (i < n - 1)
+	    pp_string (buffer, ", ");
+	}
+
+      pp_string (buffer, ">");
+
+      if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
+	dump_symbols (buffer, STORED_SYMS (stmt), flags);
+
       newline_and_indent (buffer, spc);
+      vdefs = vdefs->next;
     }
 }
 
+
 /* Dumps basic block BB to FILE with details described by FLAGS and
    indented by INDENT spaces.  */
 
@@ -2103,7 +2791,6 @@ 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);
 }
@@ -2116,12 +2803,23 @@ 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 (bb->frequency)
+	{
+          pp_string (buffer, " freq:");
+          pp_decimal_int (buffer, bb->frequency);
+	}
+      if (bb->count)
+	{
+          pp_string (buffer, " count:");
+          pp_widest_integer (buffer, bb->count);
+	}
 
       if (flags & TDF_LINENO)
 	{
@@ -2139,8 +2837,8 @@ dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
 
       pp_string (buffer, "# PRED:");
       pp_write_text_to_stream (buffer);
-      for (e = bb->pred; e; e = e->pred_next)
-        if (flags & TDF_SLIM)
+      FOR_EACH_EDGE (e, ei, bb->preds)
+	if (flags & TDF_SLIM)
 	  {
 	    pp_string (buffer, " ");
 	    if (e->src == ENTRY_BLOCK_PTR)
@@ -2175,11 +2873,12 @@ 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 (e = bb->succ; e; e = e->succ_next)
+  FOR_EACH_EDGE (e, ei, bb->succs)
     if (flags & TDF_SLIM)
       {
 	pp_string (buffer, " ");
@@ -2193,8 +2892,8 @@ dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
   pp_newline (buffer);
 }
 
-/* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
-   FLAGS indented by INDENT spaces.  */
+/* Dump PHI nodes of basic block BB to BUFFER with details described
+   by FLAGS and indented by INDENT spaces.  */
 
 static void
 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
@@ -2215,6 +2914,7 @@ dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
     }
 }
 
+
 /* Dump jump to basic block BB that is represented implicitly in the cfg
    to BUFFER.  */
 
@@ -2245,10 +2945,11 @@ 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 (e = bb->succ; e; e = e->succ_next)
+  FOR_EACH_EDGE (e, ei, bb->succs)
     if (e->flags & EDGE_FALLTHRU)
       break;
   if (e && e->dest != bb->next_bb)
@@ -2300,8 +3001,7 @@ dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
 
   dump_bb_header (buffer, bb, indent, flags);
 
-  if (bb_ann (bb))
-    dump_phi_nodes (buffer, bb, indent, flags);
+  dump_phi_nodes (buffer, bb, indent, flags);
 
   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
     {
@@ -2314,6 +3014,7 @@ dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
       INDENT (curr_indent);
       dump_generic_node (buffer, stmt, curr_indent, flags, true);
       pp_newline (buffer);
+      dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
     }
 
   dump_implicit_edges (buffer, bb, indent, flags);