X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fgimple-pretty-print.c;h=0480f9d43967fd0bff0c9ae74b5ca4046b9e4f5d;hb=375703a34fbe5d37882dce434bdc8699b54ecec2;hp=d334d856982eb44caadfe4ed712f9241f567ab32;hpb=75a70cf95f65fe9204b15ad9aba31c571381d224;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index d334d856982..0480f9d4396 100644
--- a/gcc/gimple-pretty-print.c
+++ b/gcc/gimple-pretty-print.c
@@ -1,5 +1,5 @@
 /* Pretty formatting of GIMPLE statements and expressions.
-   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
    Free Software Foundation, Inc.
    Contributed by Aldy Hernandez <aldyh@redhat.com> and
    Diego Novillo <dnovillo@google.com>
@@ -26,7 +26,8 @@ along with GCC; see the file COPYING3.  If not see
 #include "tm.h"
 #include "tree.h"
 #include "diagnostic.h"
-#include "real.h"
+#include "tree-pretty-print.h"
+#include "gimple-pretty-print.h"
 #include "hashtab.h"
 #include "tree-flow.h"
 #include "tree-pass.h"
@@ -228,7 +229,7 @@ dump_gimple_fmt (pretty_printer *buffer, int spc, int flags,
               default:
                 gcc_unreachable ();
             }
-        } 
+        }
       else
         pp_character (buffer, *c);
     }
@@ -254,25 +255,33 @@ dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
       break;
 
     case FIXED_CONVERT_EXPR:
+    case ADDR_SPACE_CONVERT_EXPR:
     case FIX_TRUNC_EXPR:
     case FLOAT_EXPR:
     CASE_CONVERT:
-      pp_string (buffer, "(");
+      pp_character (buffer, '(');
       dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false);
       pp_string (buffer, ") ");
-      dump_generic_node (buffer, rhs, spc, flags, false);
+      if (op_prio (rhs) < op_code_prio (rhs_code))
+	{
+	  pp_character (buffer, '(');
+	  dump_generic_node (buffer, rhs, spc, flags, false);
+	  pp_character (buffer, ')');
+	}
+      else
+	dump_generic_node (buffer, rhs, spc, flags, false);
       break;
-      
+
     case PAREN_EXPR:
       pp_string (buffer, "((");
       dump_generic_node (buffer, rhs, spc, flags, false);
       pp_string (buffer, "))");
       break;
-      
+
     case ABS_EXPR:
       pp_string (buffer, "ABS_EXPR <");
       dump_generic_node (buffer, rhs, spc, flags, false);
-      pp_string (buffer, ">");
+      pp_character (buffer, '>');
       break;
 
     default:
@@ -282,21 +291,31 @@ dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
 	  || rhs_code == SSA_NAME
 	  || rhs_code == ADDR_EXPR
 	  || rhs_code == CONSTRUCTOR)
-	; /* do nothing.  */
+	{
+	  dump_generic_node (buffer, rhs, spc, flags, false);
+	  break;
+	}
       else if (rhs_code == BIT_NOT_EXPR)
-	pp_string (buffer, "~");
+	pp_character (buffer, '~');
       else if (rhs_code == TRUTH_NOT_EXPR)
-	pp_string (buffer, "!");
+	pp_character (buffer, '!');
       else if (rhs_code == NEGATE_EXPR)
-	pp_string (buffer, "-");
+	pp_character (buffer, '-');
       else
 	{
-	  pp_string (buffer, "[");
+	  pp_character (buffer, '[');
 	  pp_string (buffer, tree_code_name [rhs_code]);
 	  pp_string (buffer, "] ");
 	}
 
-      dump_generic_node (buffer, rhs, spc, flags, false);
+      if (op_prio (rhs) < op_code_prio (rhs_code))
+	{
+	  pp_character (buffer, '(');
+	  dump_generic_node (buffer, rhs, spc, flags, false);
+	  pp_character (buffer, ')');
+	}
+      else
+	dump_generic_node (buffer, rhs, spc, flags, false);
       break;
     }
 }
@@ -308,38 +327,53 @@ dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
 static void
 dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
 {
-  switch (gimple_assign_rhs_code (gs))
+  const char *p;
+  enum tree_code code = gimple_assign_rhs_code (gs);
+  switch (code)
     {
     case COMPLEX_EXPR:
-      pp_string (buffer, "COMPLEX_EXPR <");
-      dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
-      pp_string (buffer, ", ");
-      dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
-      pp_string (buffer, ">");
-      break;
-      
     case MIN_EXPR:
-      pp_string (buffer, "MIN_EXPR <");
-      dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
-      pp_string (buffer, ", ");
-      dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
-      pp_string (buffer, ">");
-      break;
-      
     case MAX_EXPR:
-      pp_string (buffer, "MAX_EXPR <");
+    case VEC_WIDEN_MULT_HI_EXPR:
+    case VEC_WIDEN_MULT_LO_EXPR:
+    case VEC_PACK_TRUNC_EXPR:
+    case VEC_PACK_SAT_EXPR:
+    case VEC_PACK_FIX_TRUNC_EXPR:
+    case VEC_EXTRACT_EVEN_EXPR:
+    case VEC_EXTRACT_ODD_EXPR:
+    case VEC_INTERLEAVE_HIGH_EXPR:
+    case VEC_INTERLEAVE_LOW_EXPR:
+      for (p = tree_code_name [(int) code]; *p; p++)
+	pp_character (buffer, TOUPPER (*p));
+      pp_string (buffer, " <");
       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
-      pp_string (buffer, ">");
+      pp_character (buffer, '>');
       break;
 
     default:
-      dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
+      if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code))
+	{
+	  pp_character (buffer, '(');
+	  dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags,
+			     false);
+	  pp_character (buffer, ')');
+	}
+      else
+	dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
       pp_space (buffer);
       pp_string (buffer, op_symbol_code (gimple_assign_rhs_code (gs)));
       pp_space (buffer);
-      dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
+      if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code))
+	{
+	  pp_character (buffer, '(');
+	  dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags,
+			     false);
+	  pp_character (buffer, ')');
+	}
+      else
+	dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
     }
 }
 
@@ -444,6 +478,60 @@ dump_gimple_call_args (pretty_printer *buffer, gimple gs, int flags)
     }
 }
 
+/* Dump the points-to solution *PT to BUFFER.  */
+
+static void
+pp_points_to_solution (pretty_printer *buffer, struct pt_solution *pt)
+{
+  if (pt->anything)
+    {
+      pp_string (buffer, "anything ");
+      return;
+    }
+  if (pt->nonlocal)
+    pp_string (buffer, "nonlocal ");
+  if (pt->escaped)
+    pp_string (buffer, "escaped ");
+  if (pt->ipa_escaped)
+    pp_string (buffer, "unit-escaped ");
+  if (pt->null)
+    pp_string (buffer, "null ");
+  if (pt->vars
+      && !bitmap_empty_p (pt->vars))
+    {
+      bitmap_iterator bi;
+      unsigned i;
+      pp_string (buffer, "{ ");
+      EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
+	{
+	  struct tree_decl_minimal in;
+	  tree var;
+	  in.uid = i;
+	  var = (tree) htab_find_with_hash (gimple_referenced_vars (cfun),
+					    &in, i);
+	  if (var)
+	    {
+	      dump_generic_node (buffer, var, 0, dump_flags, false);
+	      if (DECL_PT_UID (var) != DECL_UID (var))
+		{
+		  pp_string (buffer, "ptD.");
+		  pp_decimal_int (buffer, DECL_PT_UID (var));
+		}
+	    }
+	  else
+	    {
+	      pp_string (buffer, "D.");
+	      pp_decimal_int (buffer, i);
+	    }
+	  pp_character (buffer, ' ');
+	}
+      pp_character (buffer, '}');
+      if (pt->vars_contains_global)
+	pp_string (buffer, " (glob)");
+      if (pt->vars_contains_restrict)
+	pp_string (buffer, " (restr)");
+    }
+}
 
 /* Dump the call statement GS.  BUFFER, SPC and FLAGS are as in
    dump_gimple_stmt.  */
