Mercurial > hg > CbC > CbC_gcc
diff gcc/tree-pretty-print.c @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
| author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Tue, 22 Mar 2011 17:18:12 +0900 |
| parents | b7f97abdc517 |
| children | 04ced10e8804 |
line wrap: on
line diff
--- a/gcc/tree-pretty-print.c Tue May 25 18:58:51 2010 +0900 +++ b/gcc/tree-pretty-print.c Tue Mar 22 17:18:12 2011 +0900 @@ -25,7 +25,6 @@ #include "tm.h" #include "tree.h" #include "output.h" -#include "diagnostic.h" #include "tree-pretty-print.h" #include "hashtab.h" #include "tree-flow.h" @@ -72,12 +71,12 @@ } } - pp_string (buffer, " >>>\n"); + pp_string (buffer, " >>>"); } /* Debugging function to print out a generic expression. */ -void +DEBUG_FUNCTION void debug_generic_expr (tree t) { print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS); @@ -86,7 +85,7 @@ /* Debugging function to print out a generic statement. */ -void +DEBUG_FUNCTION void debug_generic_stmt (tree t) { print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS); @@ -95,7 +94,7 @@ /* Debugging function to print out a chain of trees . */ -void +DEBUG_FUNCTION void debug_tree_chain (tree t) { struct pointer_set_t *seen = pointer_set_create (); @@ -539,7 +538,7 @@ VEC(tree,gc) *nlv = BLOCK_NONLOCALIZED_VARS (block); pp_string (buffer, "NONLOCALIZED_VARS: "); - for (i = 0; VEC_iterate (tree, nlv, i, t); i++) + FOR_EACH_VEC_ELT (tree, nlv, i, t) { dump_generic_node (buffer, t, 0, flags, false); pp_string (buffer, " "); @@ -733,6 +732,8 @@ pp_decimal_int (buffer, TYPE_PRECISION (node)); pp_string (buffer, ">"); } + else if (TREE_CODE (node) == VOID_TYPE) + pp_string (buffer, "void"); else pp_string (buffer, "<unnamed type>"); } @@ -758,6 +759,8 @@ pp_string (buffer, str); if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) dump_decl_name (buffer, TYPE_NAME (node), flags); + else if (flags & TDF_NOUID) + pp_printf (buffer, "<Txxxx>"); else pp_printf (buffer, "<T%x>", TYPE_UID (node)); @@ -795,6 +798,60 @@ NIY; break; + case MEM_REF: + { + if (integer_zerop (TREE_OPERAND (node, 1)) + /* Dump the types of INTEGER_CSTs explicitly, for we can't + infer them and MEM_ATTR caching will share MEM_REFs + with differently-typed op0s. */ + && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST + /* Same pointer types, but ignoring POINTER_TYPE vs. + REFERENCE_TYPE. */ + && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0))) + == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))) + && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0))) + == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1)))) + && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0))) + == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1)))) + /* Same value types ignoring qualifiers. */ + && (TYPE_MAIN_VARIANT (TREE_TYPE (node)) + == TYPE_MAIN_VARIANT + (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))) + { + if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR) + { + pp_string (buffer, "*"); + dump_generic_node (buffer, TREE_OPERAND (node, 0), + spc, flags, false); + } + else + dump_generic_node (buffer, + TREE_OPERAND (TREE_OPERAND (node, 0), 0), + spc, flags, false); + } + else + { + tree ptype; + + pp_string (buffer, "MEM["); + pp_string (buffer, "("); + ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1))); + dump_generic_node (buffer, ptype, + spc, flags | TDF_SLIM, false); + pp_string (buffer, ")"); + dump_generic_node (buffer, TREE_OPERAND (node, 0), + spc, flags, false); + if (!integer_zerop (TREE_OPERAND (node, 1))) + { + pp_string (buffer, " + "); + dump_generic_node (buffer, TREE_OPERAND (node, 1), + spc, flags, false); + } + pp_string (buffer, "]"); + } + break; + } + case TARGET_MEM_REF: { const char *sep = ""; @@ -802,15 +859,22 @@ pp_string (buffer, "MEM["); - tmp = TMR_SYMBOL (node); - if (tmp) + if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR) { pp_string (buffer, sep); sep = ", "; pp_string (buffer, "symbol: "); - dump_generic_node (buffer, tmp, spc, flags, false); + dump_generic_node (buffer, TREE_OPERAND (TMR_BASE (node), 0), + spc, flags, false); } - tmp = TMR_BASE (node); + else + { + pp_string (buffer, sep); + sep = ", "; + pp_string (buffer, "base: "); + dump_generic_node (buffer, TMR_BASE (node), spc, flags, false); + } + tmp = TMR_INDEX2 (node); if (tmp) { pp_string (buffer, sep); @@ -843,13 +907,6 @@ dump_generic_node (buffer, tmp, spc, flags, false); } pp_string (buffer, "]"); - if (flags & TDF_DETAILS) - { - pp_string (buffer, "{"); - dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags, - false); - pp_string (buffer, "}"); - } } break; @@ -1033,6 +1090,8 @@ } if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) dump_decl_name (buffer, TYPE_NAME (node), flags); + else if (flags & TDF_NOUID) + pp_printf (buffer, "<Txxxx>"); else pp_printf (buffer, "<T%x>", TYPE_UID (node)); dump_function_declaration (buffer, node, spc, flags); @@ -1065,7 +1124,7 @@ } if (DECL_NAME (node)) dump_decl_name (buffer, node, flags); - else + else if (TYPE_NAME (TREE_TYPE (node)) != node) { if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) @@ -1084,6 +1143,8 @@ dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); } } + else + pp_string (buffer, "<anon>"); break; case VAR_DECL: @@ -1101,7 +1162,27 @@ case COMPONENT_REF: op0 = TREE_OPERAND (node, 0); str = "."; - if (op0 && TREE_CODE (op0) == INDIRECT_REF) + if (op0 + && (TREE_CODE (op0) == INDIRECT_REF + || (TREE_CODE (op0) == MEM_REF + && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR + && integer_zerop (TREE_OPERAND (op0, 1)) + /* Dump the types of INTEGER_CSTs explicitly, for we + can't infer them and MEM_ATTR caching will share + MEM_REFs with differently-typed op0s. */ + && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST + /* Same pointer types, but ignoring POINTER_TYPE vs. + REFERENCE_TYPE. */ + && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0))) + == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))) + && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0))) + == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1)))) + && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0))) + == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1)))) + /* Same value types ignoring qualifiers. */ + && (TYPE_MAIN_VARIANT (TREE_TYPE (op0)) + == TYPE_MAIN_VARIANT + (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))))) { op0 = TREE_OPERAND (op0, 0); str = "->"; @@ -1360,7 +1441,7 @@ { pp_newline (buffer); - for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0)) + for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0)) { print_declaration (buffer, op0, spc+2, flags); pp_newline (buffer); @@ -1520,8 +1601,6 @@ 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 @@ -1538,13 +1617,6 @@ } 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: @@ -1948,6 +2020,36 @@ pp_string (buffer, " > "); break; + case WIDEN_MULT_PLUS_EXPR: + pp_string (buffer, " WIDEN_MULT_PLUS_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; + + case WIDEN_MULT_MINUS_EXPR: + pp_string (buffer, " WIDEN_MULT_MINUS_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; + + case FMA_EXPR: + pp_string (buffer, " FMA_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; + case OMP_PARALLEL: pp_string (buffer, "#pragma omp parallel"); dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags); @@ -2225,7 +2327,7 @@ pp_string (buffer, "static "); /* Print the type and name. */ - if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) + if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) { tree tmp; @@ -2341,7 +2443,7 @@ print_declaration (buffer, tmp, spc+2, flags); pp_newline (buffer); } - tmp = TREE_CHAIN (tmp); + tmp = DECL_CHAIN (tmp); } } INDENT (spc); @@ -2441,6 +2543,8 @@ case VEC_WIDEN_MULT_LO_EXPR: case WIDEN_MULT_EXPR: case DOT_PROD_EXPR: + case WIDEN_MULT_PLUS_EXPR: + case WIDEN_MULT_MINUS_EXPR: case MULT_EXPR: case TRUNC_DIV_EXPR: case CEIL_DIV_EXPR: @@ -2452,6 +2556,7 @@ case CEIL_MOD_EXPR: case FLOOR_MOD_EXPR: case ROUND_MOD_EXPR: + case FMA_EXPR: return 13; case TRUTH_NOT_EXPR: @@ -2461,8 +2566,6 @@ 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: @@ -2632,12 +2735,6 @@ case INDIRECT_REF: return "*"; - case ALIGN_INDIRECT_REF: - return "A*"; - - case MISALIGNED_INDIRECT_REF: - return "M*"; - case TRUNC_DIV_EXPR: case RDIV_EXPR: return "/"; @@ -2739,6 +2836,13 @@ dump_generic_node (buffer, op0, 0, flags, false); break; + case MEM_REF: + if (integer_zerop (TREE_OPERAND (op0, 1))) + { + op0 = TREE_OPERAND (op0, 0); + goto again; + } + /* Fallthru. */ case COMPONENT_REF: case SSA_NAME: case OBJ_TYPE_REF: