* basic-block.h (profile_staus): New global variable.

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

diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index 9d415fa..1821700 100644 (file)
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -31,6 +31,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "tree-flow.h"
 #include "langhooks.h"
 #include "tree-iterator.h"
+#include "tree-chrec.h"
 
 /* Local functions, macros and variables.  */
 static int op_prio (tree);
@@ -164,7 +165,10 @@ dump_decl_name (pretty_printer *buffer, tree node, int flags)
        pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
                   LABEL_DECL_UID (node));
       else
-       pp_printf (buffer, "<D%u>", DECL_UID (node));
+       {
+         char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
+         pp_printf (buffer, "<%c%u>", c, DECL_UID (node));
+       }
     }
 }
 
@@ -378,27 +382,37 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       {
        tree tmp;
 
-       /* Print the array type.  */
-       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
+       /* Print the innermost component type.  */
+       for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
+            tmp = TREE_TYPE (tmp))
+         ;
+       dump_generic_node (buffer, tmp, spc, flags, false);
 
        /* Print the dimensions.  */
-       tmp = node;
-       while (tmp && TREE_CODE (tmp) == ARRAY_TYPE)
+       for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE;
+            tmp = TREE_TYPE (tmp))
          {
+           tree domain = TYPE_DOMAIN (tmp);
+
            pp_character (buffer, '[');
-           if (TYPE_SIZE (tmp))
+           if (domain)
              {
-               tree size = TYPE_SIZE (tmp);
-               if (TREE_CODE (size) == INTEGER_CST)
-                 pp_wide_integer (buffer,
-                                 TREE_INT_CST_LOW (TYPE_SIZE (tmp)) /
-                                 TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp))));
-               else if (TREE_CODE (size) == MULT_EXPR)
-                 dump_generic_node (buffer, TREE_OPERAND (size, 0), spc, flags, false);
-               /* else punt.  */
+               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, ']');
-           tmp = TREE_TYPE (tmp);
          }
        break;
       }
@@ -611,12 +625,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
        pp_character (buffer, ')');
       pp_string (buffer, str);
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
-      if (TREE_OPERAND (node, 2)
-         && TREE_CODE (TREE_OPERAND (node, 2)) != INTEGER_CST)
+
+      op0 = component_ref_field_offset (node);
+      if (op0 && TREE_CODE (op0) != INTEGER_CST)
        {
          pp_string (buffer, "{off: ");
-         dump_generic_node (buffer, TREE_OPERAND (node, 2),
-                            spc, flags, false);
+         dump_generic_node (buffer, op0, spc, flags, false);
          pp_character (buffer, '}');
        }
       break;
@@ -631,10 +645,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_string (buffer, ">");
       break;
 
-    case BUFFER_REF:
-      NIY;
-      break;
-
     case ARRAY_REF:
     case ARRAY_RANGE_REF:
       op0 = TREE_OPERAND (node, 0);
@@ -649,17 +659,17 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
        pp_string (buffer, " ...");
       pp_character (buffer, ']');
 