@@ -453,6 +541,25 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
 {
   tree lhs = gimple_call_lhs (gs);
 
+  if (flags & TDF_ALIAS)
+    {
+      struct pt_solution *pt;
+      pt = gimple_call_use_set (gs);
+      if (!pt_solution_empty_p (pt))
+	{
+	  pp_string (buffer, "# USE = ");
+	  pp_points_to_solution (buffer, pt);
+	  newline_and_indent (buffer, spc);
+	}
+      pt = gimple_call_clobber_set (gs);
+      if (!pt_solution_empty_p (pt))
+	{
+	  pp_string (buffer, "# CLB = ");
+	  pp_points_to_solution (buffer, pt);
+	  newline_and_indent (buffer, spc);
+	}
+    }
+
   if (flags & TDF_RAW)
     {
       dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T",
@@ -462,7 +569,7 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
           pp_string (buffer, ", ");
           dump_gimple_call_args (buffer, gs, flags);
         }
-      pp_string (buffer, ">");
+      pp_character (buffer, '>');
     }
   else
     {
@@ -476,10 +583,10 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
 
 	  pp_space (buffer);
         }
-      dump_generic_node (buffer, gimple_call_fn (gs), spc, flags, false);
+      print_call_name (buffer, gimple_call_fn (gs), flags);
       pp_string (buffer, " (");
       dump_gimple_call_args (buffer, gs, flags);
-      pp_string (buffer, ")");
+      pp_character (buffer, ')');
       if (!(flags & TDF_RHS_ONLY))
 	pp_semicolon (buffer);
     }
@@ -525,12 +632,12 @@ dump_gimple_switch (pretty_printer *buffer, gimple gs, int spc, int flags)
 	continue;
 
       dump_generic_node (buffer, case_label, spc, flags, false);
-      pp_string (buffer, " ");
+      pp_character (buffer, ' ');
       dump_generic_node (buffer, CASE_LABEL (case_label), spc, flags, false);
       if (i < gimple_switch_num_labels (gs) - 1)
         pp_string (buffer, ", ");
     }
-  pp_string (buffer, ">");
+  pp_character (buffer, '>');
 }
 
 
@@ -556,7 +663,7 @@ dump_gimple_cond (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false);
       if (!(flags & TDF_RHS_ONLY))
 	{
-	  pp_string (buffer, ")");
+	  pp_character (buffer, ')');
 
 	  if (gimple_cond_true_label (gs))
 	    {
@@ -590,10 +697,12 @@ dump_gimple_label (pretty_printer *buffer, gimple gs, int spc, int flags)
   else
     {
       dump_generic_node (buffer, label, spc, flags, false);
-      pp_string (buffer, ":");
+      pp_character (buffer, ':');
     }
   if (DECL_NONLOCAL (label))
     pp_string (buffer, " [non-local]");
+  if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label))
+    pp_printf (buffer, " [LP %d]", EH_LANDING_PAD_NR (label));
 }
 
 /* Dump a GIMPLE_GOTO tuple on the pretty_printer BUFFER, SPC
@@ -668,26 +777,26 @@ dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags)
     {
       pp_string (buffer, "try");
       newline_and_indent (buffer, spc + 2);
-      pp_string (buffer, "{");
+      pp_character (buffer, '{');
       pp_newline (buffer);
 
       dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags);
       newline_and_indent (buffer, spc + 2);
-      pp_string (buffer, "}");
+      pp_character (buffer, '}');
 
       if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
 	{
 	  newline_and_indent (buffer, spc);
 	  pp_string (buffer, "catch");
 	  newline_and_indent (buffer, spc + 2);
-	  pp_string (buffer, "{");
+	  pp_character (buffer, '{');
 	}
       else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
 	{
 	  newline_and_indent (buffer, spc);
 	  pp_string (buffer, "finally");
 	  newline_and_indent (buffer, spc + 2);
-	  pp_string (buffer, "{");
+	  pp_character (buffer, '{');
 	}
       else
 	pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {");
@@ -734,6 +843,21 @@ dump_gimple_eh_filter (pretty_printer *buffer, gimple gs, int spc, int flags)
 }
 
 
+/* Dump a GIMPLE_EH_MUST_NOT_THROW tuple.  */
+
+static void
+dump_gimple_eh_must_not_throw (pretty_printer *buffer, gimple gs,
+			       int spc, int flags)
+{
+  if (flags & TDF_RAW)
+    dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
+		     gimple_eh_must_not_throw_fndecl (gs));
+  else
+    dump_gimple_fmt (buffer, spc, flags, "<<<eh_must_not_throw (%T)>>>",
+		     gimple_eh_must_not_throw_fndecl (gs));
+}
+
+
 /* Dump a GIMPLE_RESX tuple on the pretty_printer BUFFER, SPC spaces of
    indent.  FLAGS specifies details to show in the dump (see TDF_* in
    tree-pass.h).  */
