X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-pretty-print.c;h=6c1eed84dcc8af41c19c642aa4f337776c63834d;hb=54daa60094d5125e41489c6f6fe28a6ec3302473;hp=0d1e540a3b899f3d23077a42eef79cf8151d7b6f;hpb=153536dfc5a467f1f39b337175d2ced9d367b69c;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c index 0d1e540a3b8..6c1eed84dcc 100644 --- a/gcc/tree-pretty-print.c +++ b/gcc/tree-pretty-print.c @@ -1,5 +1,5 @@ /* Pretty formatting of GENERIC trees in C syntax. - Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc. + Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc. Adapted from c-pretty-print.c by Diego Novillo This file is part of GCC. @@ -70,9 +70,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_CODE_LENGTH (TREE_CODE (node)); for (i = 0; i < len; ++i) { newline_and_indent (buffer, 2); @@ -162,16 +162,27 @@ dump_decl_name (pretty_printer *buffer, tree node, int flags) { if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1) - pp_printf (buffer, "", + pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC, LABEL_DECL_UID (node)); else { char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D'; - pp_printf (buffer, "<%c%u>", c, DECL_UID (node)); + pp_printf (buffer, "%c.%u", c, DECL_UID (node)); } } } +/* Like the above, but used for pretty printing function calls. */ + +static void +dump_function_name (pretty_printer *buffer, tree node) +{ + if (DECL_NAME (node)) + PRINT_FUNCTION_NAME (node); + else + dump_decl_name (buffer, node, 0); +} + /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and FLAGS are as in dump_generic_node. */ @@ -206,6 +217,35 @@ 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, ""); + pp_character (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 @@ -274,8 +314,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: @@ -292,7 +350,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, 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 "); @@ -303,14 +361,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, ""); } - else if (class == 't') + else if (class == tcc_type) { if (TYPE_NAME (node)) { @@ -320,7 +378,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, ""); + pp_string (buffer, ""); + } + 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, ""); @@ -362,6 +426,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; @@ -389,38 +456,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, ""); - - 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: @@ -810,9 +850,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); @@ -1007,6 +1049,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 @@ -1023,6 +1067,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: @@ -1201,48 +1252,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, "<<>>"); - break; - case EXC_PTR_EXPR: pp_string (buffer, "<<>>"); break; @@ -1319,9 +1328,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 @@ -1442,6 +1449,26 @@ 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; + default: NIY; } @@ -1490,18 +1517,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); } } @@ -1522,6 +1538,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. */ @@ -1701,6 +1725,8 @@ 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: @@ -1744,8 +1770,7 @@ op_prio (tree op) static const char * op_symbol (tree op) { - if (op == NULL) - abort (); + gcc_assert (op); switch (TREE_CODE (op)) { @@ -1830,6 +1855,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 "/"; @@ -1882,8 +1913,7 @@ print_call_name (pretty_printer *buffer, tree node) { tree op0; - if (TREE_CODE (node) != CALL_EXPR) - abort (); + gcc_assert (TREE_CODE (node) == CALL_EXPR); op0 = TREE_OPERAND (node, 0); @@ -1894,7 +1924,7 @@ print_call_name (pretty_printer *buffer, tree node) { case VAR_DECL: case PARM_DECL: - PRINT_FUNCTION_NAME (op0); + dump_function_name (buffer, op0); break; case ADDR_EXPR: @@ -1916,7 +1946,7 @@ print_call_name (pretty_printer *buffer, tree node) /* The function is a pointer contained in a structure. */ if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF || TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL) - PRINT_FUNCTION_NAME (TREE_OPERAND (op0, 1)); + dump_function_name (buffer, TREE_OPERAND (op0, 1)); else dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false); /* else @@ -1927,7 +1957,7 @@ print_call_name (pretty_printer *buffer, tree node) case ARRAY_REF: if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL) - PRINT_FUNCTION_NAME (TREE_OPERAND (op0, 0)); + dump_function_name (buffer, TREE_OPERAND (op0, 0)); else dump_generic_node (buffer, op0, 0, 0, false); break; @@ -2053,9 +2083,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) @@ -2070,10 +2101,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); } @@ -2107,6 +2142,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) { @@ -2130,8 +2166,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) @@ -2166,11 +2202,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, " "); @@ -2236,10 +2273,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)