* arm.c (arm_handle_notshared_attribute): Wrap declaration and use

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

diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index bcca1d8..3f2d4b6 100644 (file)
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -285,8 +285,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);
+
+    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 BLOCK:
@@ -331,7 +349,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>");
@@ -821,9 +845,11 @@ 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);
@@ -1470,6 +1496,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       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;
+
     default:
       NIY;
     }
@@ -1550,6 +1586,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.  */
@@ -1971,16 +2015,6 @@ print_call_name (pretty_printer *buffer, tree node)
       dump_generic_node (buffer, op0, 0, 0, false);
       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;
-
     default:
       NIY;
     }
@@ -2097,9 +2131,10 @@ newline_and_indent (pretty_printer *buffer, int spc)
 static void
 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
 {
-  tree use, def;
+  tree use;
   use_operand_p use_p;
   def_operand_p def_p;
+  use_operand_p kill_p;
   ssa_op_iter iter;
 
   FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
@@ -2114,10 +2149,14 @@ dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
       newline_and_indent (buffer, spc);
     }
 
-  FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMUSTDEF)
+  FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)
     {
-      pp_string (buffer, "#   V_MUST_DEF <");
-      dump_generic_node (buffer, def, spc + 2, flags, false);
+      pp_string (buffer, "#   ");
+      dump_generic_node (buffer, DEF_FROM_PTR (def_p),
+                         spc + 2, flags, false);
+      pp_string (buffer, " = V_MUST_DEF <");
+      dump_generic_node (buffer, USE_FROM_PTR (kill_p),
+                         spc + 2, flags, false);
       pp_string (buffer, ">;");
       newline_and_indent (buffer, spc);
     }
@@ -2151,6 +2190,7 @@ dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
 {
   edge e;
   tree stmt;
+  edge_iterator ei;
 
   if (flags & TDF_BLOCKS)
     {
@@ -2174,8 +2214,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)
@@ -2210,11 +2250,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, " ");
@@ -2280,10 +2321,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)