@@ -743,11 +867,49 @@ dump_gimple_resx (pretty_printer *buffer, gimple gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
-                     gimple_resx_region (gs));
+		     gimple_resx_region (gs));
   else
     dump_gimple_fmt (buffer, spc, flags, "resx %d", gimple_resx_region (gs));
 }
 
+/* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER.  */
+
+static void
+dump_gimple_eh_dispatch (pretty_printer *buffer, gimple gs, int spc, int flags)
+{
+  if (flags & TDF_RAW)
+    dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
+		     gimple_eh_dispatch_region (gs));
+  else
+    dump_gimple_fmt (buffer, spc, flags, "eh_dispatch %d",
+		     gimple_eh_dispatch_region (gs));
+}
+
+/* Dump a GIMPLE_DEBUG tuple on the pretty_printer BUFFER, SPC spaces
+   of indent.  FLAGS specifies details to show in the dump (see TDF_*
+   in tree-pass.h).  */
+
+static void
+dump_gimple_debug (pretty_printer *buffer, gimple gs, int spc, int flags)
+{
+  switch (gs->gsbase.subcode)
+    {
+    case GIMPLE_DEBUG_BIND:
+      if (flags & TDF_RAW)
+	dump_gimple_fmt (buffer, spc, flags, "%G BIND <%T, %T>", gs,
+			 gimple_debug_bind_get_var (gs),
+			 gimple_debug_bind_get_value (gs));
+      else
+	dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T => %T",
+			 gimple_debug_bind_get_var (gs),
+			 gimple_debug_bind_get_value (gs));
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+}
+
 /* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER.  */
 static void
 dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
@@ -1014,115 +1176,150 @@ dump_gimple_omp_return (pretty_printer *buffer, gimple gs, int spc, int flags)
 static void
 dump_gimple_asm (pretty_printer *buffer, gimple gs, int spc, int flags)
 {
-  unsigned int i;
+  unsigned int i, n, f, fields;
 
   if (flags & TDF_RAW)
-    dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs,
-                     gimple_asm_string (gs));
-  else
-    {
-      pp_string (buffer, "__asm__");
-      if (gimple_asm_volatile_p (gs))
-	pp_string (buffer, " __volatile__");
-      pp_string (buffer, "(\"");
-      pp_string (buffer, gimple_asm_string (gs));
-      pp_string (buffer, "\"");
-    }
-
-  if (gimple_asm_ninputs (gs)
-     || gimple_asm_noutputs (gs) 
-     || gimple_asm_nclobbers (gs))
     {
-      if (gimple_asm_noutputs (gs))
-        {
-          if (flags & TDF_RAW)
-            {
-              newline_and_indent (buffer, spc + 2);
-              pp_string (buffer, "OUTPUT: ");
-            }
-          else
-            pp_string (buffer, " : ");
-        }
+      dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs,
+                       gimple_asm_string (gs));
 
-      for (i = 0; i < gimple_asm_noutputs (gs); i++)
-        {
-          dump_generic_node (buffer, gimple_asm_output_op (gs, i), spc, flags,
-                             false);
-          if ( i < gimple_asm_noutputs (gs) -1)
-            pp_string (buffer, ", ");
-        }
+      n = gimple_asm_noutputs (gs);
+      if (n)
+	{
+	  newline_and_indent (buffer, spc + 2);
+	  pp_string (buffer, "OUTPUT: ");
+	  for (i = 0; i < n; i++)
+	    {
+	      dump_generic_node (buffer, gimple_asm_output_op (gs, i),
+				 spc, flags, false);
+	      if (i < n - 1)
+		pp_string (buffer, ", ");
+	    }
+	}
 
