X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-pretty-print.c;h=8852c05cb851e7b8184e3d1b8508dbc502533088;hb=73faef308beb68f43956ec108d6dc61a4ed1b3d6;hp=c2a47f0c712bcba4961911acedac4c96a2e37567;hpb=8a1417cb7521b0bea5f506bc69233e0ce15edeb6;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c index c2a47f0c712..8852c05cb85 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, 2009, 2010 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,55 +16,46 @@ 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 "tree-pretty-print.h" #include "hashtab.h" #include "tree-flow.h" #include "langhooks.h" #include "tree-iterator.h" #include "tree-chrec.h" #include "tree-pass.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 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 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) { - print_generic_expr (stderr, t, TDF_VOPS|TDF_UID); + print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS); fprintf (stderr, "\n"); } +/* Debugging function to print out a generic statement. */ + void debug_generic_stmt (tree t) { - print_generic_stmt (stderr, t, TDF_VOPS|TDF_UID); + print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS); fprintf (stderr, "\n"); } +/* Debugging function to print out a chain of trees . */ + void debug_tree_chain (tree t) { + struct pointer_set_t *seen = pointer_set_create (); + while (t) - { - print_generic_expr (stderr, t, TDF_VOPS|TDF_UID); - fprintf(stderr, " "); - t = TREE_CHAIN (t); - } + { + print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID); + fprintf (stderr, " "); + t = TREE_CHAIN (t); + if (pointer_set_insert (seen, t)) + { + fprintf (stderr, "... [cycled back to "); + print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID); + fprintf (stderr, "]"); + break; + } + } fprintf (stderr, "\n"); + + pointer_set_destroy (seen); } /* Prints declaration DECL to the FILE with details specified by FLAGS. */ @@ -120,7 +128,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) @@ -131,7 +139,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 @@ -148,7 +156,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) @@ -163,34 +171,53 @@ print_generic_expr (FILE *file, tree t, int flags) static void dump_decl_name (pretty_printer *buffer, tree node, int flags) { - tree t = node; - - if (DECL_NAME (t)) - pp_tree_identifier (buffer, DECL_NAME (t)); - if ((flags & TDF_UID) - || DECL_NAME (t) == NULL_TREE) + if (DECL_NAME (node)) + { + if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node)) + pp_tree_identifier (buffer, DECL_ASSEMBLER_NAME (node)); + else + pp_tree_identifier (buffer, DECL_NAME (node)); + } + if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE) { - if (TREE_CODE (t) == LABEL_DECL - && LABEL_DECL_UID (t) != -1) - pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC, - LABEL_DECL_UID (t)); + if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1) + pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (node)); + else if (TREE_CODE (node) == DEBUG_EXPR_DECL) + { + if (flags & TDF_NOUID) + pp_string (buffer, "D#xxxx"); + else + pp_printf (buffer, "D#%i", DEBUG_TEMP_UID (node)); + } else { - char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D'; - pp_printf (buffer, "%c.%u", c, DECL_UID (t)); + char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D'; + if (flags & TDF_NOUID) + pp_printf (buffer, "%c.xxxx", c); + else + pp_printf (buffer, "%c.%u", c, DECL_UID (node)); } } + if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node)) + { + if (flags & TDF_NOUID) + pp_printf (buffer, "ptD.xxxx"); + else + pp_printf (buffer, "ptD.%u", DECL_PT_UID (node)); + } } /* Like the above, but used for pretty printing function calls. */ static void -dump_function_name (pretty_printer *buffer, tree node) +dump_function_name (pretty_printer *buffer, tree node, int flags) { - if (DECL_NAME (node)) - PRINT_FUNCTION_NAME (node); + if (TREE_CODE (node) == NOP_EXPR) + node = TREE_OPERAND (node, 0); + if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0) + pp_string (buffer, lang_hooks.decl_printable_name (node, 1)); else - dump_decl_name (buffer, node, 0); + dump_decl_name (buffer, node, flags); } /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and @@ -295,7 +322,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); @@ -327,19 +354,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; @@ -360,6 +390,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 (); } @@ -373,6 +406,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); @@ -384,7 +429,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) @@ -402,10 +447,139 @@ dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags) } -/* 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 location LOC to BUFFER. */ + +static void +dump_location (pretty_printer *buffer, location_t loc) +{ + expanded_location xloc = expand_location (loc); + + pp_character (buffer, '['); + if (xloc.file) + { + pp_string (buffer, xloc.file); + pp_string (buffer, " : "); + } + pp_decimal_int (buffer, xloc.line); + pp_string (buffer, "] "); +} + + +/* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in + dump_generic_node. */ + +static void +dump_block_node (pretty_printer *buffer, tree block, int spc, int flags) +{ + tree t; + + pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block)); + + if (flags & TDF_ADDRESS) + pp_printf (buffer, "[%p] ", (void *) block); + + if (BLOCK_ABSTRACT (block)) + pp_string (buffer, "[abstract] "); + + if (TREE_ASM_WRITTEN (block)) + pp_string (buffer, "[written] "); + + if (flags & TDF_SLIM) + return; + + if (BLOCK_SOURCE_LOCATION (block)) + dump_location (buffer, BLOCK_SOURCE_LOCATION (block)); + + newline_and_indent (buffer, spc + 2); + + if (BLOCK_SUPERCONTEXT (block)) + { + pp_string (buffer, "SUPERCONTEXT: "); + dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0, + flags | TDF_SLIM, false); + newline_and_indent (buffer, spc + 2); + } + + if (BLOCK_SUBBLOCKS (block)) + { + pp_string (buffer, "SUBBLOCKS: "); + for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t)) + { + dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false); + pp_string (buffer, " "); + } + newline_and_indent (buffer, spc + 2); + } + + if (BLOCK_CHAIN (block)) + { + pp_string (buffer, "SIBLINGS: "); + for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t)) + { + dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false); + pp_string (buffer, " "); + } + newline_and_indent (buffer, spc + 2); + } + + if (BLOCK_VARS (block)) + { + pp_string (buffer, "VARS: "); + for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t)) + { + dump_generic_node (buffer, t, 0, flags, false); + pp_string (buffer, " "); + } + newline_and_indent (buffer, spc + 2); + } + + if (VEC_length (tree, BLOCK_NONLOCALIZED_VARS (block)) > 0) + { + unsigned i; + VEC(tree,gc) *nlv = BLOCK_NONLOCALIZED_VARS (block); + + pp_string (buffer, "NONLOCALIZED_VARS: "); + for (i = 0; VEC_iterate (tree, nlv, i, t); i++) + { + dump_generic_node (buffer, t, 0, flags, false); + pp_string (buffer, " "); + } + newline_and_indent (buffer, spc + 2); + } + + if (BLOCK_ABSTRACT_ORIGIN (block)) + { + pp_string (buffer, "ABSTRACT_ORIGIN: "); + dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0, + flags | TDF_SLIM, false); + newline_and_indent (buffer, spc + 2); + } + + if (BLOCK_FRAGMENT_ORIGIN (block)) + { + pp_string (buffer, "FRAGMENT_ORIGIN: "); + dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0, + flags | TDF_SLIM, false); + newline_and_indent (buffer, spc + 2); + } + + if (BLOCK_FRAGMENT_CHAIN (block)) + { + pp_string (buffer, "FRAGMENT_CHAIN: "); + for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t)) + { + dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false); + pp_string (buffer, " "); + } + newline_and_indent (buffer, spc + 2); + } +} + + +/* 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, @@ -421,32 +595,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, is_expr = EXPR_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) - && has_stmt_ann (node) - && TREE_CODE (node) != PHI_NODE) - dump_vops (buffer, node, spc, flags); - if (is_stmt && (flags & TDF_STMTADDR)) pp_printf (buffer, "<&%p> ", (void *)node); if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node)) - { - expanded_location xloc = expand_location (EXPR_LOCATION (node)); - pp_character (buffer, '['); - if (xloc.file) - { - pp_string (buffer, xloc.file); - pp_string (buffer, " : "); - } - pp_decimal_int (buffer, xloc.line); - pp_string (buffer, "] "); - } + dump_location (buffer, EXPR_LOCATION (node)); switch (TREE_CODE (node)) { @@ -478,6 +631,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case TREE_BINFO: dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false); + break; case TREE_VEC: { @@ -486,13 +640,13 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, { 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, + dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc, flags, false); } } @@ -501,13 +655,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 "); @@ -516,16 +671,23 @@ 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)); + if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) + { + pp_string (buffer, " "); + } - if (class == tcc_declaration) + tclass = TREE_CODE_CLASS (TREE_CODE (node)); + + 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)) { @@ -539,9 +701,37 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, } else if (TREE_CODE (node) == VECTOR_TYPE) { - pp_string (buffer, "vector "); - dump_generic_node (buffer, TREE_TYPE (node), - spc, flags, false); + pp_string (buffer, "vector"); + pp_character (buffer, '('); + pp_wide_integer (buffer, TYPE_VECTOR_SUBPARTS (node)); + pp_string (buffer, ") "); + dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); + } + else if (TREE_CODE (node) == INTEGER_TYPE) + { + pp_string (buffer, (TYPE_UNSIGNED (node) + ? ""); + } + else if (TREE_CODE (node) == COMPLEX_TYPE) + { + pp_string (buffer, "__complex__ "); + dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); + } + else if (TREE_CODE (node) == REAL_TYPE) + { + pp_string (buffer, ""); + } + else if (TREE_CODE (node) == FIXED_POINT_TYPE) + { + pp_string (buffer, ""); } else pp_string (buffer, ""); @@ -553,7 +743,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case REFERENCE_TYPE: str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&"); - if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE) + if (TREE_TYPE (node) == NULL) + { + pp_string (buffer, str); + pp_string (buffer, ""); + } + else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE) { tree fnode = TREE_TYPE (node); @@ -579,11 +774,18 @@ 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 (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) + { + pp_string (buffer, " "); + } + if (TYPE_REF_CAN_ALIAS_ALL (node)) pp_string (buffer, " {ref-all}"); } @@ -593,11 +795,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, NIY; break; - case METHOD_TYPE: - dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags); - pp_string (buffer, "::"); - break; - case TARGET_MEM_REF: { const char *sep = ""; @@ -675,17 +872,31 @@ 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 if (!(flags & TDF_SLIM)) + /* FIXME: If we eliminate the 'else' above and attempt + to show the fields for named types, we may get stuck + following a cycle of pointers to structs. The alleged + self-reference check in print_struct_decl will not detect + cycles involving more than one pointer or struct type. */ + print_struct_decl (buffer, node, spc, flags); + break; + } case LANG_TYPE: NIY; @@ -720,23 +931,21 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, else if (! host_integerp (node, 0)) { tree val = node; + unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val); + HOST_WIDE_INT high = TREE_INT_CST_HIGH (val); if (tree_int_cst_sgn (val) < 0) { pp_character (buffer, '-'); - val = build_int_cst_wide (NULL_TREE, - -TREE_INT_CST_LOW (val), - ~TREE_INT_CST_HIGH (val) - + !TREE_INT_CST_LOW (val)); + high = ~high + !low; + low = -low; } /* 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, - TREE_INT_CST_HIGH (val), - TREE_INT_CST_LOW (val)); - pp_string (buffer, pp_buffer (buffer)->digit_buffer); - } + sprintf (pp_buffer (buffer)->digit_buffer, + HOST_WIDE_INT_PRINT_DOUBLE_HEX, + (unsigned HOST_WIDE_INT) high, low); + pp_string (buffer, pp_buffer (buffer)->digit_buffer); } else pp_wide_integer (buffer, TREE_INT_CST_LOW (node)); @@ -752,7 +961,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC) d = TREE_REAL_CST (node); if (REAL_VALUE_ISINF (d)) - pp_string (buffer, " Inf"); + pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf"); else if (REAL_VALUE_ISNAN (d)) pp_string (buffer, " Nan"); else @@ -773,6 +982,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); @@ -802,6 +1019,23 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, break; case FUNCTION_TYPE: + case METHOD_TYPE: + dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); + pp_space (buffer); + if (TREE_CODE (node) == METHOD_TYPE) + { + if (TYPE_METHOD_BASETYPE (node)) + dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), + flags); + else + pp_string (buffer, ""); + pp_string (buffer, "::"); + } + if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) + dump_decl_name (buffer, TYPE_NAME (node), flags); + else + pp_printf (buffer, "", TYPE_UID (node)); + dump_function_declaration (buffer, node, spc, flags); break; case FUNCTION_DECL: @@ -813,10 +1047,14 @@ 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)); + { + if (flags & TDF_NOUID) + pp_string (buffer, ""); + else + pp_printf (buffer, "", DECL_UID (node)); + } break; case TYPE_DECL: @@ -848,12 +1086,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, } break; - case SYMBOL_MEMORY_TAG: - case NAME_MEMORY_TAG: - case STRUCT_FIELD_TAG: case VAR_DECL: case PARM_DECL: case FIELD_DECL: + case DEBUG_EXPR_DECL: case NAMESPACE_DECL: dump_decl_name (buffer, node, flags); break; @@ -865,7 +1101,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case COMPONENT_REF: op0 = TREE_OPERAND (node, 0); str = "."; - if (TREE_CODE (op0) == INDIRECT_REF) + if (op0 && TREE_CODE (op0) == INDIRECT_REF) { op0 = TREE_OPERAND (op0, 0); str = "->"; @@ -877,16 +1113,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; @@ -918,8 +1150,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); @@ -1025,11 +1257,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case MODIFY_EXPR: case INIT_EXPR: - dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + 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, TREE_OPERAND (node, 1), spc, flags, false); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, + false); break; case TARGET_EXPR: @@ -1061,9 +1298,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)) { pp_space (buffer); - dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true); - pp_string (buffer, " else "); - dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true); + dump_generic_node (buffer, COND_EXPR_THEN (node), + 0, flags, true); + if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node))) + { + pp_string (buffer, " else "); + dump_generic_node (buffer, COND_EXPR_ELSE (node), + 0, flags, true); + } } else if (!(flags & TDF_SLIM)) { @@ -1080,7 +1322,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, } /* Output COND_EXPR_ELSE. */ - if (COND_EXPR_ELSE (node)) + if (COND_EXPR_ELSE (node) + && !IS_EMPTY_STMT (COND_EXPR_ELSE (node))) { newline_and_indent (buffer, spc); pp_string (buffer, "else"); @@ -1133,17 +1376,36 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, break; case CALL_EXPR: - print_call_name (buffer, node); + print_call_name (buffer, CALL_EXPR_FN (node), 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: "); @@ -1178,6 +1440,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: @@ -1224,7 +1487,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); @@ -1239,7 +1502,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); @@ -1323,10 +1586,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, NIY; break; + case ADDR_SPACE_CONVERT_EXPR: + 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)) @@ -1350,6 +1614,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); @@ -1457,14 +1727,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_string (buffer, " [non-local]"); break; - case EXC_PTR_EXPR: - pp_string (buffer, "<<>>"); - break; - - case FILTER_EXPR: - pp_string (buffer, "<<>>"); - break; - case LOOP_EXPR: pp_string (buffer, "while (1)"); if (!(flags & TDF_SLIM)) @@ -1479,6 +1741,16 @@ 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); @@ -1486,7 +1758,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, { pp_space (buffer); if (TREE_CODE (op0) == MODIFY_EXPR) - dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false); + dump_generic_node (buffer, TREE_OPERAND (op0, 1), + spc, flags, false); else dump_generic_node (buffer, op0, spc, flags, false); } @@ -1554,11 +1827,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, dump_generic_node (buffer, op0, spc, flags, false); break; - case RESX_EXPR: - pp_string (buffer, "resx "); - dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); - break; - case ASM_EXPR: pp_string (buffer, "__asm__"); if (ASM_VOLATILE_P (node)) @@ -1591,7 +1859,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; @@ -1606,31 +1874,14 @@ 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, ">;"); - } - break; - case SSA_NAME: dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false); pp_string (buffer, "_"); pp_decimal_int (buffer, SSA_NAME_VERSION (node)); if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node)) pp_string (buffer, "(ab)"); + else if (SSA_NAME_IS_DEFAULT_DEF (node)) + pp_string (buffer, "(D)"); break; case WITH_SIZE_EXPR: @@ -1641,10 +1892,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); @@ -1680,7 +1927,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, 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); @@ -1704,21 +1951,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)) @@ -1733,12 +1965,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); @@ -1748,14 +1987,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); @@ -1766,6 +2013,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; @@ -1784,7 +2032,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case OMP_SECTION: pp_string (buffer, "#pragma omp section"); goto dump_omp_body; - + case OMP_MASTER: pp_string (buffer, "#pragma omp master"); goto dump_omp_body; @@ -1820,18 +2068,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; @@ -1883,14 +2119,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); @@ -1898,64 +2146,50 @@ 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 BLOCK: - { - tree t; - pp_string (buffer, "BLOCK"); - if (BLOCK_ABSTRACT (node)) - pp_string (buffer, " [abstract]"); - - if (TREE_ASM_WRITTEN (node)) - pp_string (buffer, " [written]"); + 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; - newline_and_indent (buffer, spc + 2); + case BLOCK: + dump_block_node (buffer, node, spc, flags); + break; - if (BLOCK_SUPERCONTEXT (node)) - { - pp_string (buffer, "SUPERCONTEXT: "); - if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK) - pp_printf (buffer, "BLOCK %p", - (void *)BLOCK_SUPERCONTEXT (node)); - else - dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags, - false); - newline_and_indent (buffer, spc + 2); - } + case VEC_EXTRACT_EVEN_EXPR: + pp_string (buffer, " VEC_EXTRACT_EVEN_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; - if (BLOCK_SUBBLOCKS (node)) - { - pp_string (buffer, "SUBBLOCKS: "); - for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t)) - pp_printf (buffer, "%p ", (void *)t); - newline_and_indent (buffer, spc + 2); - } + case VEC_EXTRACT_ODD_EXPR: + pp_string (buffer, " VEC_EXTRACT_ODD_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; - if (BLOCK_VARS (node)) - { - pp_string (buffer, "VARS: "); - for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t)) - { - dump_generic_node (buffer, t, 0, flags, false); - pp_string (buffer, " "); - } - newline_and_indent (buffer, spc + 2); - } + case VEC_INTERLEAVE_HIGH_EXPR: + pp_string (buffer, " VEC_INTERLEAVE_HIGH_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; - if (BLOCK_ABSTRACT_ORIGIN (node)) - { - pp_string (buffer, "ABSTRACT_ORIGIN: "); - if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK) - pp_printf (buffer, "BLOCK %p", - (void *)BLOCK_ABSTRACT_ORIGIN (node)); - else - dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags, - false); - newline_and_indent (buffer, spc + 2); - } - } - break; + case VEC_INTERLEAVE_LOW_EXPR: + pp_string (buffer, " VEC_INTERLEAVE_LOW_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; default: NIY; @@ -1963,14 +2197,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); @@ -2034,7 +2272,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) @@ -2064,7 +2302,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)) @@ -2097,8 +2335,8 @@ print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags) Maybe this could be solved by looking at the scope in which the structure was declared. */ if (TREE_TYPE (tmp) != node - || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE - && TREE_TYPE (TREE_TYPE (tmp)) != node)) + && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE + || TREE_TYPE (TREE_TYPE (tmp)) != node)) { print_declaration (buffer, tmp, spc+2, flags); pp_newline (buffer); @@ -2110,7 +2348,7 @@ print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags) pp_character (buffer, '}'); } -/* Return the priority of the operator OP. +/* Return the priority of the operator CODE. From lowest to highest precedence with either left-to-right (L-R) or right-to-left (R-L) associativity]: @@ -2134,13 +2372,10 @@ print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags) unary +, - and * have higher precedence than the corresponding binary operators. */ -static int -op_prio (tree op) +int +op_code_prio (enum tree_code code) { - if (op == NULL) - return 9999; - - switch (TREE_CODE (op)) + switch (code) { case TREE_LIST: case COMPOUND_EXPR: @@ -2198,6 +2433,7 @@ op_prio (tree op) case WIDEN_SUM_EXPR: case PLUS_EXPR: + case POINTER_PLUS_EXPR: case MINUS_EXPR: return 12; @@ -2230,8 +2466,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; @@ -2255,14 +2490,12 @@ 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; - case SAVE_EXPR: - case NON_LVALUE_EXPR: - return op_prio (TREE_OPERAND (op, 0)); - default: /* Return an arbitrarily high precedence to avoid surrounding single VAR_DECLs in ()s. */ @@ -2270,11 +2503,27 @@ op_prio (tree op) } } +/* Return the priority of the operator OP. */ -/* Return the symbol associated with operator OP. */ +int +op_prio (const_tree op) +{ + enum tree_code code; -static const char * -op_symbol_1 (enum tree_code code) + if (op == NULL) + return 9999; + + code = TREE_CODE (op); + if (code == SAVE_EXPR || code == NON_LVALUE_EXPR) + return op_prio (TREE_OPERAND (op, 0)); + + return op_code_prio (code); +} + +/* Return the symbol associated with operator CODE. */ + +const char * +op_symbol_code (enum tree_code code) { switch (code) { @@ -2353,7 +2602,10 @@ op_symbol_1 (enum tree_code code) case VEC_RSHIFT_EXPR: return "v>>"; - + + case POINTER_PLUS_EXPR: + return "+"; + case PLUS_EXPR: return "+"; @@ -2437,71 +2689,60 @@ 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. */ +/* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or + the gimple_call_fn of a GIMPLE_CALL. */ -static void -print_call_name (pretty_printer *buffer, tree node) +void +print_call_name (pretty_printer *buffer, tree node, int flags) { - tree op0; - - gcc_assert (TREE_CODE (node) == CALL_EXPR); - - op0 = TREE_OPERAND (node, 0); + tree op0 = node; if (TREE_CODE (op0) == NON_LVALUE_EXPR) op0 = TREE_OPERAND (op0, 0); + again: switch (TREE_CODE (op0)) { case VAR_DECL: case PARM_DECL: - dump_function_name (buffer, op0); + case FUNCTION_DECL: + dump_function_name (buffer, op0, flags); break; case ADDR_EXPR: case INDIRECT_REF: case NOP_EXPR: - dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false); - break; + op0 = TREE_OPERAND (op0, 0); + goto again; case COND_EXPR: pp_string (buffer, "("); - dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false); + dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false); pp_string (buffer, ") ? "); - dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false); + dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false); pp_string (buffer, " : "); - dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false); - break; - - case COMPONENT_REF: - /* 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) - dump_function_name (buffer, TREE_OPERAND (op0, 1)); - else - dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false); - /* else - We can have several levels of structures and a function - pointer inside. This is not implemented yet... */ - /* NIY;*/ + dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, flags, false); break; case ARRAY_REF: if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL) - dump_function_name (buffer, TREE_OPERAND (op0, 0)); + dump_function_name (buffer, TREE_OPERAND (op0, 0), flags); else - dump_generic_node (buffer, op0, 0, 0, false); + dump_generic_node (buffer, op0, 0, flags, false); break; + case COMPONENT_REF: case SSA_NAME: case OBJ_TYPE_REF: - dump_generic_node (buffer, op0, 0, 0, false); + dump_generic_node (buffer, op0, 0, flags, false); break; default: @@ -2602,6 +2843,7 @@ maybe_init_pretty_print (FILE *file) { pp_construct (&buffer, /* prefix */NULL, /* line-width */0); pp_needs_newline (&buffer) = true; + pp_translate_identifiers (&buffer) = false; initialized = 1; } @@ -2615,284 +2857,51 @@ newline_and_indent (pretty_printer *buffer, int spc) INDENT (spc); } -static void -dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags) -{ - tree use; - use_operand_p use_p; - def_operand_p def_p; - use_operand_p kill_p; - ssa_op_iter iter; - - if (!ssa_operands_active ()) - return; - - FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter) - { - pp_string (buffer, "# "); - dump_generic_node (buffer, DEF_FROM_PTR (def_p), - spc + 2, flags, false); - pp_string (buffer, " = V_MAY_DEF <"); - dump_generic_node (buffer, USE_FROM_PTR (use_p), - spc + 2, flags, false); - pp_string (buffer, ">;"); - newline_and_indent (buffer, spc); - } - - FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter) - { - 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); - } - - FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE) - { - pp_string (buffer, "# VUSE <"); - dump_generic_node (buffer, use, spc + 2, flags, false); - pp_string (buffer, ">;"); - newline_and_indent (buffer, spc); - } -} - -/* Dumps basic block BB to FILE with details described by FLAGS and - indented by INDENT spaces. */ +/* Handle a %K format for TEXT. Separate from default_tree_printer so + it can also be used in front ends. + %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded. +*/ 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); -} - -/* Dumps phi nodes of basic block BB to buffer BUFFER with details described by - FLAGS indented by INDENT spaces. */ - -static void -dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags) +percent_K_format (text_info *text) { - tree phi = phi_nodes (bb); - if (!phi) - return; - - for (; phi; phi = PHI_CHAIN (phi)) + tree t = va_arg (*text->args_ptr, tree), block; + gcc_assert (text->locus != NULL); + *text->locus = EXPR_LOCATION (t); + gcc_assert (pp_ti_abstract_origin (text) != NULL); + block = TREE_BLOCK (t); + *pp_ti_abstract_origin (text) = NULL; + while (block + && TREE_CODE (block) == BLOCK + && BLOCK_ABSTRACT_ORIGIN (block)) { - 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. */ + tree ao = BLOCK_ABSTRACT_ORIGIN (block); -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); + while (TREE_CODE (ao) == BLOCK + && BLOCK_ABSTRACT_ORIGIN (ao) + && BLOCK_ABSTRACT_ORIGIN (ao) != ao) + ao = BLOCK_ABSTRACT_ORIGIN (ao); - if ((flags & TDF_LINENO) -#ifdef USE_MAPPED_LOCATION - && e->goto_locus != UNKNOWN_LOCATION -#else - && e->goto_locus -#endif - ) + if (TREE_CODE (ao) == FUNCTION_DECL) { - 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_ti_abstract_origin (text) = block; + break; } - - pp_cfg_jump (buffer, e->dest); - pp_newline (buffer); + block = BLOCK_SUPERCONTEXT (block); } } -/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and - indented by INDENT spaces. */ +/* Print the identifier ID to PRETTY-PRINTER. */ -static void -dump_generic_bb_buff (pretty_printer *buffer, basic_block bb, - int indent, int flags) +void +pp_base_tree_identifier (pretty_printer *pp, tree id) { - 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)) + if (pp_translate_identifiers (pp)) { - 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); + const char *text = identifier_to_locale (IDENTIFIER_POINTER (id)); + pp_append_text (pp, text, text + strlen (text)); } - - dump_implicit_edges (buffer, bb, indent, flags); - - if (flags & TDF_BLOCKS) - dump_bb_end (buffer, bb, indent, flags); + else + pp_append_text (pp, IDENTIFIER_POINTER (id), + IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id)); }