X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-pretty-print.c;h=5708eedf3b2fdf25e05624a88dc197dffb4b5926;hb=a55e30dca65991b3c45bbf3d9515bf97cc1a3e9b;hp=d9d4b968a3249c06ca343a90ca09ccd6bf52fd6f;hpb=167a3fa54362dcfe6cb3ef3b92e1d27784c415c4;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c index d9d4b968a32..5708eedf3b2 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, 2004, 2005, 2006 + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. Adapted from c-pretty-print.c by Diego Novillo @@ -7,7 +7,7 @@ This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free -Software Foundation; either version 2, or (at your option) any later +Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY @@ -16,15 +16,15 @@ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA -02110-1301, USA. */ +along with GCC; see the file COPYING3. If not see +. */ #include "config.h" #include "system.h" #include "coretypes.h" #include "tm.h" #include "tree.h" +#include "output.h" #include "diagnostic.h" #include "real.h" #include "hashtab.h" @@ -33,21 +33,19 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA #include "tree-iterator.h" #include "tree-chrec.h" #include "tree-pass.h" +#include "fixed-value.h" #include "value-prof.h" +#include "predict.h" /* Local functions, macros and variables. */ -static int op_prio (tree); -static const char *op_symbol_1 (enum tree_code); -static const char *op_symbol (tree); +static int op_prio (const_tree); +static const char *op_symbol (const_tree); static void pretty_print_string (pretty_printer *, const char*); -static void print_call_name (pretty_printer *, tree); +static void print_call_name (pretty_printer *, const_tree); static void newline_and_indent (pretty_printer *, int); static void maybe_init_pretty_print (FILE *); -static void print_declaration (pretty_printer *, tree, int, int); -static void print_struct_decl (pretty_printer *, tree, int, int); -static void do_niy (pretty_printer *, tree); -static void dump_vops (pretty_printer *, tree, int, int); -static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int); +static void print_struct_decl (pretty_printer *, const_tree, int, int); +static void do_niy (pretty_printer *, const_tree); #define INDENT(SPACE) do { \ int i; for (i = 0; i>>\n"); } +/* Debugging function to print out a generic expression. */ + void debug_generic_expr (tree t) { @@ -92,6 +92,8 @@ debug_generic_expr (tree t) fprintf (stderr, "\n"); } +/* Debugging function to print out a generic statement. */ + void debug_generic_stmt (tree t) { @@ -99,6 +101,8 @@ debug_generic_stmt (tree t) fprintf (stderr, "\n"); } +/* Debugging function to print out a chain of trees . */ + void debug_tree_chain (tree t) { @@ -121,7 +125,7 @@ print_generic_decl (FILE *file, tree decl, int flags) } /* Print tree T, and its successors, on file FILE. FLAGS specifies details - to show in the dump. See TDF_* in tree.h. */ + to show in the dump. See TDF_* in tree-pass.h. */ void print_generic_stmt (FILE *file, tree t, int flags) @@ -132,7 +136,7 @@ print_generic_stmt (FILE *file, tree t, int flags) } /* Print tree T, and its successors, on file FILE. FLAGS specifies details - to show in the dump. See TDF_* in tree.h. The output is indented by + to show in the dump. See TDF_* in tree-pass.h. The output is indented by INDENT spaces. */ void @@ -149,7 +153,7 @@ print_generic_stmt_indented (FILE *file, tree t, int flags, int indent) } /* Print a single expression T on file FILE. FLAGS specifies details to show - in the dump. See TDF_* in tree.h. */ + in the dump. See TDF_* in tree-pass.h. */ void print_generic_expr (FILE *file, tree t, int flags) @@ -173,8 +177,7 @@ dump_decl_name (pretty_printer *buffer, tree node, int flags) { if (TREE_CODE (t) == LABEL_DECL && LABEL_DECL_UID (t) != -1) - pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC, - LABEL_DECL_UID (t)); + pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (t)); else { char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D'; @@ -296,7 +299,7 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags) case OMP_CLAUSE_REDUCTION: pp_string (buffer, "reduction("); - pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause))); + pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause))); pp_character (buffer, ':'); dump_generic_node (buffer, OMP_CLAUSE_DECL (clause), spc, flags, false); @@ -328,19 +331,22 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags) pp_string (buffer, "default("); switch (OMP_CLAUSE_DEFAULT_KIND (clause)) { - case OMP_CLAUSE_DEFAULT_UNSPECIFIED: - break; - case OMP_CLAUSE_DEFAULT_SHARED: - pp_string (buffer, "shared"); - break; - case OMP_CLAUSE_DEFAULT_NONE: - pp_string (buffer, "none"); - break; - case OMP_CLAUSE_DEFAULT_PRIVATE: - pp_string (buffer, "private"); - break; - default: - gcc_unreachable (); + case OMP_CLAUSE_DEFAULT_UNSPECIFIED: + break; + case OMP_CLAUSE_DEFAULT_SHARED: + pp_string (buffer, "shared"); + break; + case OMP_CLAUSE_DEFAULT_NONE: + pp_string (buffer, "none"); + break; + case OMP_CLAUSE_DEFAULT_PRIVATE: + pp_string (buffer, "private"); + break; + case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE: + pp_string (buffer, "firstprivate"); + break; + default: + gcc_unreachable (); } pp_character (buffer, ')'); break; @@ -361,6 +367,9 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags) case OMP_CLAUSE_SCHEDULE_RUNTIME: pp_string (buffer, "runtime"); break; + case OMP_CLAUSE_SCHEDULE_AUTO: + pp_string (buffer, "auto"); + break; default: gcc_unreachable (); } @@ -374,6 +383,18 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags) pp_character (buffer, ')'); break; + case OMP_CLAUSE_UNTIED: + pp_string (buffer, "untied"); + break; + + case OMP_CLAUSE_COLLAPSE: + pp_string (buffer, "collapse("); + dump_generic_node (buffer, + OMP_CLAUSE_COLLAPSE_EXPR (clause), + spc, flags, false); + pp_character (buffer, ')'); + break; + default: /* Should never happen. */ dump_generic_node (buffer, clause, spc, flags, false); @@ -385,7 +406,7 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags) /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in dump_generic_node. */ -static void +void dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags) { if (clause == NULL) @@ -403,37 +424,10 @@ dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags) } -/* Dump the set of decls SYMS. BUFFER, SPC and FLAGS are as in - dump_generic_node. */ - -static void -dump_symbols (pretty_printer *buffer, bitmap syms, int flags) -{ - unsigned i; - bitmap_iterator bi; - - if (syms == NULL) - pp_string (buffer, "NIL"); - else - { - pp_string (buffer, " { "); - - EXECUTE_IF_SET_IN_BITMAP (syms, 0, i, bi) - { - tree sym = referenced_var_lookup (i); - dump_generic_node (buffer, sym, 0, flags, false); - pp_string (buffer, " "); - } - - pp_string (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 - and it is terminated by ';' if appropriate. */ +/* 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-pass.h). If IS_STMT is true, the object printed is considered + to be a statement and it is terminated by ';' if appropriate. */ int dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, @@ -447,18 +441,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, if (node == NULL_TREE) return spc; - is_expr = EXPR_P (node) || GIMPLE_STMT_P (node); - - /* We use has_stmt_ann because CALL_EXPR can be both an expression - and a statement, and we have no guarantee that it will have a - stmt_ann when it is used as an RHS expression. stmt_ann will assert - if you call it on something with a non-stmt annotation attached. */ - if (TREE_CODE (node) != ERROR_MARK - && is_gimple_stmt (node) - && (flags & (TDF_VOPS|TDF_MEMSYMS)) - && has_stmt_ann (node) - && TREE_CODE (node) != PHI_NODE) - dump_vops (buffer, node, spc, flags); + is_expr = EXPR_P (node); if (is_stmt && (flags & TDF_STMTADDR)) pp_printf (buffer, "<&%p> ", (void *)node); @@ -529,13 +512,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case VOID_TYPE: case INTEGER_TYPE: case REAL_TYPE: + case FIXED_POINT_TYPE: case COMPLEX_TYPE: case VECTOR_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: { unsigned int quals = TYPE_QUALS (node); - enum tree_code_class class; + enum tree_code_class tclass; if (quals & TYPE_QUAL_CONST) pp_string (buffer, "const "); @@ -544,16 +528,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, else if (quals & TYPE_QUAL_RESTRICT) pp_string (buffer, "restrict "); - class = TREE_CODE_CLASS (TREE_CODE (node)); + tclass = TREE_CODE_CLASS (TREE_CODE (node)); - if (class == tcc_declaration) + if (tclass == tcc_declaration) { if (DECL_NAME (node)) dump_decl_name (buffer, node, flags); else pp_string (buffer, ""); } - else if (class == tcc_type) + else if (tclass == tcc_type) { if (TYPE_NAME (node)) { @@ -571,6 +555,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); } + else if (TREE_CODE (node) == INTEGER_TYPE) + { + pp_string (buffer, (TYPE_UNSIGNED (node) + ? ""); + } else pp_string (buffer, ""); } @@ -607,9 +599,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, if (quals & TYPE_QUAL_CONST) pp_string (buffer, " const"); - else if (quals & TYPE_QUAL_VOLATILE) - pp_string (buffer, "volatile"); - else if (quals & TYPE_QUAL_RESTRICT) + if (quals & TYPE_QUAL_VOLATILE) + pp_string (buffer, " volatile"); + if (quals & TYPE_QUAL_RESTRICT) pp_string (buffer, " restrict"); if (TYPE_REF_CAN_ALIAS_ALL (node)) @@ -703,17 +695,26 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case RECORD_TYPE: case UNION_TYPE: case QUAL_UNION_TYPE: - /* Print the name of the structure. */ - if (TREE_CODE (node) == RECORD_TYPE) - pp_string (buffer, "struct "); - else if (TREE_CODE (node) == UNION_TYPE) - pp_string (buffer, "union "); + { + unsigned int quals = TYPE_QUALS (node); - if (TYPE_NAME (node)) - dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false); - else - print_struct_decl (buffer, node, spc, flags); - break; + if (quals & TYPE_QUAL_CONST) + pp_string (buffer, "const "); + if (quals & TYPE_QUAL_VOLATILE) + pp_string (buffer, "volatile "); + + /* Print the name of the structure. */ + if (TREE_CODE (node) == RECORD_TYPE) + pp_string (buffer, "struct "); + else if (TREE_CODE (node) == UNION_TYPE) + pp_string (buffer, "union "); + + if (TYPE_NAME (node)) + dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false); + else + print_struct_decl (buffer, node, spc, flags); + break; + } case LANG_TYPE: NIY; @@ -760,7 +761,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, /* Would "%x%0*x" or "%x%*0x" get zero-padding on all systems? */ sprintf (pp_buffer (buffer)->digit_buffer, - HOST_WIDE_INT_PRINT_DOUBLE_HEX, high, low); + HOST_WIDE_INT_PRINT_DOUBLE_HEX, + (unsigned HOST_WIDE_INT) high, low); pp_string (buffer, pp_buffer (buffer)->digit_buffer); } else @@ -798,6 +800,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, break; } + case FIXED_CST: + { + char string[100]; + fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string)); + pp_string (buffer, string); + break; + } + case COMPLEX_CST: pp_string (buffer, "__complex__ ("); dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false); @@ -838,10 +848,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, if (DECL_NAME (node)) dump_decl_name (buffer, node, flags); else if (LABEL_DECL_UID (node) != -1) - pp_printf (buffer, "", - LABEL_DECL_UID (node)); + pp_printf (buffer, "", (int) LABEL_DECL_UID (node)); else - pp_printf (buffer, "", DECL_UID (node)); + pp_printf (buffer, "", DECL_UID (node)); break; case TYPE_DECL: @@ -875,7 +884,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case SYMBOL_MEMORY_TAG: case NAME_MEMORY_TAG: - case STRUCT_FIELD_TAG: case VAR_DECL: case PARM_DECL: case FIELD_DECL: @@ -903,16 +911,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_CODE (op0) != VALUE_HANDLE) + op0 = component_ref_field_offset (node); + if (op0 && TREE_CODE (op0) != INTEGER_CST) { - op0 = component_ref_field_offset (node); - if (op0 && TREE_CODE (op0) != INTEGER_CST) - { - pp_string (buffer, "{off: "); + pp_string (buffer, "{off: "); dump_generic_node (buffer, op0, spc, flags, false); pp_character (buffer, '}'); - } } break; @@ -944,8 +948,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, 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))) + || TREE_OPERAND (node, 2) + || TREE_OPERAND (node, 3)) { pp_string (buffer, "{lb: "); dump_generic_node (buffer, op0, spc, flags, false); @@ -1050,14 +1054,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, break; case MODIFY_EXPR: - case GIMPLE_MODIFY_STMT: case INIT_EXPR: - dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags, + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); pp_space (buffer); pp_character (buffer, '='); + if (TREE_CODE (node) == MODIFY_EXPR + && MOVE_NONTEMPORAL (node)) + pp_string (buffer, "{nt}"); pp_space (buffer); - dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags, + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); break; @@ -1173,12 +1179,31 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, /* Print parameters. */ pp_space (buffer); pp_character (buffer, '('); - op1 = TREE_OPERAND (node, 1); - if (op1) - dump_generic_node (buffer, op1, spc, flags, false); + { + tree arg; + call_expr_arg_iterator iter; + FOR_EACH_CALL_EXPR_ARG (arg, iter, node) + { + dump_generic_node (buffer, arg, spc, flags, false); + if (more_call_expr_args_p (&iter)) + { + pp_character (buffer, ','); + pp_space (buffer); + } + } + } + if (CALL_EXPR_VA_ARG_PACK (node)) + { + if (call_expr_nargs (node) > 0) + { + pp_character (buffer, ','); + pp_space (buffer); + } + pp_string (buffer, "__builtin_va_arg_pack ()"); + } pp_character (buffer, ')'); - op1 = TREE_OPERAND (node, 2); + op1 = CALL_EXPR_STATIC_CHAIN (node); if (op1) { pp_string (buffer, " [static-chain: "); @@ -1213,6 +1238,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case WIDEN_MULT_EXPR: case MULT_EXPR: case PLUS_EXPR: + case POINTER_PLUS_EXPR: case MINUS_EXPR: case TRUNC_DIV_EXPR: case CEIL_DIV_EXPR: @@ -1259,7 +1285,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, /* When the operands are expressions with less priority, keep semantics of the tree representation. */ - if (op_prio (op0) < op_prio (node)) + if (op_prio (op0) <= op_prio (node)) { pp_character (buffer, '('); dump_generic_node (buffer, op0, spc, flags, false); @@ -1274,7 +1300,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, /* When the operands are expressions with less priority, keep semantics of the tree representation. */ - if (op_prio (op1) < op_prio (node)) + if (op_prio (op1) <= op_prio (node)) { pp_character (buffer, '('); dump_generic_node (buffer, op1, spc, flags, false); @@ -1358,10 +1384,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, NIY; break; + case FIXED_CONVERT_EXPR: case FIX_TRUNC_EXPR: case FLOAT_EXPR: - case CONVERT_EXPR: - case NOP_EXPR: + CASE_CONVERT: type = TREE_TYPE (node); op0 = TREE_OPERAND (node, 0); if (type != TREE_TYPE (op0)) @@ -1385,6 +1411,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_character (buffer, ')'); break; + case PAREN_EXPR: + pp_string (buffer, "(("); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, "))"); + break; + case NON_LVALUE_EXPR: pp_string (buffer, "NON_LVALUE_EXPR <"); dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); @@ -1476,6 +1508,17 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, is_expr = false; break; + case CHANGE_DYNAMIC_TYPE_EXPR: + pp_string (buffer, "<<>>"); + is_expr = false; + break; + case LABEL_EXPR: op0 = TREE_OPERAND (node, 0); /* If this is for break or continue, don't bother printing it. */ @@ -1514,15 +1557,24 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, is_expr = false; break; + case PREDICT_EXPR: + pp_string (buffer, "// predicted "); + if (PREDICT_EXPR_OUTCOME (node)) + pp_string (buffer, "likely by "); + else + pp_string (buffer, "unlikely by "); + pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node))); + pp_string (buffer, " predictor."); + break; + case RETURN_EXPR: pp_string (buffer, "return"); op0 = TREE_OPERAND (node, 0); if (op0) { pp_space (buffer); - if (TREE_CODE (op0) == MODIFY_EXPR - || TREE_CODE (op0) == GIMPLE_MODIFY_STMT) - dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1), + if (TREE_CODE (op0) == MODIFY_EXPR) + dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false); else dump_generic_node (buffer, op0, spc, flags, false); @@ -1628,7 +1680,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, dump_generic_node (buffer, CASE_LOW (node), spc, flags, false); } else - pp_string (buffer, "default "); + pp_string (buffer, "default"); pp_character (buffer, ':'); break; @@ -1643,28 +1695,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_character (buffer, ')'); break; - case PHI_NODE: - { - int i; - - dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false); - pp_string (buffer, " = PHI <"); - for (i = 0; i < PHI_NUM_ARGS (node); i++) - { - dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false); - pp_string (buffer, "("); - pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index); - pp_string (buffer, ")"); - if (i < PHI_NUM_ARGS (node) - 1) - pp_string (buffer, ", "); - } - pp_string (buffer, ">"); - - if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS)) - dump_symbols (buffer, STORED_SYMS (node), flags); - } - break; - case SSA_NAME: dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false); pp_string (buffer, "_"); @@ -1683,10 +1713,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_string (buffer, ">"); break; - case VALUE_HANDLE: - pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node)); - break; - case ASSERT_EXPR: pp_string (buffer, "ASSERT_EXPR <"); dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false); @@ -1746,21 +1772,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case OMP_PARALLEL: pp_string (buffer, "#pragma omp parallel"); dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags); - if (OMP_PARALLEL_FN (node)) - { - pp_string (buffer, " [child fn: "); - dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false); - - pp_string (buffer, " ("); - - if (OMP_PARALLEL_DATA_ARG (node)) - dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags, - false); - else - pp_string (buffer, "???"); - - pp_string (buffer, ")]"); - } dump_omp_body: if (!(flags & TDF_SLIM) && OMP_BODY (node)) @@ -1775,12 +1786,19 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, is_expr = false; break; + case OMP_TASK: + pp_string (buffer, "#pragma omp task"); + dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags); + goto dump_omp_body; + case OMP_FOR: pp_string (buffer, "#pragma omp for"); dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags); if (!(flags & TDF_SLIM)) { + int i; + if (OMP_FOR_PRE_BODY (node)) { newline_and_indent (buffer, spc + 2); @@ -1790,14 +1808,22 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, dump_generic_node (buffer, OMP_FOR_PRE_BODY (node), spc, flags, false); } - newline_and_indent (buffer, spc); - pp_string (buffer, "for ("); - dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false); - pp_string (buffer, "; "); - dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false); - pp_string (buffer, "; "); - dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false); - pp_string (buffer, ")"); + spc -= 2; + for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++) + { + spc += 2; + newline_and_indent (buffer, spc); + pp_string (buffer, "for ("); + dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i), + spc, flags, false); + pp_string (buffer, "; "); + dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i), + spc, flags, false); + pp_string (buffer, "; "); + dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i), + spc, flags, false); + pp_string (buffer, ")"); + } if (OMP_FOR_BODY (node)) { newline_and_indent (buffer, spc + 2); @@ -1808,6 +1834,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, newline_and_indent (buffer, spc + 2); pp_character (buffer, '}'); } + spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2; if (OMP_FOR_PRE_BODY (node)) { spc -= 4; @@ -1862,18 +1889,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags); goto dump_omp_body; - case OMP_RETURN: - pp_string (buffer, "OMP_RETURN"); - if (OMP_RETURN_NOWAIT (node)) - pp_string (buffer, " [nowait]"); - is_expr = false; - break; - - case OMP_CONTINUE: - pp_string (buffer, "OMP_CONTINUE"); - is_expr = false; - break; - case OMP_CLAUSE: dump_omp_clause (buffer, node, spc, flags); is_expr = false; @@ -1925,14 +1940,26 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_string (buffer, " > "); break; - case VEC_PACK_MOD_EXPR: - pp_string (buffer, " VEC_PACK_MOD_EXPR < "); + case VEC_UNPACK_FLOAT_HI_EXPR: + pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_UNPACK_FLOAT_LO_EXPR: + pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < "); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_string (buffer, " > "); + break; + + case VEC_PACK_TRUNC_EXPR: + pp_string (buffer, " VEC_PACK_TRUNC_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 VEC_PACK_SAT_EXPR: pp_string (buffer, " VEC_PACK_SAT_EXPR < "); dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); @@ -1940,7 +1967,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); pp_string (buffer, " > "); break; - + + case VEC_PACK_FIX_TRUNC_EXPR: + pp_string (buffer, " VEC_PACK_FIX_TRUNC_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 BLOCK: { tree t; @@ -2037,14 +2072,18 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, if (is_stmt && is_expr) pp_semicolon (buffer); - pp_write_text_to_stream (buffer); + + /* If we're building a diagnostic, the formatted text will be written + into BUFFER's stream by the caller; otherwise, write it now. */ + if (!(flags & TDF_DIAGNOSTIC)) + pp_write_text_to_stream (buffer); return spc; } /* Print the declaration of a variable. */ -static void +void print_declaration (pretty_printer *buffer, tree t, int spc, int flags) { INDENT (spc); @@ -2108,7 +2147,7 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags) pp_character (buffer, ')'); } - /* The initial value of a function serves to determine wether the function + /* The initial value of a function serves to determine whether the function is declared or defined. So the following does not apply to function nodes. */ if (TREE_CODE (t) != FUNCTION_DECL) @@ -2138,7 +2177,7 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags) FIXME: Still incomplete. */ static void -print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags) +print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags) { /* Print the name of the structure. */ if (TYPE_NAME (node)) @@ -2209,7 +2248,7 @@ print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags) operators. */ static int -op_prio (tree op) +op_prio (const_tree op) { if (op == NULL) return 9999; @@ -2222,7 +2261,6 @@ op_prio (tree op) return 1; case MODIFY_EXPR: - case GIMPLE_MODIFY_STMT: case INIT_EXPR: return 2; @@ -2273,6 +2311,7 @@ op_prio (tree op) case WIDEN_SUM_EXPR: case PLUS_EXPR: + case POINTER_PLUS_EXPR: case MINUS_EXPR: return 12; @@ -2305,8 +2344,7 @@ op_prio (tree op) case INDIRECT_REF: case ADDR_EXPR: case FLOAT_EXPR: - case NOP_EXPR: - case CONVERT_EXPR: + CASE_CONVERT: case FIX_TRUNC_EXPR: case TARGET_EXPR: return 14; @@ -2330,7 +2368,9 @@ op_prio (tree op) case VEC_RSHIFT_EXPR: case VEC_UNPACK_HI_EXPR: case VEC_UNPACK_LO_EXPR: - case VEC_PACK_MOD_EXPR: + case VEC_UNPACK_FLOAT_HI_EXPR: + case VEC_UNPACK_FLOAT_LO_EXPR: + case VEC_PACK_TRUNC_EXPR: case VEC_PACK_SAT_EXPR: return 16; @@ -2346,15 +2386,14 @@ op_prio (tree op) } -/* Return the symbol associated with operator OP. */ +/* Return the symbol associated with operator CODE. */ -static const char * -op_symbol_1 (enum tree_code code) +const char * +op_symbol_code (enum tree_code code) { switch (code) { case MODIFY_EXPR: - case GIMPLE_MODIFY_STMT: return "="; case TRUTH_OR_EXPR: @@ -2429,6 +2468,9 @@ op_symbol_1 (enum tree_code code) case VEC_RSHIFT_EXPR: return "v>>"; + + case POINTER_PLUS_EXPR: + return "+"; case PLUS_EXPR: return "+"; @@ -2513,22 +2555,24 @@ op_symbol_1 (enum tree_code code) } } +/* Return the symbol associated with operator OP. */ + static const char * -op_symbol (tree op) +op_symbol (const_tree op) { - return op_symbol_1 (TREE_CODE (op)); + return op_symbol_code (TREE_CODE (op)); } /* Prints the name of a CALL_EXPR. */ static void -print_call_name (pretty_printer *buffer, tree node) +print_call_name (pretty_printer *buffer, const_tree node) { tree op0; gcc_assert (TREE_CODE (node) == CALL_EXPR); - op0 = TREE_OPERAND (node, 0); + op0 = CALL_EXPR_FN (node); if (TREE_CODE (op0) == NON_LVALUE_EXPR) op0 = TREE_OPERAND (op0, 0); @@ -2690,325 +2734,3 @@ newline_and_indent (pretty_printer *buffer, int spc) pp_newline (buffer); INDENT (spc); } - - -static void -dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags) -{ - struct voptype_d *vdefs; - struct voptype_d *vuses; - int i, n; - - if (!ssa_operands_active () || !stmt_references_memory_p (stmt)) - return; - - /* Even if the statement doesn't have virtual operators yet, it may - contain symbol information (this happens before aliases have been - computed). */ - if ((flags & TDF_MEMSYMS) - && VUSE_OPS (stmt) == NULL - && VDEF_OPS (stmt) == NULL) - { - if (LOADED_SYMS (stmt)) - { - pp_string (buffer, "# LOADS: "); - dump_symbols (buffer, LOADED_SYMS (stmt), flags); - newline_and_indent (buffer, spc); - } - - if (STORED_SYMS (stmt)) - { - pp_string (buffer, "# STORES: "); - dump_symbols (buffer, STORED_SYMS (stmt), flags); - newline_and_indent (buffer, spc); - } - - return; - } - - vuses = VUSE_OPS (stmt); - while (vuses) - { - pp_string (buffer, "# VUSE <"); - - n = VUSE_NUM (vuses); - for (i = 0; i < n; i++) - { - dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false); - if (i < n - 1) - pp_string (buffer, ", "); - } - - pp_string (buffer, ">"); - - if (flags & TDF_MEMSYMS) - dump_symbols (buffer, LOADED_SYMS (stmt), flags); - - newline_and_indent (buffer, spc); - vuses = vuses->next; - } - - vdefs = VDEF_OPS (stmt); - while (vdefs) - { - pp_string (buffer, "# "); - dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false); - pp_string (buffer, " = VDEF <"); - - n = VDEF_NUM (vdefs); - for (i = 0; i < n; i++) - { - dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0); - if (i < n - 1) - pp_string (buffer, ", "); - } - - pp_string (buffer, ">"); - - if ((flags & TDF_MEMSYMS) && vdefs->next == NULL) - dump_symbols (buffer, STORED_SYMS (stmt), flags); - - newline_and_indent (buffer, spc); - vdefs = vdefs->next; - } -} - - -/* Dumps basic block BB to FILE with details described by FLAGS and - indented by INDENT spaces. */ - -void -dump_generic_bb (FILE *file, basic_block bb, int indent, int flags) -{ - maybe_init_pretty_print (file); - dump_generic_bb_buff (&buffer, bb, indent, flags); - pp_flush (&buffer); -} - -/* Dumps header of basic block BB to buffer BUFFER indented by INDENT - spaces and details described by flags. */ - -static void -dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags) -{ - edge e; - tree stmt; - edge_iterator ei; - - if (flags & TDF_BLOCKS) - { - INDENT (indent); - pp_string (buffer, "# BLOCK "); - pp_decimal_int (buffer, bb->index); - if (bb->frequency) - { - pp_string (buffer, " freq:"); - pp_decimal_int (buffer, bb->frequency); - } - if (bb->count) - { - pp_string (buffer, " count:"); - pp_widest_integer (buffer, bb->count); - } - - if (flags & TDF_LINENO) - { - block_stmt_iterator bsi; - - for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) - if (get_lineno (bsi_stmt (bsi)) != -1) - { - pp_string (buffer, ", starting at line "); - pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi))); - break; - } - } - newline_and_indent (buffer, indent); - - pp_string (buffer, "# PRED:"); - pp_write_text_to_stream (buffer); - FOR_EACH_EDGE (e, ei, bb->preds) - if (flags & TDF_SLIM) - { - pp_string (buffer, " "); - if (e->src == ENTRY_BLOCK_PTR) - pp_string (buffer, "ENTRY"); - else - pp_decimal_int (buffer, e->src->index); - } - else - dump_edge_info (buffer->buffer->stream, e, 0); - pp_newline (buffer); - } - else - { - stmt = first_stmt (bb); - if (!stmt || TREE_CODE (stmt) != LABEL_EXPR) - { - INDENT (indent - 2); - pp_string (buffer, "index); - pp_string (buffer, ">:"); - 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 - spaces. */ - -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_EACH_EDGE (e, ei, bb->succs) - if (flags & TDF_SLIM) - { - pp_string (buffer, " "); - if (e->dest == EXIT_BLOCK_PTR) - pp_string (buffer, "EXIT"); - else - pp_decimal_int (buffer, e->dest->index); - } - else - dump_edge_info (buffer->buffer->stream, e, 1); - pp_newline (buffer); -} - -/* Dump PHI nodes of basic block BB to BUFFER with details described - by FLAGS and indented by INDENT spaces. */ - -static void -dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags) -{ - tree phi = phi_nodes (bb); - if (!phi) - return; - - for (; phi; phi = PHI_CHAIN (phi)) - { - if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS)) - { - INDENT (indent); - pp_string (buffer, "# "); - dump_generic_node (buffer, phi, indent, flags, false); - pp_newline (buffer); - } - } -} - - -/* Dump jump to basic block BB that is represented implicitly in the cfg - to BUFFER. */ - -static void -pp_cfg_jump (pretty_printer *buffer, basic_block bb) -{ - tree stmt; - - stmt = first_stmt (bb); - - pp_string (buffer, "goto index); - pp_string (buffer, ">"); - if (stmt && TREE_CODE (stmt) == LABEL_EXPR) - { - pp_string (buffer, " ("); - dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false); - pp_string (buffer, ")"); - } - pp_semicolon (buffer); -} - -/* Dump edges represented implicitly in basic block BB to BUFFER, indented - by INDENT spaces, with details given by FLAGS. */ - -static void -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_EACH_EDGE (e, ei, bb->succs) - if (e->flags & EDGE_FALLTHRU) - break; - if (e && e->dest != bb->next_bb) - { - INDENT (indent); - - 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 (goto_xloc.file) - { - pp_string (buffer, goto_xloc.file); - pp_string (buffer, " : "); - } - pp_decimal_int (buffer, goto_xloc.line); - pp_string (buffer, "] "); - } - - pp_cfg_jump (buffer, e->dest); - pp_newline (buffer); - } -} - -/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and - indented by INDENT spaces. */ - -static void -dump_generic_bb_buff (pretty_printer *buffer, basic_block bb, - int indent, int flags) -{ - block_stmt_iterator bsi; - tree stmt; - int label_indent = indent - 2; - - if (label_indent < 0) - label_indent = 0; - - dump_bb_header (buffer, bb, indent, flags); - - dump_phi_nodes (buffer, bb, indent, flags); - - for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) - { - int curr_indent; - - stmt = bsi_stmt (bsi); - - curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent; - - INDENT (curr_indent); - dump_generic_node (buffer, stmt, curr_indent, flags, true); - pp_newline (buffer); - dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt); - } - - dump_implicit_edges (buffer, bb, indent, flags); - - if (flags & TDF_BLOCKS) - dump_bb_end (buffer, bb, indent, flags); -}