-      if (gimple_asm_ninputs (gs))
-        {
-          if (flags & TDF_RAW)
-            {
-              newline_and_indent (buffer, spc + 2);
-              pp_string (buffer, "INPUT: ");
-            }
-          else
-            pp_string (buffer, " : ");
-        }
+      n = gimple_asm_ninputs (gs);
+      if (n)
+	{
+	  newline_and_indent (buffer, spc + 2);
+	  pp_string (buffer, "INPUT: ");
+	  for (i = 0; i < n; i++)
+	    {
+	      dump_generic_node (buffer, gimple_asm_input_op (gs, i),
+				 spc, flags, false);
+	      if (i < n - 1)
+		pp_string (buffer, ", ");
+	    }
+	}
 
-      for (i = 0; i < gimple_asm_ninputs (gs); i++)
-        {
-          dump_generic_node (buffer, gimple_asm_input_op (gs, i), spc, flags,
-                             false);
-          if (i < gimple_asm_ninputs (gs) -1)
-            pp_string (buffer, " : ");
-        }
+      n = gimple_asm_nclobbers (gs);
+      if (n)
+	{
+	  newline_and_indent (buffer, spc + 2);
+	  pp_string (buffer, "CLOBBER: ");
+	  for (i = 0; i < n; i++)
+	    {
+	      dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
+				 spc, flags, false);
+	      if (i < n - 1)
+		pp_string (buffer, ", ");
+	    }
+	}
 
-      if (gimple_asm_nclobbers (gs))
-        {
-          if (flags & TDF_RAW)
-            {
-              newline_and_indent (buffer, spc + 2);
-              pp_string (buffer, "CLOBBER: ");
-            }
-          else
-            pp_string (buffer, " : ");
-        }
+      n = gimple_asm_nlabels (gs);
+      if (n)
+	{
+	  newline_and_indent (buffer, spc + 2);
+	  pp_string (buffer, "LABEL: ");
+	  for (i = 0; i < n; i++)
+	    {
+	      dump_generic_node (buffer, gimple_asm_label_op (gs, i),
+				 spc, flags, false);
+	      if (i < n - 1)
+		pp_string (buffer, ", ");
+	    }
+	}
 
-      for (i = 0; i < gimple_asm_nclobbers (gs); i++)
-        {
-          dump_generic_node (buffer, gimple_asm_clobber_op (gs, i), spc, flags,
-                             false);
-          if ( i < gimple_asm_nclobbers (gs) -1)
-            pp_string (buffer, ", ");
-        }
-    }
-  if (flags & TDF_RAW)
-    {
       newline_and_indent (buffer, spc);
       pp_character (buffer, '>');
     }
   else
