2004-07-14 Andreas Tobler <a.tobler@schweiz.ch>

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

diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index 9eb478c..e660b44 100644 (file)
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -231,13 +231,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       && (flags & TDF_LINENO)
       && EXPR_HAS_LOCATION (node))
     {
+      expanded_location xloc = expand_location (EXPR_LOCATION (node));
       pp_character (buffer, '[');
-      if (EXPR_FILENAME (node))
+      if (xloc.file)
        {
-         pp_string (buffer, EXPR_FILENAME (node));
+         pp_string (buffer, xloc.file);
          pp_string (buffer, " : ");
        }
-      pp_decimal_int (buffer, EXPR_LINENO (node));
+      pp_decimal_int (buffer, xloc.line);
       pp_string (buffer, "] ");
     }
 
@@ -377,27 +378,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;
       }
@@ -556,7 +567,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       break;
 
     case TYPE_DECL:
-      if (strcmp (DECL_SOURCE_FILE (node), "<built-in>") == 0)
+      if (DECL_IS_BUILTIN (node))
        {
          /* Don't print the declaration of built-in types.  */
          break;
@@ -610,12 +621,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;
@@ -630,10 +641,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);
@@ -648,17 +655,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;
@@ -988,7 +995,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:
@@ -1044,18 +1050,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;
@@ -1108,10 +1102,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_character (buffer, '>');
       break;
 
-    case RTL_EXPR:
-      NIY;
-      break;
-
     case ENTRY_VALUE_EXPR:
       NIY;
       break;
@@ -1195,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.  */
@@ -1844,9 +1830,6 @@ op_symbol (tree op)
     case POSTINCREMENT_EXPR:
       return "++ ";
 
-    case REFERENCE_EXPR:
-      return "";
-
     default:
       return "<<< ??? >>>";
     }
@@ -2224,15 +2207,27 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
     {
       INDENT (indent);
 
-      if ((flags & TDF_LINENO) && e->goto_locus)
+      if ((flags & TDF_LINENO)
+#ifdef USE_MAPPED_LOCATION
+         && e->goto_locus != UNKNOWN_LOCATION
+#else
+         && e->goto_locus
+#endif
+         )
        {
+         expanded_location goto_xloc;
+#ifdef USE_MAPPED_LOCATION
+         goto_xloc = expand_location (e->goto_locus);
+#else
+         goto_xloc = *e->goto_locus;
+#endif
          pp_character (buffer, '[');
-         if (e->goto_locus->file)
+         if (goto_xloc.file)
            {
-             pp_string (buffer, e->goto_locus->file);
+             pp_string (buffer, goto_xloc.file);
              pp_string (buffer, " : ");
            }
-         pp_decimal_int (buffer, e->goto_locus->line);
+         pp_decimal_int (buffer, goto_xloc.line);
          pp_string (buffer, "] ");
        }