/* 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 <dnovillo@redhat.com>
This file is part of GCC.
#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"
#include "tree-iterator.h"
#include "tree-chrec.h"
#include "tree-pass.h"
-#include "fixed-value.h"
#include "value-prof.h"
+#include "predict.h"
/* Local functions, macros and variables. */
-static int op_prio (const_tree);
-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<SPACE; i++) pp_space (buffer); } while (0)
#define NIY do_niy(buffer,node)
-#define PRINT_FUNCTION_NAME(NODE) pp_printf \
- (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
- lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
- lang_hooks.decl_printable_name (NODE, 1))
-
static pretty_printer buffer;
static int initialized = 0;
/* Try to print something for an unknown tree code. */
static void
-do_niy (pretty_printer *buffer, tree node)
+do_niy (pretty_printer *buffer, const_tree node)
{
int i, len;
}
}
- pp_string (buffer, " >>>\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. */
}
/* 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)
}
/* 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
}
/* 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)
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
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, ')');
}
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;
case OMP_CLAUSE_SCHEDULE_RUNTIME:
pp_string (buffer, "runtime");
break;
+ case OMP_CLAUSE_SCHEDULE_AUTO:
+ pp_string (buffer, "auto");
+ break;
default:
gcc_unreachable ();
}
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);
/* 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)
}
-/* 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,
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))
{
case TREE_BINFO:
dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
+ break;
case TREE_VEC:
{
{
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);
}
}
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 ");
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, "<address-space-");
+ pp_decimal_int (buffer, 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, "<unnamed type decl>");
}
- else if (class == tcc_type)
+ else if (tclass == tcc_type)
{
if (TYPE_NAME (node))
{
}
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_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, "<float:");
+ pp_decimal_int (buffer, TYPE_PRECISION (node));
+ pp_string (buffer, ">");
+ }
+ else if (TREE_CODE (node) == FIXED_POINT_TYPE)
+ {
+ pp_string (buffer, "<fixed-point-");
+ pp_string (buffer, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
+ pp_decimal_int (buffer, TYPE_PRECISION (node));
+ pp_string (buffer, ">");
+ }
+ else if (TREE_CODE (node) == VOID_TYPE)
+ pp_string (buffer, "void");
else
pp_string (buffer, "<unnamed type>");
}
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, "<null type>");
+ }
+ else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
{
tree fnode = TREE_TYPE (node);
pp_string (buffer, str);
if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
dump_decl_name (buffer, TYPE_NAME (node), flags);
+ else if (flags & TDF_NOUID)
+ pp_printf (buffer, "<Txxxx>");
else
pp_printf (buffer, "<T%x>", TYPE_UID (node));
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, " <address-space-");
+ pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));
+ pp_string (buffer, ">");
+ }
+
if (TYPE_REF_CAN_ALIAS_ALL (node))
pp_string (buffer, " {ref-all}");
}
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:
{
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);
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;
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;
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);
/* 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:
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, "<null method basetype>");
+ 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, "<Txxxx>");
+ else
+ pp_printf (buffer, "<T%x>", TYPE_UID (node));
+ dump_function_declaration (buffer, node, spc, flags);
break;
case FUNCTION_DECL:
if (DECL_NAME (node))
dump_decl_name (buffer, node, flags);
else if (LABEL_DECL_UID (node) != -1)
- pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
- LABEL_DECL_UID (node));
+ pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
else
- pp_printf (buffer, "<D%u>", DECL_UID (node));
+ {
+ if (flags & TDF_NOUID)
+ pp_string (buffer, "<D.xxxx>");
+ else
+ pp_printf (buffer, "<D.%u>", DECL_UID (node));
+ }
break;
case TYPE_DECL:
}
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)
dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
}
}
+ else
+ pp_string (buffer, "<anon>");
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;
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 = "->";
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;
{
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;
+ 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);
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) == GIMPLE_MODIFY_STMT
+ 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;
{
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);
break;
case CALL_EXPR:
- print_call_name (buffer, node);
+ print_call_name (buffer, CALL_EXPR_FN (node), flags);
/* Print parameters. */
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 = CALL_EXPR_STATIC_CHAIN (node);
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
}
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:
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))
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);
is_expr = false;
break;
- case CHANGE_DYNAMIC_TYPE_EXPR:
- pp_string (buffer, "<<<change_dynamic_type (");
- dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_NEW_TYPE (node), spc + 2,
- flags, false);
- pp_string (buffer, ") ");
- dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_LOCATION (node), spc + 2,
- flags, false);
- pp_string (buffer, ")>>>");
- is_expr = false;
- break;
-
case LABEL_EXPR:
op0 = TREE_OPERAND (node, 0);
/* If this is for break or continue, don't bother printing it. */
pp_string (buffer, " [non-local]");
break;
- case EXC_PTR_EXPR:
- pp_string (buffer, "<<<exception object>>>");
- break;
-
- case FILTER_EXPR:
- pp_string (buffer, "<<<filter object>>>");
- break;
-
case LOOP_EXPR:
pp_string (buffer, "while (1)");
if (!(flags & TDF_SLIM))
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);
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))
dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
}
else
- pp_string (buffer, "default ");
+ pp_string (buffer, "default");
pp_character (buffer, ':');
break;
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, "_");
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);
dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
pp_string (buffer, ">");
break;
-
+
case VEC_COND_EXPR:
pp_string (buffer, " VEC_COND_EXPR < ");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_string (buffer, " > ");
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))
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);
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);
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;
case OMP_SECTIONS:
pp_string (buffer, "#pragma omp sections");
- if (OMP_SECTIONS_CONTROL (node))
- {
- pp_string (buffer, " <");
- dump_generic_node (buffer, OMP_SECTIONS_CONTROL (node), spc,
- flags, false);
- pp_string (buffer, ">");
- }
dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
goto dump_omp_body;
- case OMP_SECTIONS_SWITCH:
- pp_string (buffer, "OMP_SECTIONS_SWITCH");
- is_expr = false;
- break;
-
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;
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;
+ 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_CONTINUE:
- pp_string (buffer, "OMP_CONTINUE <");
+ 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_string (buffer, " <- ");
+ pp_space (buffer);
+ pp_character (buffer, '=');
+ pp_space (buffer);
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
- pp_string (buffer, ">");
- is_expr = 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_CLAUSE:
dump_omp_clause (buffer, node, spc, flags);
is_expr = false;
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;
+ dump_block_node (buffer, node, spc, flags);
+ break;
case VEC_EXTRACT_EVEN_EXPR:
pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
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 < ");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
/* Print the declaration of a variable. */
-static void
+void
print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
{
INDENT (spc);
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;
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)
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))
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]:
unary +, - and * have higher precedence than the corresponding binary
operators. */
-static int
-op_prio (const_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:
return 1;
case MODIFY_EXPR:
- case GIMPLE_MODIFY_STMT:
case INIT_EXPR:
return 2;
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:
case CEIL_MOD_EXPR:
case FLOOR_MOD_EXPR:
case ROUND_MOD_EXPR:
+ case FMA_EXPR:
return 13;
case TRUTH_NOT_EXPR:
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;
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. */
}
}
+/* Return the priority of the operator OP. */
+
+int
+op_prio (const_tree op)
+{
+ 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. */
switch (code)
{
case MODIFY_EXPR:
- case GIMPLE_MODIFY_STMT:
return "=";
case TRUTH_OR_EXPR:
case POINTER_PLUS_EXPR:
return "+";
-
+
case PLUS_EXPR:
return "+";
case INDIRECT_REF:
return "*";
- case ALIGN_INDIRECT_REF:
- return "A*";
-
- case MISALIGNED_INDIRECT_REF:
- return "M*";
-
case TRUNC_DIV_EXPR:
case RDIV_EXPR:
return "/";
/* Return the symbol associated with operator OP. */
static const char *
-op_symbol (tree op)
+op_symbol (const_tree 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:
{
pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
pp_needs_newline (&buffer) = true;
+ pp_translate_identifiers (&buffer) = false;
initialized = 1;
}
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)
- {
- if (LOADED_SYMS (stmt))
- {
- pp_string (buffer, "# LOADS: ");
- dump_symbols (buffer, LOADED_SYMS (stmt), flags);
- newline_and_indent (buffer, spc);
- }
-
- if (STORED_SYMS (stmt))
- {
- pp_string (buffer, "# STORES: ");
- dump_symbols (buffer, STORED_SYMS (stmt), flags);
- newline_and_indent (buffer, spc);
- }
-
- return;
- }
-
- vuses = VUSE_OPS (stmt);
- while (vuses)
+ 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))
{
- pp_string (buffer, "# VUSE <");
+ tree ao = BLOCK_ABSTRACT_ORIGIN (block);
- 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;
- }
+ while (TREE_CODE (ao) == BLOCK
+ && BLOCK_ABSTRACT_ORIGIN (ao)
+ && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
+ ao = BLOCK_ABSTRACT_ORIGIN (ao);
- 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, "<bb ");
- pp_decimal_int (buffer, bb->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 <bb ");
- pp_decimal_int (buffer, bb->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);
+ pp_append_text (pp, IDENTIFIER_POINTER (id),
+ IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
}
-/* 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;
- tree stmt;
+/* A helper function that is used to dump function information before the
+ function dump. */
- stmt = last_stmt (bb);
- if (stmt && TREE_CODE (stmt) == COND_EXPR)
- {
- edge true_edge, false_edge;
-
- /* When we are emitting the code or changing CFG, it is possible that
- the edges are not yet created. When we are using debug_bb in such
- a situation, we do not want it to crash. */
- if (EDGE_COUNT (bb->succs) != 2)
- return;
- extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
-
- INDENT (indent + 2);
- pp_cfg_jump (buffer, true_edge->dest);
- newline_and_indent (buffer, indent);
- pp_string (buffer, "else");
- newline_and_indent (buffer, indent + 2);
- pp_cfg_jump (buffer, false_edge->dest);
- pp_newline (buffer);
- return;
- }
-
- /* If there is a fallthru edge, we may need to add an artificial goto to the
- dump. */
- FOR_EACH_EDGE (e, ei, bb->succs)
- if (e->flags & EDGE_FALLTHRU)
- break;
- if (e && e->dest != bb->next_bb)
- {
- INDENT (indent);
-
- if ((flags & TDF_LINENO)
-#ifdef USE_MAPPED_LOCATION
- && e->goto_locus != UNKNOWN_LOCATION
-#else
- && e->goto_locus
-#endif
- )
- {
- expanded_location goto_xloc;
-#ifdef USE_MAPPED_LOCATION
- goto_xloc = expand_location (e->goto_locus);
-#else
- goto_xloc = *e->goto_locus;
-#endif
- pp_character (buffer, '[');
- if (goto_xloc.file)
- {
- pp_string (buffer, goto_xloc.file);
- pp_string (buffer, " : ");
- }
- pp_decimal_int (buffer, goto_xloc.line);
- pp_string (buffer, "] ");
- }
-
- pp_cfg_jump (buffer, e->dest);
- pp_newline (buffer);
- }
-}
-
-/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
- indented by INDENT spaces. */
-
-static void
-dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
- int indent, int flags)
+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 = "<unset-asm-name>";
- 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");
}