-    pp_string (buffer, ");");
-}
+    {
+      pp_string (buffer, "__asm__");
+      if (gimple_asm_volatile_p (gs))
+	pp_string (buffer, " __volatile__");
+      if (gimple_asm_nlabels (gs))
+	pp_string (buffer, " goto");
+      pp_string (buffer, "(\"");
+      pp_string (buffer, gimple_asm_string (gs));
+      pp_string (buffer, "\"");
 
+      if (gimple_asm_nlabels (gs))
+	fields = 4;
+      else if (gimple_asm_nclobbers (gs))
+	fields = 3;
+      else if (gimple_asm_ninputs (gs))
+	fields = 2;
+      else if (gimple_asm_noutputs (gs))
+	fields = 1;
+      else
+	fields = 0;
 
-/* Dump the set of decls SYMS.  BUFFER, SPC and FLAGS are as in
-   dump_generic_node.  */
+      for (f = 0; f < fields; ++f)
+	{
+	  pp_string (buffer, " : ");
 
-static void
-dump_symbols (pretty_printer *buffer, bitmap syms, int flags)
-{
-  unsigned i;
-  bitmap_iterator bi;
+	  switch (f)
+	    {
+	    case 0:
+	      n = gimple_asm_noutputs (gs);
+	      for (i = 0; i < n; i++)
+		{
+		  dump_generic_node (buffer, gimple_asm_output_op (gs, i),
+				     spc, flags, false);
+		  if (i < n - 1)
+		    pp_string (buffer, ", ");
+		}
+	      break;
 
-  if (syms == NULL)
-    pp_string (buffer, "NIL");
-  else
-    {
-      pp_string (buffer, " { ");
+	    case 1:
+	      n = gimple_asm_ninputs (gs);
+	      for (i = 0; i < n; i++)
+		{
+		  dump_generic_node (buffer, gimple_asm_input_op (gs, i),
+				     spc, flags, false);
+		  if (i < n - 1)
+		    pp_string (buffer, ", ");
+		}
+	      break;
 
-      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, " ");
+	    case 2:
+	      n = gimple_asm_nclobbers (gs);
+	      for (i = 0; i < n; i++)
+		{
+		  dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
+				     spc, flags, false);
+		  if (i < n - 1)
+		    pp_string (buffer, ", ");
+		}
+	      break;
+
+	    case 3:
+	      n = gimple_asm_nlabels (gs);
+	      for (i = 0; i < n; i++)
+		{
+		  dump_generic_node (buffer, gimple_asm_label_op (gs, i),
+				     spc, flags, false);
+		  if (i < n - 1)
+		    pp_string (buffer, ", ");
+		}
+	      break;
+
+	    default:
+	      gcc_unreachable ();
+	    }
 	}
 
-      pp_string (buffer, "}");
+      pp_string (buffer, ");");
     }
 }
 
@@ -1134,26 +1331,53 @@ static void
 dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, int flags)
 {
   size_t i;
+  tree lhs = gimple_phi_result (phi);
+
+  if (flags & TDF_ALIAS
+      && POINTER_TYPE_P (TREE_TYPE (lhs))
+      && SSA_NAME_PTR_INFO (lhs))
+    {
+      pp_string (buffer, "PT = ");
+      pp_points_to_solution (buffer, &SSA_NAME_PTR_INFO (lhs)->pt);
+      newline_and_indent (buffer, spc);
+      pp_string (buffer, "# ");
+    }
 
   if (flags & TDF_RAW)
       dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", phi,
                        gimple_phi_result (phi));
   else
     {
-      dump_generic_node (buffer, gimple_phi_result (phi), spc, flags, false);
+      dump_generic_node (buffer, lhs, spc, flags, false);
       pp_string (buffer, " = PHI <");
     }
   for (i = 0; i < gimple_phi_num_args (phi); i++)
     {
+      if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i))
+        {
+	  expanded_location xloc;
+
+	  xloc = expand_location (gimple_phi_arg_location (phi, i));
+	  pp_character (buffer, '[');
+	  if (xloc.file)
+	    {
+	      pp_string (buffer, xloc.file);
+	      pp_string (buffer, " : ");
+	    }
+	  pp_decimal_int (buffer, xloc.line);
+	  pp_string (buffer, ":");
+	  pp_decimal_int (buffer, xloc.column);
+	  pp_string (buffer, "] ");
+	}
       dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags,
 			 false);
-      pp_string (buffer, "(");
+      pp_character (buffer, '(');
       pp_decimal_int (buffer, gimple_phi_arg_edge (phi, i)->src->index);
-      pp_string (buffer, ")");
+      pp_character (buffer, ')');
       if (i < gimple_phi_num_args (phi) - 1)
 	pp_string (buffer, ", ");
     }
-  pp_string (buffer, ">");
+  pp_character (buffer, '>');
 }
 
 
@@ -1319,27 +1543,6 @@ dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc,
     }
 }
 
