/* Pretty formatting of GENERIC trees in C syntax.
- Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ Free Software Foundation, Inc.
Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
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
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
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
+#include "output.h"
#include "diagnostic.h"
#include "real.h"
#include "hashtab.h"
#include "tree-iterator.h"
#include "tree-chrec.h"
#include "tree-pass.h"
+#include "fixed-value.h"
+#include "value-prof.h"
+#include "predict.h"
/* Local functions, macros and variables. */
-static int op_prio (tree);
-static const char *op_symbol_1 (enum tree_code);
-static const char *op_symbol (tree);
+static int op_prio (const_tree);
+static const char *op_symbol (const_tree);
static void pretty_print_string (pretty_printer *, const char*);
-static void print_call_name (pretty_printer *, tree);
+static void print_call_name (pretty_printer *, const_tree);
static void newline_and_indent (pretty_printer *, int);
static void maybe_init_pretty_print (FILE *);
static void print_declaration (pretty_printer *, tree, int, int);
-static void print_struct_decl (pretty_printer *, tree, int, int);
-static void do_niy (pretty_printer *, tree);
+static void print_struct_decl (pretty_printer *, const_tree, int, int);
+static void do_niy (pretty_printer *, const_tree);
static void dump_vops (pretty_printer *, tree, int, int);
static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
/* 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;
if (EXPR_P (node))
{
- len = TREE_CODE_LENGTH (TREE_CODE (node));
+ len = TREE_OPERAND_LENGTH (node);
for (i = 0; i < len; ++i)
{
newline_and_indent (buffer, 2);
pp_string (buffer, " >>>\n");
}
+/* Debugging function to print out a generic expression. */
+
void
debug_generic_expr (tree t)
{
- print_generic_expr (stderr, t, TDF_VOPS|TDF_UID);
+ print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
fprintf (stderr, "\n");
}
+/* Debugging function to print out a generic statement. */
+
void
debug_generic_stmt (tree t)
{
- print_generic_stmt (stderr, t, TDF_VOPS|TDF_UID);
+ print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
fprintf (stderr, "\n");
}
+/* Debugging function to print out a chain of trees . */
+
void
debug_tree_chain (tree t)
{
- print_generic_expr (stderr, t, TDF_VOPS|TDF_UID|TDF_CHAIN);
+ while (t)
+ {
+ print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
+ fprintf(stderr, " ");
+ t = TREE_CHAIN (t);
+ }
fprintf (stderr, "\n");
}
}
/* 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)
{
tree t = node;
- while (t)
+ if (DECL_NAME (t))
+ pp_tree_identifier (buffer, DECL_NAME (t));
+ if ((flags & TDF_UID)
+ || DECL_NAME (t) == NULL_TREE)
{
- if (DECL_NAME (t))
- pp_tree_identifier (buffer, DECL_NAME (t));
-
- if ((flags & TDF_UID)
- || DECL_NAME (t) == 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));
- else
- {
- char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
- pp_printf (buffer, "%c.%u", c, DECL_UID (t));
- }
- }
-
- if (flags & TDF_CHAIN)
+ if (TREE_CODE (t) == LABEL_DECL
+ && LABEL_DECL_UID (t) != -1)
+ pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (t));
+ else
{
- t = TREE_CHAIN (t);
- pp_string (buffer, " ");
+ char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
+ pp_printf (buffer, "%c.%u", c, DECL_UID (t));
}
- else
- t = NULL_TREE;
}
}
pp_character (buffer, ']');
}
-/* Dump the list of OpenMP clauses. */
+
+/* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
+ dump_generic_node. */
static void
-dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
+dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
{
const char *name;
- if (clause == NULL)
- return;
-
- pp_space (buffer);
- while (1)
+ switch (OMP_CLAUSE_CODE (clause))
{
- switch (TREE_CODE (clause))
- {
- case OMP_CLAUSE_PRIVATE:
- name = "private";
- goto print_remap;
- case OMP_CLAUSE_SHARED:
- name = "shared";
- goto print_remap;
- case OMP_CLAUSE_FIRSTPRIVATE:
- name = "firstprivate";
- goto print_remap;
- case OMP_CLAUSE_LASTPRIVATE:
- name = "lastprivate";
- goto print_remap;
- case OMP_CLAUSE_COPYIN:
- name = "copyin";
- goto print_remap;
- case OMP_CLAUSE_COPYPRIVATE:
- name = "copyprivate";
- goto print_remap;
- print_remap:
- pp_string (buffer, name);
- pp_character (buffer, '(');
- dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
- spc, flags, false);
- pp_character (buffer, ')');
- break;
-
- case OMP_CLAUSE_REDUCTION:
- pp_string (buffer, "reduction(");
- pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause)));
- pp_character (buffer, ':');
- dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
- spc, flags, false);
- pp_character (buffer, ')');
- break;
+ case OMP_CLAUSE_PRIVATE:
+ name = "private";
+ goto print_remap;
+ case OMP_CLAUSE_SHARED:
+ name = "shared";
+ goto print_remap;
+ case OMP_CLAUSE_FIRSTPRIVATE:
+ name = "firstprivate";
+ goto print_remap;
+ case OMP_CLAUSE_LASTPRIVATE:
+ name = "lastprivate";
+ goto print_remap;
+ case OMP_CLAUSE_COPYIN:
+ name = "copyin";
+ goto print_remap;
+ case OMP_CLAUSE_COPYPRIVATE:
+ name = "copyprivate";
+ goto print_remap;
+ print_remap:
+ pp_string (buffer, name);
+ pp_character (buffer, '(');
+ dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
+ spc, flags, false);
+ pp_character (buffer, ')');
+ break;
- case OMP_CLAUSE_IF:
- pp_string (buffer, "if(");
- dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
- spc, flags, false);
- pp_character (buffer, ')');
- break;
+ case OMP_CLAUSE_REDUCTION:
+ pp_string (buffer, "reduction(");
+ 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);
+ pp_character (buffer, ')');
+ break;
- case OMP_CLAUSE_NUM_THREADS:
- pp_string (buffer, "num_threads(");
- dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
- spc, flags, false);
- pp_character (buffer, ')');
- break;
+ case OMP_CLAUSE_IF:
+ pp_string (buffer, "if(");
+ dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
+ spc, flags, false);
+ pp_character (buffer, ')');
+ break;
- case OMP_CLAUSE_NOWAIT:
- pp_string (buffer, "nowait");
- break;
- case OMP_CLAUSE_ORDERED:
- pp_string (buffer, "ordered");
- break;
+ case OMP_CLAUSE_NUM_THREADS:
+ pp_string (buffer, "num_threads(");
+ dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
+ spc, flags, false);
+ pp_character (buffer, ')');
+ break;
- case OMP_CLAUSE_DEFAULT:
- 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 ();
- }
- pp_character (buffer, ')');
- break;
+ case OMP_CLAUSE_NOWAIT:
+ pp_string (buffer, "nowait");
+ break;
+ case OMP_CLAUSE_ORDERED:
+ pp_string (buffer, "ordered");
+ break;
- case OMP_CLAUSE_SCHEDULE:
- pp_string (buffer, "schedule(");
- switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
- {
- case OMP_CLAUSE_SCHEDULE_STATIC:
- pp_string (buffer, "static");
- break;
- case OMP_CLAUSE_SCHEDULE_DYNAMIC:
- pp_string (buffer, "dynamic");
- break;
- case OMP_CLAUSE_SCHEDULE_GUIDED:
- pp_string (buffer, "guided");
- break;
- case OMP_CLAUSE_SCHEDULE_RUNTIME:
- pp_string (buffer, "runtime");
- break;
- default:
- gcc_unreachable ();
- }
- if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
- {
- pp_character (buffer, ',');
- dump_generic_node (buffer,
- OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
- spc, flags, false);
- }
- pp_character (buffer, ')');
- break;
+ case OMP_CLAUSE_DEFAULT:
+ 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 ();
+ }
+ pp_character (buffer, ')');
+ break;
- default:
- /* Should never happen. */
- dump_generic_node (buffer, clause, spc, flags, false);
- break;
+ case OMP_CLAUSE_SCHEDULE:
+ pp_string (buffer, "schedule(");
+ switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
+ {
+ case OMP_CLAUSE_SCHEDULE_STATIC:
+ pp_string (buffer, "static");
+ break;
+ case OMP_CLAUSE_SCHEDULE_DYNAMIC:
+ pp_string (buffer, "dynamic");
+ break;
+ case OMP_CLAUSE_SCHEDULE_GUIDED:
+ pp_string (buffer, "guided");
+ break;
+ case OMP_CLAUSE_SCHEDULE_RUNTIME:
+ pp_string (buffer, "runtime");
+ break;
+ default:
+ gcc_unreachable ();
}
+ if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
+ {
+ pp_character (buffer, ',');
+ dump_generic_node (buffer,
+ OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
+ spc, flags, false);
+ }
+ pp_character (buffer, ')');
+ break;
+
+ default:
+ /* Should never happen. */
+ dump_generic_node (buffer, clause, spc, flags, false);
+ break;
+ }
+}
+
+
+/* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
+ dump_generic_node. */
+static void
+dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
+{
+ if (clause == NULL)
+ return;
+
+ pp_space (buffer);
+ while (1)
+ {
+ dump_omp_clause (buffer, clause, spc, flags);
clause = OMP_CLAUSE_CHAIN (clause);
if (clause == NULL)
return;
}
}
+
+/* Dump the set of decls SYMS. BUFFER, SPC and FLAGS are as in
+ dump_generic_node. */
+
+static void
+dump_symbols (pretty_printer *buffer, bitmap syms, int flags)
+{
+ unsigned i;
+ bitmap_iterator bi;
+
+ if (syms == NULL)
+ pp_string (buffer, "NIL");
+ else
+ {
+ pp_string (buffer, " { ");
+
+ EXECUTE_IF_SET_IN_BITMAP (syms, 0, i, bi)
+ {
+ tree sym = referenced_var_lookup (i);
+ dump_generic_node (buffer, sym, 0, flags, false);
+ pp_string (buffer, " ");
+ }
+
+ pp_string (buffer, "}");
+ }
+}
+
+
/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
- FLAGS specifies details to show in the dump (see TDF_* in tree.h). If
- IS_STMT is true, the object printed is considered to be a statement
+ 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
if (node == NULL_TREE)
return spc;
- is_expr = EXPR_P (node);
+ 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)
- && stmt_ann (node)
+ && (flags & (TDF_VOPS|TDF_MEMSYMS))
+ && has_stmt_ann (node)
&& TREE_CODE (node) != PHI_NODE)
dump_vops (buffer, node, spc, 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:
- case CHAR_TYPE:
{
unsigned int quals = TYPE_QUALS (node);
enum tree_code_class class;
dump_generic_node (buffer, TREE_TYPE (node),
spc, flags, false);
}
+ else if (TREE_CODE (node) == INTEGER_TYPE)
+ {
+ pp_string (buffer, (TYPE_UNSIGNED (node)
+ ? "<unnamed-unsigned:"
+ : "<unnamed-signed:"));
+ pp_decimal_int (buffer, TYPE_PRECISION (node));
+ pp_string (buffer, ">");
+ }
else
pp_string (buffer, "<unnamed type>");
}
if (quals & TYPE_QUAL_CONST)
pp_string (buffer, " const");
- else if (quals & TYPE_QUAL_VOLATILE)
- pp_string (buffer, "volatile");
- else if (quals & TYPE_QUAL_RESTRICT)
+ if (quals & TYPE_QUAL_VOLATILE)
+ pp_string (buffer, " volatile");
+ if (quals & TYPE_QUAL_RESTRICT)
pp_string (buffer, " restrict");
if (TYPE_REF_CAN_ALIAS_ALL (node))
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
- /* Print the name of the structure. */
- if (TREE_CODE (node) == RECORD_TYPE)
- pp_string (buffer, "struct ");
- else if (TREE_CODE (node) == UNION_TYPE)
- pp_string (buffer, "union ");
+ {
+ unsigned int quals = TYPE_QUALS (node);
- if (TYPE_NAME (node))
- dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
- else
- print_struct_decl (buffer, node, spc, flags);
- break;
+ if (quals & TYPE_QUAL_CONST)
+ pp_string (buffer, "const ");
+ if (quals & TYPE_QUAL_VOLATILE)
+ pp_string (buffer, "volatile ");
+
+ /* Print the name of the structure. */
+ if (TREE_CODE (node) == RECORD_TYPE)
+ pp_string (buffer, "struct ");
+ else if (TREE_CODE (node) == UNION_TYPE)
+ pp_string (buffer, "union ");
+
+ if (TYPE_NAME (node))
+ dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
+ else
+ print_struct_decl (buffer, node, spc, flags);
+ break;
+ }
case LANG_TYPE:
NIY;
else if (! host_integerp (node, 0))
{
tree val = node;
+ unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
+ HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
if (tree_int_cst_sgn (val) < 0)
{
pp_character (buffer, '-');
- val = build_int_cst_wide (NULL_TREE,
- -TREE_INT_CST_LOW (val),
- ~TREE_INT_CST_HIGH (val)
- + !TREE_INT_CST_LOW (val));
+ high = ~high + !low;
+ low = -low;
}
/* Would "%x%0*x" or "%x%*0x" get zero-padding on all
systems? */
- {
- static char format[10]; /* "%x%09999x\0" */
- if (!format[0])
- sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
- sprintf (pp_buffer (buffer)->digit_buffer, format,
- TREE_INT_CST_HIGH (val),
- TREE_INT_CST_LOW (val));
- pp_string (buffer, pp_buffer (buffer)->digit_buffer);
- }
+ sprintf (pp_buffer (buffer)->digit_buffer,
+ HOST_WIDE_INT_PRINT_DOUBLE_HEX, high, low);
+ pp_string (buffer, pp_buffer (buffer)->digit_buffer);
}
else
pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
#if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
d = TREE_REAL_CST (node);
if (REAL_VALUE_ISINF (d))
- pp_string (buffer, " Inf");
+ pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
else if (REAL_VALUE_ISNAN (d))
pp_string (buffer, " Nan");
else
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);
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));
+ pp_printf (buffer, "<D.%u>", DECL_UID (node));
break;
case TYPE_DECL:
}
break;
- case TYPE_MEMORY_TAG:
+ case SYMBOL_MEMORY_TAG:
case NAME_MEMORY_TAG:
case STRUCT_FIELD_TAG:
case VAR_DECL:
case PARM_DECL:
case FIELD_DECL:
case NAMESPACE_DECL:
+ case MEMORY_PARTITION_TAG:
dump_decl_name (buffer, node, flags);
break;
op1 = array_ref_element_size (node);
if (!integer_zerop (op0)
- || (TYPE_SIZE_UNIT (TREE_TYPE (node))
- && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
+ || TREE_OPERAND (node, 2)
+ || TREE_OPERAND (node, 3))
{
pp_string (buffer, "{lb: ");
dump_generic_node (buffer, op0, spc, flags, false);
break;
case MODIFY_EXPR:
+ case GIMPLE_MODIFY_STMT:
case INIT_EXPR:
- dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
+ false);
pp_space (buffer);
pp_character (buffer, '=');
+ if (TREE_CODE (node) == GIMPLE_MODIFY_STMT
+ && MOVE_NONTEMPORAL (node))
+ pp_string (buffer, "{nt}");
+ if (TREE_CODE (node) == GIMPLE_MODIFY_STMT)
+ {
+ stmt_ann_t ann;
+ if ((ann = stmt_ann (node))
+ && ann->has_volatile_ops)
+ pp_string (buffer, "{v}");
+ }
pp_space (buffer);
- dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
+ false);
break;
case TARGET_EXPR:
|| TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
{
pp_space (buffer);
- dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
- pp_string (buffer, " else ");
- dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
+ dump_generic_node (buffer, COND_EXPR_THEN (node),
+ 0, flags, true);
+ if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
+ {
+ pp_string (buffer, " else ");
+ dump_generic_node (buffer, COND_EXPR_ELSE (node),
+ 0, flags, true);
+ }
}
else if (!(flags & TDF_SLIM))
{
}
/* Output COND_EXPR_ELSE. */
- if (COND_EXPR_ELSE (node))
+ if (COND_EXPR_ELSE (node)
+ && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
{
newline_and_indent (buffer, spc);
pp_string (buffer, "else");
/* Print parameters. */
pp_space (buffer);
pp_character (buffer, '(');
- op1 = TREE_OPERAND (node, 1);
- if (op1)
- dump_generic_node (buffer, op1, spc, flags, false);
+ {
+ tree arg;
+ call_expr_arg_iterator iter;
+ FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
+ {
+ dump_generic_node (buffer, arg, spc, flags, false);
+ if (more_call_expr_args_p (&iter))
+ {
+ pp_character (buffer, ',');
+ pp_space (buffer);
+ }
+ }
+ }
+ if (CALL_EXPR_VA_ARG_PACK (node))
+ {
+ if (call_expr_nargs (node) > 0)
+ {
+ pp_character (buffer, ',');
+ pp_space (buffer);
+ }
+ pp_string (buffer, "__builtin_va_arg_pack ()");
+ }
pp_character (buffer, ')');
- op1 = TREE_OPERAND (node, 2);
+ op1 = CALL_EXPR_STATIC_CHAIN (node);
if (op1)
{
pp_string (buffer, " [static-chain: ");
break;
/* Binary arithmetic and logic expressions. */
+ case WIDEN_SUM_EXPR:
+ 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:
/* When the operands are expressions with less priority,
keep semantics of the tree representation. */
- if (op_prio (op0) < op_prio (node))
+ if (op_prio (op0) <= op_prio (node))
{
pp_character (buffer, '(');
dump_generic_node (buffer, op0, spc, flags, false);
/* When the operands are expressions with less priority,
keep semantics of the tree representation. */
- if (op_prio (op1) < op_prio (node))
+ if (op_prio (op1) <= op_prio (node))
{
pp_character (buffer, '(');
dump_generic_node (buffer, op1, spc, flags, false);
NIY;
break;
+ case FIXED_CONVERT_EXPR:
case FIX_TRUNC_EXPR:
- case FIX_CEIL_EXPR:
- case FIX_FLOOR_EXPR:
- case FIX_ROUND_EXPR:
case FLOAT_EXPR:
case CONVERT_EXPR:
case NOP_EXPR:
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. */
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)
- dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
+ if (TREE_CODE (op0) == MODIFY_EXPR
+ || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
+ dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
+ spc, flags, false);
else
dump_generic_node (buffer, op0, spc, flags, false);
}
break;
case RESX_EXPR:
- pp_string (buffer, "resx");
- /* ??? Any sensible way to present the eh region? */
+ pp_string (buffer, "resx ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
break;
case ASM_EXPR:
if (i < PHI_NUM_ARGS (node) - 1)
pp_string (buffer, ", ");
}
- pp_string (buffer, ">;");
+ pp_string (buffer, ">");
+
+ if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS))
+ dump_symbols (buffer, STORED_SYMS (node), flags);
}
break;
pp_decimal_int (buffer, SSA_NAME_VERSION (node));
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
pp_string (buffer, "(ab)");
+ else if (SSA_NAME_IS_DEFAULT_DEF (node))
+ pp_string (buffer, "(D)");
break;
case WITH_SIZE_EXPR:
pp_string (buffer, " > ");
break;
+ case DOT_PROD_EXPR:
+ pp_string (buffer, " DOT_PROD_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
case OMP_PARALLEL:
pp_string (buffer, "#pragma omp parallel");
dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
+ if (OMP_PARALLEL_FN (node))
+ {
+ pp_string (buffer, " [child fn: ");
+ dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
+
+ pp_string (buffer, " (");
+
+ if (OMP_PARALLEL_DATA_ARG (node))
+ dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
+ false);
+ else
+ pp_string (buffer, "???");
+
+ pp_string (buffer, ")]");
+ }
dump_omp_body:
if (!(flags & TDF_SLIM) && OMP_BODY (node))
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;
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
break;
+ case OMP_ATOMIC_LOAD:
+ pp_string (buffer, "#pragma omp atomic_load");
+ 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);
+ pp_character (buffer, '*');
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ break;
+
+ case OMP_ATOMIC_STORE:
+ pp_string (buffer, "#pragma omp atomic_store (");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_character (buffer, ')');
+ 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 <");
+ 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, ">");
+ is_expr = false;
+ break;
+
+ case OMP_CLAUSE:
+ dump_omp_clause (buffer, node, spc, flags);
+ is_expr = false;
+ break;
+
case REDUC_MAX_EXPR:
pp_string (buffer, " REDUC_MAX_EXPR < ");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_string (buffer, " > ");
break;
+ case VEC_WIDEN_MULT_HI_EXPR:
+ pp_string (buffer, " VEC_WIDEN_MULT_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_MULT_LO_EXPR:
+ pp_string (buffer, " VEC_WIDEN_MULT_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 VEC_UNPACK_HI_EXPR:
+ pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_UNPACK_LO_EXPR:
+ pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_UNPACK_FLOAT_HI_EXPR:
+ pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_UNPACK_FLOAT_LO_EXPR:
+ pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_PACK_TRUNC_EXPR:
+ pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_PACK_SAT_EXPR:
+ pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_PACK_FIX_TRUNC_EXPR:
+ pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
case BLOCK:
{
tree t;
}
break;
+ case VEC_EXTRACT_EVEN_EXPR:
+ pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_EXTRACT_ODD_EXPR:
+ pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_INTERLEAVE_HIGH_EXPR:
+ pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_INTERLEAVE_LOW_EXPR:
+ pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
default:
NIY;
}
if (is_stmt && is_expr)
pp_semicolon (buffer);
- pp_write_text_to_stream (buffer);
+
+ /* If we're building a diagnostic, the formatted text will be written
+ into BUFFER's stream by the caller; otherwise, write it now. */
+ if (!(flags & TDF_DIAGNOSTIC))
+ pp_write_text_to_stream (buffer);
return spc;
}
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))
operators. */
static int
-op_prio (tree op)
+op_prio (const_tree op)
{
if (op == NULL)
return 9999;
return 1;
case MODIFY_EXPR:
+ case GIMPLE_MODIFY_STMT:
case INIT_EXPR:
return 2;
case RROTATE_EXPR:
return 11;
+ case WIDEN_SUM_EXPR:
case PLUS_EXPR:
+ case POINTER_PLUS_EXPR:
case MINUS_EXPR:
return 12;
+ case VEC_WIDEN_MULT_HI_EXPR:
+ case VEC_WIDEN_MULT_LO_EXPR:
+ case WIDEN_MULT_EXPR:
+ case DOT_PROD_EXPR:
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case CEIL_DIV_EXPR:
case NOP_EXPR:
case CONVERT_EXPR:
case FIX_TRUNC_EXPR:
- case FIX_CEIL_EXPR:
- case FIX_FLOOR_EXPR:
- case FIX_ROUND_EXPR:
case TARGET_EXPR:
return 14;
case REDUC_PLUS_EXPR:
case VEC_LSHIFT_EXPR:
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:
}
-/* Return the symbol associated with operator OP. */
+/* Return the symbol associated with operator CODE. */
-static const char *
-op_symbol_1 (enum tree_code code)
+const char *
+op_symbol_code (enum tree_code code)
{
switch (code)
{
case MODIFY_EXPR:
+ case GIMPLE_MODIFY_STMT:
return "=";
case TRUTH_OR_EXPR:
case VEC_RSHIFT_EXPR:
return "v>>";
+
+ case POINTER_PLUS_EXPR:
+ return "+";
case PLUS_EXPR:
return "+";
case REDUC_PLUS_EXPR:
return "r+";
+ case WIDEN_SUM_EXPR:
+ return "w+";
+
+ case WIDEN_MULT_EXPR:
+ return "w*";
+
case NEGATE_EXPR:
case MINUS_EXPR:
return "-";
}
}
+/* Return the symbol associated with operator OP. */
+
static const char *
-op_symbol (tree op)
+op_symbol (const_tree op)
{
- return op_symbol_1 (TREE_CODE (op));
+ return op_symbol_code (TREE_CODE (op));
}
/* Prints the name of a CALL_EXPR. */
static void
-print_call_name (pretty_printer *buffer, tree node)
+print_call_name (pretty_printer *buffer, const_tree node)
{
tree op0;
gcc_assert (TREE_CODE (node) == CALL_EXPR);
- op0 = TREE_OPERAND (node, 0);
+ op0 = CALL_EXPR_FN (node);
if (TREE_CODE (op0) == NON_LVALUE_EXPR)
op0 = TREE_OPERAND (op0, 0);
pp_string (buffer, "\\'");
break;
- case '\0':
- pp_string (buffer, "\\0");
- break;
+ /* No need to handle \0; the loop terminates on \0. */
case '\1':
pp_string (buffer, "\\1");
INDENT (spc);
}
+
static void
dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
{
- tree use;
- use_operand_p use_p;
- def_operand_p def_p;
- use_operand_p kill_p;
- ssa_op_iter iter;
+ struct voptype_d *vdefs;
+ struct voptype_d *vuses;
+ int i, n;
- if (!ssa_operands_active ())
+ if (!ssa_operands_active () || !stmt_references_memory_p (stmt))
return;
- FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
+ /* 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)
{
- pp_string (buffer, "# ");
- dump_generic_node (buffer, DEF_FROM_PTR (def_p),
- spc + 2, flags, false);
- pp_string (buffer, " = V_MAY_DEF <");
- dump_generic_node (buffer, USE_FROM_PTR (use_p),
- spc + 2, flags, false);
- pp_string (buffer, ">;");
- newline_and_indent (buffer, spc);
+ 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;
}
- FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)
+ vuses = VUSE_OPS (stmt);
+ while (vuses)
{
- pp_string (buffer, "# ");
- dump_generic_node (buffer, DEF_FROM_PTR (def_p),
- spc + 2, flags, false);
- pp_string (buffer, " = V_MUST_DEF <");
- dump_generic_node (buffer, USE_FROM_PTR (kill_p),
- spc + 2, flags, false);
- pp_string (buffer, ">;");
+ 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;
}
- FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
+ vdefs = VDEF_OPS (stmt);
+ while (vdefs)
{
- pp_string (buffer, "# VUSE <");
- dump_generic_node (buffer, use, spc + 2, flags, false);
- pp_string (buffer, ">;");
+ pp_string (buffer, "# ");
+ dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
+ pp_string (buffer, " = VDEF <");
+
+ n = VDEF_NUM (vdefs);
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+
+ pp_string (buffer, ">");
+
+ if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
+ dump_symbols (buffer, STORED_SYMS (stmt), flags);
+
newline_and_indent (buffer, spc);
+ vdefs = vdefs->next;
}
}
+
/* Dumps basic block BB to FILE with details described by FLAGS and
indented by INDENT spaces. */
pp_newline (buffer);
}
-/* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
- FLAGS indented by INDENT spaces. */
+/* 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)
}
}
+
/* Dump jump to basic block BB that is represented implicitly in the cfg
to BUFFER. */
{
edge e;
edge_iterator ei;
+ tree stmt;
+
+ 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. */
{
INDENT (indent);
- if ((flags & TDF_LINENO)
-#ifdef USE_MAPPED_LOCATION
- && e->goto_locus != UNKNOWN_LOCATION
-#else
- && e->goto_locus
-#endif
- )
+ if ((flags & TDF_LINENO) && e->goto_locus != UNKNOWN_LOCATION)
{
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)
{
INDENT (curr_indent);
dump_generic_node (buffer, stmt, curr_indent, flags, true);
pp_newline (buffer);
+ dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
}
dump_implicit_edges (buffer, bb, indent, flags);