X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-pretty-print.c;h=4b9b4536641469a999a26fba7201421c4a372989;hb=208ee050c84d5f6674eae1883f53f6396e47d753;hp=32f8ac00d3783a48ba4e62ca83ea0a6699c28240;hpb=b4c018995f8b4be4e77c61e16244c0a9ad29e7cb;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c index 32f8ac00d37..4b9b4536641 100644 --- a/gcc/tree-pretty-print.c +++ b/gcc/tree-pretty-print.c @@ -1,13 +1,13 @@ /* Pretty formatting of GENERIC trees in C syntax. - Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 - Free Software Foundation, Inc. + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, + 2011 Free Software Foundation, Inc. Adapted from c-pretty-print.c by Diego Novillo 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,17 +16,16 @@ 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 "diagnostic.h" -#include "real.h" +#include "output.h" +#include "tree-pretty-print.h" #include "hashtab.h" #include "tree-flow.h" #include "langhooks.h" @@ -34,38 +33,28 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA #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"); + pp_string (buffer, " >>>"); } -void +/* Debugging function to print out a generic expression. */ + +DEBUG_FUNCTION void debug_generic_expr (tree t) { print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS); fprintf (stderr, "\n"); } -void +/* Debugging function to print out a generic statement. */ + +DEBUG_FUNCTION void debug_generic_stmt (tree t) { print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS); fprintf (stderr, "\n"); } -void +/* Debugging function to print out a chain of trees . */ + +DEBUG_FUNCTION void debug_tree_chain (tree t) { + struct pointer_set_t *seen = pointer_set_create (); + while (t) - { - print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|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. */ @@ -121,7 +127,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 +138,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 +155,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) @@ -164,34 +170,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 @@ -207,23 +232,27 @@ dump_function_declaration (pretty_printer *buffer, tree node, pp_space (buffer); pp_character (buffer, '('); - /* Print the argument types. The last element in the list is a VOID_TYPE. - The following avoids printing the last element. */ + /* Print the argument types. */ arg = TYPE_ARG_TYPES (node); - while (arg && TREE_CHAIN (arg) && arg != error_mark_node) + while (arg && arg != void_list_node && arg != error_mark_node) { - wrote_arg = true; - dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false); - arg = TREE_CHAIN (arg); - if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST) + if (wrote_arg) { pp_character (buffer, ','); pp_space (buffer); } + wrote_arg = true; + dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false); + arg = TREE_CHAIN (arg); } - if (!wrote_arg) + /* Drop the trailing void_type_node if we had any previous argument. */ + if (arg == void_list_node && !wrote_arg) pp_string (buffer, "void"); + /* Properly dump vararg function types. */ + else if (!arg && wrote_arg) + pp_string (buffer, ", ..."); + /* Avoid printing any arg for unprototyped functions. */ pp_character (buffer, ')'); } @@ -296,7 +325,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 +357,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 +393,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 +409,29 @@ 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; + + case OMP_CLAUSE_FINAL: + pp_string (buffer, "final("); + dump_generic_node (buffer, OMP_CLAUSE_FINAL_EXPR (clause), + spc, flags, false); + pp_character (buffer, ')'); + break; + + case OMP_CLAUSE_MERGEABLE: + pp_string (buffer, "mergeable"); + break; + default: /* Should never happen. */ dump_generic_node (buffer, clause, spc, flags, false); @@ -385,7 +443,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 +461,139 @@ 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 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_symbols (pretty_printer *buffer, bitmap syms, int flags) +dump_block_node (pretty_printer *buffer, tree block, int spc, int flags) { - unsigned i; - bitmap_iterator bi; + tree t; - if (syms == NULL) - pp_string (buffer, "NIL"); - else + 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, " { "); + pp_string (buffer, "SUPERCONTEXT: "); + dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0, + flags | TDF_SLIM, false); + newline_and_indent (buffer, spc + 2); + } - EXECUTE_IF_SET_IN_BITMAP (syms, 0, i, bi) + if (BLOCK_SUBBLOCKS (block)) + { + pp_string (buffer, "SUBBLOCKS: "); + for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t)) { - tree sym = referenced_var_lookup (i); - dump_generic_node (buffer, sym, 0, flags, false); + dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false); pp_string (buffer, " "); } + newline_and_indent (buffer, spc + 2); + } - pp_string (buffer, "}"); + 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_EACH_VEC_ELT (tree, nlv, i, t) + { + 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. */ +/* 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,34 +607,13 @@ 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); 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)) { @@ -506,6 +645,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: { @@ -514,13 +654,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); } } @@ -529,13 +669,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 +685,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, " "); + } + + 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)) { @@ -567,9 +715,11 @@ 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) { @@ -579,6 +729,26 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_decimal_int (buffer, TYPE_PRECISION (node)); pp_string (buffer, ">"); } + 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 if (TREE_CODE (node) == VOID_TYPE) + pp_string (buffer, "void"); else pp_string (buffer, ""); } @@ -589,7 +759,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); @@ -599,6 +774,8 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, 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, ""); else pp_printf (buffer, "", TYPE_UID (node)); @@ -615,11 +792,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}"); } @@ -629,10 +813,61 @@ 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 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 + /* Released SSA_NAMES have no TREE_TYPE. */ + && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE + /* 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: { @@ -641,15 +876,22 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, 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); + } + else + { + pp_string (buffer, sep); + sep = ", "; + pp_string (buffer, "base: "); + dump_generic_node (buffer, TMR_BASE (node), spc, flags, false); } - tmp = TMR_BASE (node); + tmp = TMR_INDEX2 (node); if (tmp) { pp_string (buffer, sep); @@ -682,13 +924,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, 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; @@ -711,17 +946,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; @@ -753,7 +1002,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_wide_integer (buffer, TREE_INT_CST_LOW (node)); pp_string (buffer, "B"); /* pseudo-unit */ } - else if (! host_integerp (node, 0)) + else if (host_integerp (node, 0)) + pp_wide_integer (buffer, TREE_INT_CST_LOW (node)); + else if (host_integerp (node, 1)) + pp_unsigned_wide_integer (buffer, TREE_INT_CST_LOW (node)); + else { tree val = node; unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val); @@ -768,11 +1021,10 @@ 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 - pp_wide_integer (buffer, TREE_INT_CST_LOW (node)); break; case REAL_CST: @@ -806,6 +1058,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); @@ -835,6 +1095,25 @@ 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 if (flags & TDF_NOUID) + pp_printf (buffer, ""); + else + pp_printf (buffer, "", TYPE_UID (node)); + dump_function_declaration (buffer, node, spc, flags); break; case FUNCTION_DECL: @@ -846,10 +1125,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: @@ -860,7 +1143,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, } 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) @@ -879,16 +1162,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); } } + else + pp_string (buffer, ""); 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: - case MEMORY_PARTITION_TAG: dump_decl_name (buffer, node, flags); break; @@ -899,7 +1181,29 @@ 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 + || (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 + /* Released SSA_NAMES have no TREE_TYPE. */ + && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE + /* 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 = "->"; @@ -911,16 +1215,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; @@ -967,19 +1267,60 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, { unsigned HOST_WIDE_INT ix; tree field, val; - bool is_struct_init = FALSE; + bool is_struct_init = false; + bool is_array_init = false; + double_int curidx = double_int_zero; pp_character (buffer, '{'); - if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE - || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) - is_struct_init = TRUE; + if (TREE_CLOBBER_P (node)) + pp_string (buffer, "CLOBBER"); + else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE + || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) + is_struct_init = true; + else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE + && TYPE_DOMAIN (TREE_TYPE (node)) + && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))) + && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))) + == INTEGER_CST) + { + tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))); + is_array_init = true; + curidx = tree_to_double_int (minv); + } FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val) { - if (field && is_struct_init) + if (field) { - pp_character (buffer, '.'); - dump_generic_node (buffer, field, spc, flags, false); - pp_string (buffer, "="); + if (is_struct_init) + { + pp_character (buffer, '.'); + dump_generic_node (buffer, field, spc, flags, false); + pp_character (buffer, '='); + } + else if (is_array_init + && (TREE_CODE (field) != INTEGER_CST + || !double_int_equal_p (tree_to_double_int (field), + curidx))) + { + pp_character (buffer, '['); + if (TREE_CODE (field) == RANGE_EXPR) + { + dump_generic_node (buffer, TREE_OPERAND (field, 0), spc, + flags, false); + pp_string (buffer, " ... "); + dump_generic_node (buffer, TREE_OPERAND (field, 1), spc, + flags, false); + if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST) + curidx = tree_to_double_int (TREE_OPERAND (field, 1)); + } + else + dump_generic_node (buffer, field, spc, flags, false); + if (TREE_CODE (field) == INTEGER_CST) + curidx = tree_to_double_int (field); + pp_string (buffer, "]="); + } } + if (is_array_init) + curidx = double_int_add (curidx, double_int_one); if (val && TREE_CODE (val) == ADDR_EXPR) if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL) val = TREE_OPERAND (val, 0); @@ -1058,14 +1399,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; @@ -1160,7 +1503,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, { 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); @@ -1176,7 +1519,7 @@ 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); @@ -1194,6 +1537,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, } } } + 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 = CALL_EXPR_STATIC_CHAIN (node); @@ -1231,6 +1583,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: @@ -1248,6 +1601,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case RROTATE_EXPR: case VEC_LSHIFT_EXPR: case VEC_RSHIFT_EXPR: + case WIDEN_LSHIFT_EXPR: case BIT_IOR_EXPR: case BIT_XOR_EXPR: case BIT_AND_EXPR: @@ -1310,8 +1664,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case ADDR_EXPR: case PREDECREMENT_EXPR: case PREINCREMENT_EXPR: - case ALIGN_INDIRECT_REF: - case MISALIGNED_INDIRECT_REF: case INDIRECT_REF: if (TREE_CODE (node) == ADDR_EXPR && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST @@ -1328,13 +1680,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, } else dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); - - if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF) - { - pp_string (buffer, "{misalignment: "); - dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); - pp_character (buffer, '}'); - } break; case POSTDECREMENT_EXPR: @@ -1376,10 +1721,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)) @@ -1403,6 +1749,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); @@ -1510,14 +1862,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)) @@ -1532,15 +1876,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); @@ -1609,11 +1962,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)) @@ -1646,7 +1994,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; @@ -1661,28 +2009,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, "_"); @@ -1701,10 +2027,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); @@ -1740,7 +2062,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); @@ -1750,6 +2072,16 @@ 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_PERM_EXPR: + pp_string (buffer, " VEC_PERM_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 DOT_PROD_EXPR: pp_string (buffer, " DOT_PROD_EXPR < "); @@ -1761,24 +2093,39 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_string (buffer, " > "); break; - 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); + 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; - pp_string (buffer, " ("); + 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; - if (OMP_PARALLEL_DATA_ARG (node)) - dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags, - false); - else - pp_string (buffer, "???"); + 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; - pp_string (buffer, ")]"); - } + case OMP_PARALLEL: + pp_string (buffer, "#pragma omp parallel"); + dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags); dump_omp_body: if (!(flags & TDF_SLIM) && OMP_BODY (node)) @@ -1793,12 +2140,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); @@ -1808,14 +2162,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); @@ -1826,6 +2188,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; @@ -1844,7 +2207,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; @@ -1875,25 +2238,51 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); break; + case OMP_ATOMIC_READ: + pp_string (buffer, "#pragma omp atomic read"); + newline_and_indent (buffer, spc + 2); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_space (buffer); + break; + + case OMP_ATOMIC_CAPTURE_OLD: + case OMP_ATOMIC_CAPTURE_NEW: + pp_string (buffer, "#pragma omp atomic capture"); + newline_and_indent (buffer, spc + 2); + dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); + pp_space (buffer); + pp_character (buffer, '='); + pp_space (buffer); + dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); + break; + case OMP_SINGLE: pp_string (buffer, "#pragma omp single"); 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"); + case OMP_CLAUSE: + dump_omp_clause (buffer, node, spc, flags); is_expr = false; break; - case OMP_CLAUSE: - dump_omp_clause (buffer, node, spc, flags); + case TRANSACTION_EXPR: + if (TRANSACTION_EXPR_OUTER (node)) + pp_string (buffer, "__transaction_atomic [[outer]]"); + else if (TRANSACTION_EXPR_RELAXED (node)) + pp_string (buffer, "__transaction_relaxed"); + else + pp_string (buffer, "__transaction_atomic"); + if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node)) + { + newline_and_indent (buffer, spc); + pp_character (buffer, '{'); + newline_and_indent (buffer, spc + 2); + dump_generic_node (buffer, TRANSACTION_EXPR_BODY (node), + spc + 2, flags, false); + newline_and_indent (buffer, spc); + pp_character (buffer, '}'); + } is_expr = false; break; @@ -1931,6 +2320,22 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_string (buffer, " > "); break; + case VEC_WIDEN_LSHIFT_HI_EXPR: + pp_string (buffer, " VEC_WIDEN_LSHIFT_HI_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_WIDEN_LSHIFT_LO_EXPR: + pp_string (buffer, " VEC_WIDEN_LSHIFT_HI_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_UNPACK_HI_EXPR: pp_string (buffer, " VEC_UNPACK_HI_EXPR < "); dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); @@ -1943,110 +2348,44 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, pp_string (buffer, " > "); break; - case VEC_PACK_TRUNC_EXPR: - pp_string (buffer, " VEC_PACK_TRUNC_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, ", "); - 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 < "); + + 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, ", "); - 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]"); - - newline_and_indent (buffer, spc + 2); - - 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); - } - - 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); - } - 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); - } - - 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_EXTRACT_EVEN_EXPR: - pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < "); + 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_EXTRACT_ODD_EXPR: - pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < "); + + case VEC_PACK_SAT_EXPR: + pp_string (buffer, " VEC_PACK_SAT_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_INTERLEAVE_HIGH_EXPR: - pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < "); + 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 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, " > "); + case BLOCK: + dump_block_node (buffer, node, spc, flags); break; default: @@ -2066,7 +2405,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, /* Print the declaration of a variable. */ -static void +void print_declaration (pretty_printer *buffer, tree t, int spc, int flags) { INDENT (spc); @@ -2083,7 +2422,7 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags) 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; @@ -2130,7 +2469,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) @@ -2160,7 +2499,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)) @@ -2193,20 +2532,20 @@ 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); } - tmp = TREE_CHAIN (tmp); + tmp = DECL_CHAIN (tmp); } } INDENT (spc); 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]: @@ -2230,13 +2569,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: @@ -2244,7 +2580,6 @@ op_prio (tree op) return 1; case MODIFY_EXPR: - case GIMPLE_MODIFY_STMT: case INIT_EXPR: return 2; @@ -2291,10 +2626,14 @@ op_prio (tree op) case RSHIFT_EXPR: case LROTATE_EXPR: case RROTATE_EXPR: + case VEC_WIDEN_LSHIFT_HI_EXPR: + case VEC_WIDEN_LSHIFT_LO_EXPR: + case WIDEN_LSHIFT_EXPR: return 11; case WIDEN_SUM_EXPR: case PLUS_EXPR: + case POINTER_PLUS_EXPR: case MINUS_EXPR: return 12; @@ -2302,6 +2641,8 @@ op_prio (tree op) 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: @@ -2313,6 +2654,7 @@ op_prio (tree op) case CEIL_MOD_EXPR: case FLOOR_MOD_EXPR: case ROUND_MOD_EXPR: + case FMA_EXPR: return 13; case TRUTH_NOT_EXPR: @@ -2322,13 +2664,10 @@ op_prio (tree op) case PREINCREMENT_EXPR: case PREDECREMENT_EXPR: case NEGATE_EXPR: - case ALIGN_INDIRECT_REF: - case MISALIGNED_INDIRECT_REF: case INDIRECT_REF: case ADDR_EXPR: case FLOAT_EXPR: - case NOP_EXPR: - case CONVERT_EXPR: + CASE_CONVERT: case FIX_TRUNC_EXPR: case TARGET_EXPR: return 14; @@ -2352,14 +2691,12 @@ op_prio (tree op) case VEC_RSHIFT_EXPR: case VEC_UNPACK_HI_EXPR: case VEC_UNPACK_LO_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. */ @@ -2367,16 +2704,31 @@ 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) { case MODIFY_EXPR: - case GIMPLE_MODIFY_STMT: return "="; case TRUTH_OR_EXPR: @@ -2451,7 +2803,13 @@ op_symbol_1 (enum tree_code code) case VEC_RSHIFT_EXPR: return "v>>"; - + + case WIDEN_LSHIFT_EXPR: + return "w<<"; + + case POINTER_PLUS_EXPR: + return "+"; + case PLUS_EXPR: return "+"; @@ -2478,12 +2836,6 @@ op_symbol_1 (enum tree_code code) case INDIRECT_REF: return "*"; - case ALIGN_INDIRECT_REF: - return "A*"; - - case MISALIGNED_INDIRECT_REF: - return "M*"; - case TRUNC_DIV_EXPR: case RDIV_EXPR: return "/"; @@ -2535,71 +2887,67 @@ 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 = CALL_EXPR_FN (node); + 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 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: - dump_generic_node (buffer, op0, 0, 0, false); + dump_generic_node (buffer, op0, 0, flags, false); break; default: @@ -2700,6 +3048,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; } @@ -2713,324 +3062,88 @@ newline_and_indent (pretty_printer *buffer, int spc) INDENT (spc); } +/* 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. +*/ -static void -dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags) +void +percent_K_format (text_info *text) { - 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) + 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 (LOADED_SYMS (stmt)) - { - pp_string (buffer, "# LOADS: "); - dump_symbols (buffer, LOADED_SYMS (stmt), flags); - newline_and_indent (buffer, spc); - } + tree ao = BLOCK_ABSTRACT_ORIGIN (block); - if (STORED_SYMS (stmt)) - { - pp_string (buffer, "# STORES: "); - dump_symbols (buffer, STORED_SYMS (stmt), flags); - newline_and_indent (buffer, spc); - } - - return; - } + while (TREE_CODE (ao) == BLOCK + && BLOCK_ABSTRACT_ORIGIN (ao) + && BLOCK_ABSTRACT_ORIGIN (ao) != ao) + ao = BLOCK_ABSTRACT_ORIGIN (ao); - 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++) + if (TREE_CODE (ao) == FUNCTION_DECL) { - dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0); - if (i < n - 1) - pp_string (buffer, ", "); + *pp_ti_abstract_origin (text) = block; + break; } - - 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; + block = BLOCK_SUPERCONTEXT (block); } } - -/* Dumps basic block BB to FILE with details described by FLAGS and - indented by INDENT spaces. */ +/* Print the identifier ID to PRETTY-PRINTER. */ 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) +pp_base_tree_identifier (pretty_printer *pp, tree id) { - edge e; - tree stmt; - edge_iterator ei; - - if (flags & TDF_BLOCKS) + if (pp_translate_identifiers (pp)) { - 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); + const char *text = identifier_to_locale (IDENTIFIER_POINTER (id)); + pp_append_text (pp, text, text + strlen (text)); } 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); - } + pp_append_text (pp, IDENTIFIER_POINTER (id), + IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id)); } -/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and - indented by INDENT spaces. */ +/* A helper function that is used to dump function information before the + function dump. */ -static void -dump_generic_bb_buff (pretty_printer *buffer, basic_block bb, - int indent, int flags) +void +dump_function_header (FILE *dump_file, tree fdecl, int flags) { - block_stmt_iterator bsi; - tree stmt; - int label_indent = indent - 2; - - if (label_indent < 0) - label_indent = 0; + const char *dname, *aname; + struct cgraph_node *node = cgraph_get_node (fdecl); + struct function *fun = DECL_STRUCT_FUNCTION (fdecl); - dump_bb_header (buffer, bb, indent, flags); + dname = lang_hooks.decl_printable_name (fdecl, 2); - dump_phi_nodes (buffer, bb, indent, flags); + if (DECL_ASSEMBLER_NAME_SET_P (fdecl)) + aname = (IDENTIFIER_POINTER + (DECL_ASSEMBLER_NAME (fdecl))); + else + aname = ""; - for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) + fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d", + dname, aname, fun->funcdef_no); + if (!(flags & TDF_NOUID)) + fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl)); + if (node) { - 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); + fprintf (dump_file, ", cgraph_uid=%d)%s\n\n", node->uid, + node->frequency == NODE_FREQUENCY_HOT + ? " (hot)" + : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED + ? " (unlikely executed)" + : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE + ? " (executed once)" + : ""); } - - dump_implicit_edges (buffer, bb, indent, flags); - - if (flags & TDF_BLOCKS) - dump_bb_end (buffer, bb, indent, flags); + else + fprintf (dump_file, ")\n\n"); }