-/* Dump a GIMPLE_CHANGE_DYNAMIC_TYPE statement GS.  BUFFER, SPC and
-   FLAGS are as in dump_gimple_stmt.  */
-
-static void
-dump_gimple_cdt (pretty_printer *buffer, gimple gs, int spc, int flags)
-{
-  if (flags & TDF_RAW)
-    dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
-                     gimple_cdt_new_type (gs), gimple_cdt_location (gs));
-  else
-    {
-      pp_string (buffer, "<<<change_dynamic_type (");
-      dump_generic_node (buffer, gimple_cdt_new_type (gs), spc + 2, flags,
-                         false);
-      pp_string (buffer, ") ");
-      dump_generic_node (buffer, gimple_cdt_location (gs), spc + 2, flags,
-                         false);
-      pp_string (buffer, ")>>>");
-    }
-}
-
 
 /* Dump all the memory operands for statement GS.  BUFFER, SPC and
    FLAGS are as in dump_gimple_stmt.  */
@@ -1347,81 +1550,27 @@ dump_gimple_cdt (pretty_printer *buffer, gimple gs, int spc, int flags)
 static void
 dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, int spc, int flags)
 {
-  struct voptype_d *vdefs;
-  struct voptype_d *vuses;
-  int i, n;
+  tree vdef = gimple_vdef (gs);
+  tree vuse = gimple_vuse (gs);
 
   if (!ssa_operands_active () || !gimple_references_memory_p (gs))
     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)
-      && gimple_vuse_ops (gs) == NULL
-      && gimple_vdef_ops (gs) == NULL)
+  if (vdef != NULL_TREE)
     {
-      if (gimple_loaded_syms (gs))
-	{
-	  pp_string (buffer, "# LOADS: ");
-	  dump_symbols (buffer, gimple_loaded_syms (gs), flags);
-	  newline_and_indent (buffer, spc);
-	}
-
-      if (gimple_stored_syms (gs))
-	{
-	  pp_string (buffer, "# STORES: ");
-	  dump_symbols (buffer, gimple_stored_syms (gs), flags);
-	  newline_and_indent (buffer, spc);
-	}
-
-      return;
-    }
-
-  vuses = gimple_vuse_ops (gs);
-  while (vuses)
-    {
-      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, gimple_loaded_syms (gs), flags);
-
+      pp_string (buffer, "# ");
+      dump_generic_node (buffer, vdef, spc + 2, flags, false);
+      pp_string (buffer, " = VDEF <");
+      dump_generic_node (buffer, vuse, spc + 2, flags, false);
+      pp_character (buffer, '>');
       newline_and_indent (buffer, spc);
-      vuses = vuses->next;
     }
-
-  vdefs = gimple_vdef_ops (gs);
-  while (vdefs)
+  else if (vuse != NULL_TREE)
     {
-      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, gimple_stored_syms (gs), flags);
-
+      pp_string (buffer, "# VUSE <");
+      dump_generic_node (buffer, vuse, spc + 2, flags, false);
+      pp_character (buffer, '>');
       newline_and_indent (buffer, spc);
-      vdefs = vdefs->next;
     }
 }
 
@@ -1449,13 +1598,38 @@ dump_gimple_stmt (pretty_printer *buffer, gimple gs, int spc, int flags)
 	  pp_string (buffer, " : ");
 	}
       pp_decimal_int (buffer, xloc.line);
+      pp_string (buffer, ":");
+      pp_decimal_int (buffer, xloc.column);
       pp_string (buffer, "] ");
     }
 
+  if (flags & TDF_EH)
+    {
+      int lp_nr = lookup_stmt_eh_lp (gs);
+      if (lp_nr > 0)
+	pp_printf (buffer, "[LP %d] ", lp_nr);
+      else if (lp_nr < 0)
+	pp_printf (buffer, "[MNT %d] ", -lp_nr);
+    }
+
   if ((flags & (TDF_VOPS|TDF_MEMSYMS))
       && gimple_has_mem_ops (gs))
     dump_gimple_mem_ops (buffer, gs, spc, flags);
 