-      if ((TREE_OPERAND (node, 2)
-          && TREE_CODE (TREE_OPERAND (node, 2)) != INTEGER_CST)
-         || (TREE_OPERAND (node, 3)
-             && TREE_CODE (TREE_OPERAND (node, 3)) != INTEGER_CST))
+      op0 = array_ref_low_bound (node);
+      op1 = array_ref_element_size (node);
+
+      if (!integer_zerop (op0)
+         || (TYPE_SIZE_UNIT (TREE_TYPE (node))
+             && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
        {
          pp_string (buffer, "{lb: ");
-         dump_generic_node (buffer, TREE_OPERAND (node, 2),
-                            spc, flags, false);
+         dump_generic_node (buffer, op0, spc, flags, false);
          pp_string (buffer, " sz: ");
-         dump_generic_node (buffer, TREE_OPERAND (node, 3),
-                            spc, flags, false);
+         dump_generic_node (buffer, op1, spc, flags, false);
          pp_character (buffer, '}');
        }
       break;
@@ -747,7 +757,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)
          {
            pp_string (buffer, "<STATEMENT_LIST>");
@@ -891,6 +901,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_TAILCALL (node))
        pp_string (buffer, " [tail call]");
       break;
@@ -989,7 +1001,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case BIT_NOT_EXPR:
     case TRUTH_NOT_EXPR:
     case ADDR_EXPR:
-    case REFERENCE_EXPR:
     case PREDECREMENT_EXPR:
     case PREINCREMENT_EXPR:
     case INDIRECT_REF:
@@ -1045,18 +1056,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_character (buffer, '>');
       break;
 
-    case IN_EXPR:
-      NIY;
-      break;
-
-    case SET_LE_EXPR:
-      NIY;
-      break;
-
-    case CARD_EXPR:
-      NIY;
-      break;
-
     case RANGE_EXPR:
       NIY;
       break;
@@ -1103,16 +1102,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_character (buffer, '>');
       break;
 
-    case UNSAVE_EXPR:
-      pp_string (buffer, "UNSAVE_EXPR <");
-      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-      pp_character (buffer, '>');
-      break;
-
-    case RTL_EXPR:
-      NIY;
-      break;
-
     case ENTRY_VALUE_EXPR:
       NIY;
       break;
@@ -1196,10 +1185,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       is_expr = false;
       break;
 
-    case GOTO_SUBROUTINE_EXPR:
-      NIY;
-      break;
-
     case LABEL_EXPR:
       op0 = TREE_OPERAND (node, 0);
       /* If this is for break or continue, don't bother printing it.  */
@@ -1427,10 +1412,36 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_decimal_int (buffer, SSA_NAME_VERSION (node));
       break;
 
+    case WITH_SIZE_EXPR:
+      pp_string (buffer, "WITH_SIZE_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 VALUE_HANDLE:
       pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
       break;
 
+    case SCEV_KNOWN:
+      pp_string (buffer, "scev_known");
+      break;
+
+    case SCEV_NOT_KNOWN:
+      pp_string (buffer, "scev_not_known");
+      break;
+
+    case POLYNOMIAL_CHREC:
+      pp_string (buffer, "{");
+      dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
+      pp_string (buffer, ", +, ");
+      dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
+      pp_string (buffer, "}_");
+      dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
+      is_stmt = false;
+      break;
+
     default:
       NIY;
     }
@@ -1845,9 +1856,6 @@ op_symbol (tree op)
     case POSTINCREMENT_EXPR:
       return "++ ";
 
-    case REFERENCE_EXPR:
-      return "";
-
     default:
       return "<<< ??? >>>";
     }
@@ -2040,10 +2048,10 @@ dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
   for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
     {
       pp_string (buffer, "#   ");
-      dump_generic_node (buffer, V_MAY_DEF_RESULT (v_may_defs, i), 
+      dump_generic_node (buffer, V_MAY_DEF_RESULT (v_may_defs, i),
                          spc + 2, flags, false);
       pp_string (buffer, " = V_MAY_DEF <");
-      dump_generic_node (buffer, V_MAY_DEF_OP (v_may_defs, i), 
+      dump_generic_node (buffer, V_MAY_DEF_OP (v_may_defs, i),
                          spc + 2, flags, false);
       pp_string (buffer, ">;");
       newline_and_indent (buffer, spc);
@@ -2136,6 +2144,8 @@ dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
          pp_newline (buffer);
        }
     }
+  pp_write_text_to_stream (buffer);
+  check_bb_profile (bb, buffer->buffer->stream);
 }
 
 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
@@ -2272,7 +2282,7 @@ dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
 
   if (bb_ann (bb))
     dump_phi_nodes (buffer, bb, indent, flags);
-  
+
   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
     {
       int curr_indent;