+  if ((flags & TDF_ALIAS)
+      && gimple_has_lhs (gs))
+    {
+      tree lhs = gimple_get_lhs (gs);
+      if (TREE_CODE (lhs) == SSA_NAME
+	  && POINTER_TYPE_P (TREE_TYPE (lhs))
+	  && SSA_NAME_PTR_INFO (lhs))
+	{
+	  pp_string (buffer, "# PT = ");
+	  pp_points_to_solution (buffer, &SSA_NAME_PTR_INFO (lhs)->pt);
+	  newline_and_indent (buffer, spc);
+	}
+    }
+
   switch (gimple_code (gs))
     {
     case GIMPLE_ASM:
@@ -1557,10 +1731,6 @@ dump_gimple_stmt (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_gimple_omp_critical (buffer, gs, spc, flags);
       break;
 
-    case GIMPLE_CHANGE_DYNAMIC_TYPE:
-      dump_gimple_cdt (buffer, gs, spc, flags);
-      break;
-
     case GIMPLE_CATCH:
       dump_gimple_catch (buffer, gs, spc, flags);
       break;
@@ -1569,10 +1739,22 @@ dump_gimple_stmt (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_gimple_eh_filter (buffer, gs, spc, flags);
       break;
 
+    case GIMPLE_EH_MUST_NOT_THROW:
+      dump_gimple_eh_must_not_throw (buffer, gs, spc, flags);
+      break;
+
     case GIMPLE_RESX:
       dump_gimple_resx (buffer, gs, spc, flags);
       break;
 
+    case GIMPLE_EH_DISPATCH:
+      dump_gimple_eh_dispatch (buffer, gs, spc, flags);
+      break;
+
+    case GIMPLE_DEBUG:
+      dump_gimple_debug (buffer, gs, spc, flags);
+      break;
+
     case GIMPLE_PREDICT:
       pp_string (buffer, "// predicted ");
       if (gimple_predict_outcome (gs))
@@ -1626,12 +1808,19 @@ dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
 	  gimple_stmt_iterator gsi;
 
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-	    if (get_lineno (gsi_stmt (gsi)) != -1)
+	    if (!is_gimple_debug (gsi_stmt (gsi))
+		&& get_lineno (gsi_stmt (gsi)) != UNKNOWN_LOCATION)
 	      {
 		pp_string (buffer, ", starting at line ");
 		pp_decimal_int (buffer, get_lineno (gsi_stmt (gsi)));
 		break;
 	      }
+
+          if (bb->discriminator)
+            {
+              pp_string (buffer, ", discriminator ");
+	      pp_decimal_int (buffer, bb->discriminator);
+            }
 	}
       newline_and_indent (buffer, indent);
 
@@ -1640,7 +1829,7 @@ dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
       FOR_EACH_EDGE (e, ei, bb->preds)
 	if (flags & TDF_SLIM)
 	  {
-	    pp_string (buffer, " ");
+	    pp_character (buffer, ' ');
 	    if (e->src == ENTRY_BLOCK_PTR)
 	      pp_string (buffer, "ENTRY");
 	    else
@@ -1682,7 +1871,7 @@ dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
   FOR_EACH_EDGE (e, ei, bb->succs)
     if (flags & TDF_SLIM)
       {
-	pp_string (buffer, " ");
+	pp_character (buffer, ' ');
 	if (e->dest == EXIT_BLOCK_PTR)
 	  pp_string (buffer, "EXIT");
 	else
@@ -1728,12 +1917,12 @@ pp_cfg_jump (pretty_printer *buffer, basic_block bb)
 
   pp_string (buffer, "goto <bb ");
   pp_decimal_int (buffer, bb->index);
-  pp_string (buffer, ">");
+  pp_character (buffer, '>');
   if (stmt && gimple_code (stmt) == GIMPLE_LABEL)
     {
       pp_string (buffer, " (");
       dump_generic_node (buffer, gimple_label_label (stmt), 0, 0, false);
-      pp_string (buffer, ")");
+      pp_character (buffer, ')');
       pp_semicolon (buffer);
     }
   else
@@ -1798,6 +1987,8 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
 	      pp_string (buffer, " : ");
 	    }
 	  pp_decimal_int (buffer, goto_xloc.line);
+	  pp_string (buffer, " : ");
+	  pp_decimal_int (buffer, goto_xloc.column);
 	  pp_string (buffer, "] ");
 	}