+2012-07-20 Steven Bosscher <steven@gcc.gnu.org>
+
+ * basic-block.h (BB_FLAGS_TO_PRESERVE): New define.
+ (brief_dump_cfg): Update prototype to take flags argument.
+ (check_bb_profile): Remove prototype.
+ * tracer.c (tracer): Update brief_dump_cfg calls.
+ * cfghooks.c (dump_bb): Do not pass TDF_COMMENT to dump_bb_info.
+ Call dump_bb_info before and after the cfghook dump_bb. Terminate
+ the dump with a newline.
+ (dump_flow_info): Do not call check_bb_profile.
+ * cfg.c (clear_bb_flags): Update using BB_FLAGS_TO_PRESERVE.
+ (check_bb_profile): Make static. Take indent and flags arguments.
+ (dump_bb_info): Always dump loop depth. With TDF_DETAILS, call
+ check_bb_profile. Print one edge per line.
+ (brief_dump_cfg): Take a flags argument, and filter out
+ TDF_COMMENT and TDF_DETAILS.
+ * pretty-print.c (pp_base_newline): Set pp_needs_newline to false.
+ * gimple-pretty-print.c (dump_gimple_bb_header): Do not use dump_bb_info
+ here, it is already called from dump_bb. Idem for check_bb_profile.
+ (dump_gimple_bb_footer): Likewise.
+ (gimple_dump_bb_buff): Call pp_flush after dump_gimple_stmt to
+ avoid broken dumps for statement histograms.
+ (gimple_dump_bb): Handle ENTRY_BLOCK and EXIT_BLOCK. Do
+ not call pp_flush here, the buffer should be empty.
+ * sched-rgn.c (debug_region): Pass TDF_BLOCKS to dump_bb.
+ * sched-vis.c (debug_bb_slim): Likewise.
+ * tree-cfg.c (remove_bb): Pass dump_flags to dump_bb.
+ (gimple_debug_bb): Pass TDF_BLOCKS to dump_bb.
+ (gimple_dump_cfg): Do brief_dump_cfg with TDF_COMMENT.
+ (dump_function_to_file): Do not call check_bb_profile on
+ ENTRY_BLOCK and EXIT_BLOCK, check_bb_profile doesn't handle them.
+ Use dump_bb instead of gimple_dump_bb.
+ (print_loops_bb): Use dump_bb instead of gimple_dump_bb.
+ * passes.c (execute_function_dump): Always call print_rtl_with_bb
+ for RTL dumps.
+ * cfgrtl.c (print_rtl_with_bb): Handle printing without an up-to-date
+ CFG. With TDF_BLOCKS and TDF_DETAILS, do DF dumps at the top and bottom
+ of each basic block.
+
2012-07-20 Richard Guenther <rguenther@suse.de>
PR tree-optimization/54031
(flow_nodes_print): Remove.
(flow_edge_list_print): Remove.
(inverted_post_order_compute): Use FOR_ALL_BB.
- *cfgrtl.c (dump_flow_info): Moved from cfg.c.
+ * cfgrtl.c (dump_flow_info): Moved from cfg.c.
Do not call dump_reg_info.
(debug_flow_info): Moved from cfg.c
(dump_bb_info): Moved from cfg.c. Take 'verbose' argument
};
#undef DEF_BASIC_BLOCK_FLAG
-/* Bit mask for all edge flags. */
+/* Bit mask for all basic block flags. */
#define BB_ALL_FLAGS ((LAST_CFG_BB_FLAG - 1) * 2 - 1)
+/* Bit mask for all basic block flags that must be preserved. These are
+ the bit masks that are *not* cleared by clear_bb_flags. */
+#define BB_FLAGS_TO_PRESERVE \
+ (BB_DISABLE_SCHEDULE | BB_RTL | BB_NON_LOCAL_GOTO_TARGET \
+ | BB_HOT_PARTITION | BB_COLD_PARTITION)
+
/* Dummy bitmask for convenience in the hot/cold partitioning code. */
#define BB_UNPARTITIONED 0
extern void clear_bb_flags (void);
extern void dump_bb_info (FILE *, basic_block, int, int, bool, bool);
extern void dump_edge_info (FILE *, edge, int, int);
-extern void brief_dump_cfg (FILE *);
+extern void brief_dump_cfg (FILE *, int);
extern void clear_edges (void);
extern void scale_bbs_frequencies_int (basic_block *, int, int, int);
extern void scale_bbs_frequencies_gcov_type (basic_block *, int, gcov_type,
extern edge try_redirect_by_replacing_jump (edge, basic_block, bool);
extern void break_superblocks (void);
extern void relink_block_chain (bool);
-extern void check_bb_profile (basic_block, FILE *);
extern void update_bb_profile_for_threading (basic_block, int, gcov_type, edge);
extern void init_rtl_bb_info (basic_block);
DEF_BASIC_BLOCK_FLAG(VISITED, 13)
/* Set on blocks that are in a transaction. This is calculated on
- demand, and is available after calling
- compute_transaction_bits(). */
+ demand, and is available after calling compute_transaction_bits(). */
DEF_BASIC_BLOCK_FLAG(IN_TRANSACTION, 14)
#endif
connect_src (e);
}
-/* Clear all basic block flags, with the exception of partitioning and
- setjmp_target. */
+/* Clear all basic block flags that do not have to be preserved. */
void
clear_bb_flags (void)
{
basic_block bb;
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
- bb->flags = (BB_PARTITION (bb)
- | (bb->flags & (BB_DISABLE_SCHEDULE + BB_RTL + BB_NON_LOCAL_GOTO_TARGET)));
+ bb->flags &= BB_FLAGS_TO_PRESERVE;
}
\f
/* Check the consistency of profile information. We can't do that
solved graphs, later eliminating of conditionals or roundoff errors.
It is still practical to have them reported for debugging of simple
testcases. */
-void
-check_bb_profile (basic_block bb, FILE * file)
+static void
+check_bb_profile (basic_block bb, FILE * file, int indent, int flags)
{
edge e;
int sum = 0;
gcov_type lsum;
edge_iterator ei;
+ char *s_indent = (char *) alloca ((size_t) indent + 1);
+ memset ((void *) s_indent, ' ', (size_t) indent);
+ s_indent[indent] = '\0';
if (profile_status == PROFILE_ABSENT)
return;
FOR_EACH_EDGE (e, ei, bb->succs)
sum += e->probability;
if (EDGE_COUNT (bb->succs) && abs (sum - REG_BR_PROB_BASE) > 100)
- fprintf (file, "Invalid sum of outgoing probabilities %.1f%%\n",
+ fprintf (file, "%s%sInvalid sum of outgoing probabilities %.1f%%\n",
+ (flags & TDF_COMMENT) ? ";; " : "", s_indent,
sum * 100.0 / REG_BR_PROB_BASE);
lsum = 0;
FOR_EACH_EDGE (e, ei, bb->succs)
lsum += e->count;
if (EDGE_COUNT (bb->succs)
&& (lsum - bb->count > 100 || lsum - bb->count < -100))
- fprintf (file, "Invalid sum of outgoing counts %i, should be %i\n",
+ fprintf (file, "%s%sInvalid sum of outgoing counts %i, should be %i\n",
+ (flags & TDF_COMMENT) ? ";; " : "", s_indent,
(int) lsum, (int) bb->count);
}
if (bb != ENTRY_BLOCK_PTR)
sum += EDGE_FREQUENCY (e);
if (abs (sum - bb->frequency) > 100)
fprintf (file,
- "Invalid sum of incoming frequencies %i, should be %i\n",
+ "%s%sInvalid sum of incoming frequencies %i, should be %i\n",
+ (flags & TDF_COMMENT) ? ";; " : "", s_indent,
sum, bb->frequency);
lsum = 0;
FOR_EACH_EDGE (e, ei, bb->preds)
lsum += e->count;
if (lsum - bb->count > 100 || lsum - bb->count < -100)
- fprintf (file, "Invalid sum of incoming counts %i, should be %i\n",
+ fprintf (file, "%s%sInvalid sum of incoming counts %i, should be %i\n",
+ (flags & TDF_COMMENT) ? ";; " : "", s_indent,
(int) lsum, (int) bb->count);
}
}
#undef DEF_BASIC_BLOCK_FLAG
};
const unsigned n_bitnames = sizeof (bb_bitnames) / sizeof (char *);
+ bool first;
char *s_indent = (char *) alloca ((size_t) indent + 1);
memset ((void *) s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';
if (flags & TDF_COMMENT)
fputs (";; ", outf);
- fprintf (outf, "%sbasic block %d", s_indent, bb->index);
+ fprintf (outf, "%sbasic block %d, loop depth %d",
+ s_indent, bb->index, bb->loop_depth);
if (flags & TDF_DETAILS)
{
- fprintf (outf, ", loop depth %d, count " HOST_WIDEST_INT_PRINT_DEC,
- bb->loop_depth, (HOST_WIDEST_INT) bb->count);
+ fprintf (outf, ", count " HOST_WIDEST_INT_PRINT_DEC,
+ (HOST_WIDEST_INT) bb->count);
fprintf (outf, ", freq %i", bb->frequency);
if (maybe_hot_bb_p (bb))
fputs (", maybe hot", outf);
fputs (", probably never executed", outf);
}
fputc ('\n', outf);
+ if (TDF_DETAILS)
+ check_bb_profile (bb, outf, indent, flags);
if (flags & TDF_DETAILS)
{
- bool first = true;
-
if (flags & TDF_COMMENT)
fputs (";; ", outf);
fprintf (outf, "%s prev block ", s_indent);
fprintf (outf, "(nil)");
fputs (", flags:", outf);
+ first = true;
for (i = 0; i < n_bitnames; i++)
if (bb->flags & (1 << i))
{
}
if (!first)
fputc (')', outf);
+ fputc ('\n', outf);
}
- fputc ('\n', outf);
if (flags & TDF_COMMENT)
fputs (";; ", outf);
fprintf (outf, "%s pred: ", s_indent);
+ first = true;
FOR_EACH_EDGE (e, ei, bb->preds)
- dump_edge_info (outf, e, flags, 0);
- fputc ('\n', outf);
+ {
+ if (! first)
+ {
+ if (flags & TDF_COMMENT)
+ fputs (";; ", outf);
+ fprintf (outf, "%s ", s_indent);
+ }
+ first = false;
+ dump_edge_info (outf, e, flags, 0);
+ fputc ('\n', outf);
+ }
}
if (do_footer)
if (flags & TDF_COMMENT)
fputs (";; ", outf);
fprintf (outf, "%s succ: ", s_indent);
+ first = true;
FOR_EACH_EDGE (e, ei, bb->succs)
- dump_edge_info (outf, e, flags, 1);
- fputs ("\n\n", outf);
+ {
+ if (! first)
+ {
+ if (flags & TDF_COMMENT)
+ fputs (";; ", outf);
+ fprintf (outf, "%s ", s_indent);
+ }
+ first = false;
+ dump_edge_info (outf, e, flags, 1);
+ fputc ('\n', outf);
+ }
}
}
/* Dumps a brief description of cfg to FILE. */
void
-brief_dump_cfg (FILE *file)
+brief_dump_cfg (FILE *file, int flags)
{
basic_block bb;
FOR_EACH_BB (bb)
{
- dump_bb_info (file, bb, 0, 0, true, true);
+ dump_bb_info (file, bb, 0,
+ flags & (TDF_COMMENT | TDF_DETAILS),
+ true, true);
}
}
void
dump_bb (FILE *outf, basic_block bb, int indent, int flags)
{
- dump_bb_info (outf, bb, indent, flags | TDF_COMMENT, true, true);
+ dump_bb_info (outf, bb, indent, flags, true, false);
if (cfg_hooks->dump_bb)
cfg_hooks->dump_bb (outf, bb, indent, flags);
+ dump_bb_info (outf, bb, indent, flags, false, true);
+ fputc ('\n', outf);
}
/* Dump the complete CFG to FILE. FLAGS are the TDF_* flags in dumpfile.h. */
fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
FOR_ALL_BB (bb)
- {
- dump_bb (file, bb, 0, flags);
- check_bb_profile (bb, file);
- }
+ dump_bb (file, bb, 0, flags);
putc ('\n', file);
}
}
\f
-/* Like print_rtl, but also print out live information for the start of each
- basic block. FLAGS are the flags documented in dumpfile.h. */
+/* Like dump_function_to_file, but for RTL. Print out dataflow information
+ for the start of each basic block. FLAGS are the TDF_* masks documented
+ in dumpfile.h. */
void
print_rtl_with_bb (FILE *outf, const_rtx rtx_first, int flags)
basic_block *start = XCNEWVEC (basic_block, max_uid);
basic_block *end = XCNEWVEC (basic_block, max_uid);
enum bb_state *in_bb_p = XCNEWVEC (enum bb_state, max_uid);
-
basic_block bb;
+ /* After freeing the CFG, we still have BLOCK_FOR_INSN set on most
+ insns, but the CFG is not maintained so the basic block info
+ is not reliable. Therefore it's omitted from the dumps. */
+ if (! (cfun->curr_properties & PROP_cfg))
+ flags &= ~TDF_BLOCKS;
+
if (df)
df_dump_start (outf);
- FOR_EACH_BB_REVERSE (bb)
+ if (flags & TDF_BLOCKS)
{
- rtx x;
-
- start[INSN_UID (BB_HEAD (bb))] = bb;
- end[INSN_UID (BB_END (bb))] = bb;
- for (x = BB_HEAD (bb); x != NULL_RTX; x = NEXT_INSN (x))
+ FOR_EACH_BB_REVERSE (bb)
{
- enum bb_state state = IN_MULTIPLE_BB;
+ rtx x;
+
+ start[INSN_UID (BB_HEAD (bb))] = bb;
+ end[INSN_UID (BB_END (bb))] = bb;
+ for (x = BB_HEAD (bb); x != NULL_RTX; x = NEXT_INSN (x))
+ {
+ enum bb_state state = IN_MULTIPLE_BB;
- if (in_bb_p[INSN_UID (x)] == NOT_IN_BB)
- state = IN_ONE_BB;
- in_bb_p[INSN_UID (x)] = state;
+ if (in_bb_p[INSN_UID (x)] == NOT_IN_BB)
+ state = IN_ONE_BB;
+ in_bb_p[INSN_UID (x)] = state;
- if (x == BB_END (bb))
- break;
+ if (x == BB_END (bb))
+ break;
+ }
}
}
for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
{
- bb = start[INSN_UID (tmp_rtx)];
- if (bb != NULL)
- dump_bb_info (outf, bb, 0, dump_flags | TDF_COMMENT, true, false);
+ if (flags & TDF_BLOCKS)
+ {
+ bb = start[INSN_UID (tmp_rtx)];
+ if (bb != NULL)
+ {
+ dump_bb_info (outf, bb, 0, dump_flags | TDF_COMMENT, true, false);
+ if (df && (flags & TDF_DETAILS))
+ df_dump_top (bb, outf);
+ }
- if (in_bb_p[INSN_UID (tmp_rtx)] == NOT_IN_BB
- && !NOTE_P (tmp_rtx)
- && !BARRIER_P (tmp_rtx))
- fprintf (outf, ";; Insn is not within a basic block\n");
- else if (in_bb_p[INSN_UID (tmp_rtx)] == IN_MULTIPLE_BB)
- fprintf (outf, ";; Insn is in multiple basic blocks\n");
+ if (in_bb_p[INSN_UID (tmp_rtx)] == NOT_IN_BB
+ && !NOTE_P (tmp_rtx)
+ && !BARRIER_P (tmp_rtx))
+ fprintf (outf, ";; Insn is not within a basic block\n");
+ else if (in_bb_p[INSN_UID (tmp_rtx)] == IN_MULTIPLE_BB)
+ fprintf (outf, ";; Insn is in multiple basic blocks\n");
+ }
if (! (flags & TDF_SLIM))
print_rtl_single (outf, tmp_rtx);
else
dump_insn_slim (outf, tmp_rtx);
- bb = end[INSN_UID (tmp_rtx)];
- if (bb != NULL)
- dump_bb_info (outf, bb, 0, dump_flags | TDF_COMMENT, false, true);
+ if (flags & TDF_BLOCKS)
+ {
+ bb = end[INSN_UID (tmp_rtx)];
+ if (bb != NULL)
+ {
+ dump_bb_info (outf, bb, 0, dump_flags | TDF_COMMENT, false, true);
+ if (df && (flags & TDF_DETAILS))
+ df_dump_bottom (bb, outf);
+ }
+ }
putc ('\n', outf);
}
/* Print the GIMPLE sequence SEQ on BUFFER using SPC indentantion
- spaces and FLAGS as in dump_gimple_stmt. */
+ spaces and FLAGS as in dump_gimple_stmt.
+ The caller is responsible for calling pp_flush on BUFFER to finalize
+ the pretty printer. */
static void
dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc, int flags)
}
-/* Dump a PHI node PHI. BUFFER, SPC and FLAGS are as in
- dump_gimple_stmt. */
+/* Dump a PHI node PHI. BUFFER, SPC and FLAGS are as in dump_gimple_stmt.
+ The caller is responsible for calling pp_flush on BUFFER to finalize
+ pretty printer. */
static void
dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, int flags)
/* Dump the gimple statement GS on the pretty printer BUFFER, SPC
spaces of indent. FLAGS specifies details to show in the dump (see
- TDF_* in dumpfile.h). */
+ TDF_* in dumpfile.h). The caller is responsible for calling
+ pp_flush on BUFFER to finalize the pretty printer. */
void
dump_gimple_stmt (pretty_printer *buffer, gimple gs, int spc, int flags)
{
if (flags & TDF_BLOCKS)
{
- dump_bb_info (outf, bb, indent, flags, true, false);
-
if (flags & TDF_LINENO)
{
gimple_stmt_iterator gsi;
fprintf (outf, "%s<bb %d>:\n", s_indent, bb->index);
}
}
- if (cfun)
- check_bb_profile (bb, outf);
}
spaces. */
static void
-dump_gimple_bb_footer (FILE *outf, basic_block bb, int indent, int flags)
+dump_gimple_bb_footer (FILE *outf ATTRIBUTE_UNUSED,
+ basic_block bb ATTRIBUTE_UNUSED,
+ int indent ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED)
{
- dump_bb_info (outf, bb, indent, flags, false, true);
+ /* There is currently no GIMPLE-specific basic block info to dump. */
+ return;
}
INDENT (curr_indent);
dump_gimple_stmt (buffer, stmt, curr_indent, flags);
- pp_newline (buffer);
+ pp_flush (buffer);
dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
}
gimple_dump_bb (FILE *file, basic_block bb, int indent, int flags)
{
dump_gimple_bb_header (file, bb, indent, flags);
- maybe_init_pretty_print (file);
- gimple_dump_bb_buff (&buffer, bb, indent, flags);
- pp_flush (&buffer);
+ if (bb->index >= NUM_FIXED_BLOCKS)
+ {
+ maybe_init_pretty_print (file);
+ gimple_dump_bb_buff (&buffer, bb, indent, flags);
+ }
dump_gimple_bb_footer (file, bb, indent, flags);
}
dump_function_to_file (current_function_decl, dump_file, dump_flags);
else
{
- if ((cfun->curr_properties & PROP_cfg)
- && (dump_flags & TDF_BLOCKS))
- print_rtl_with_bb (dump_file, get_insns (), dump_flags);
- else
- print_rtl (dump_file, get_insns ());
+ print_rtl_with_bb (dump_file, get_insns (), dump_flags);
if ((cfun->curr_properties & PROP_cfg)
&& graph_dump_format != no_graph
pp_base_newline (pretty_printer *pp)
{
obstack_1grow (pp->buffer->obstack, '\n');
+ pp_needs_newline (pp) = false;
pp->buffer->line_length = 0;
}
for (bb = 0; bb < rgn_table[rgn].rgn_nr_blocks; bb++)
{
dump_bb (stderr, BASIC_BLOCK (rgn_bb_table[current_blocks + bb]),
- 0, TDF_SLIM);
+ 0, TDF_SLIM | TDF_BLOCKS);
fprintf (stderr, "\n");
}
DEBUG_FUNCTION void
debug_bb_slim (basic_block bb)
{
- dump_bb (stderr, bb, 0, TDF_SLIM);
+ dump_bb (stderr, bb, 0, TDF_SLIM | TDF_BLOCKS);
}
extern void debug_bb_n_slim (int);
+2012-07-20 Steven Bosscher <steven@gcc.gnu.org>
+
+ * gcc.dg/tree-prof/update-loopch.c: Look for counts on the dumps of
+ the basic block and check loop depth.
+ * gcc.dg/tree-ssa/pr18133-1.c: Dump details, not blocks. Update
+ matching patterns and comments.
+ * gcc.dg/tree-ssa/20031021-1.c: Fix check patterns.
+ * gcc.dg/tree-ssa/vector-2.c: Likewise.
+
2012-07-20 Jakub Jelinek <jakub@redhat.com>
PR c++/28656
-/* { dg-options "-O2 -fdump-ipa-profile-blocks -fdump-tree-optimized-blocks" } */
+/* { dg-options "-O2 -fdump-ipa-profile-details -fdump-tree-optimized-details" } */
int max = 33333;
int a[8];
int
/* Loop header copying will peel away the initial conditional, so the loop body
is once reached directly from entry point of function, rest via loopback
edge. */
-/* { dg-final-use { scan-ipa-dump "count:33333" "profile"} } */
-/* { dg-final-use { scan-tree-dump "count:33332" "optimized"} } */
+/* { dg-final-use { scan-ipa-dump "loop depth 1, count 33334" "profile"} } */
+/* { dg-final-use { scan-tree-dump "loop depth 1, count 33332" "optimized"} } */
/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
/* { dg-final-use { cleanup-ipa-dump "profile" } } */
/* { dg-final-use { cleanup-tree-dump "optimized" } } */
}
/* We should only store to a.i, not load from it. */
-/* { dg-final { scan-tree-dump-times "a.i" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-not "= a.i" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
/* { dg-do compile } */
-/* { dg-options "-O1 -fdump-tree-optimized-blocks" } */
+/* { dg-options "-O1 -fdump-tree-optimized-details" } */
void foo (void)
{
/* The goto &L0 should have been optimized away during CFG
cleanups. */
-/* { dg-final { scan-tree-dump-times "goto &L0" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-not "goto &L0" "optimized" } } */
/* There should not be any abnormal edges as DOM removed the
computed goto. */
-/* { dg-final { scan-tree-dump-times "ab" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-not "ABNORMAL" "optimized" } } */
/* And verify that we have fixed the fallthru flag as well.
After DOM we will have two fallthru edges (e->0, 0->1),
- but in the dump files we mention the 0->1 two times. So
- scan for 3 instances of "fallthru". */
+ but in the dump files we mention the 2->3 two times. So
+ scan for 3 instances of "FALLTHRU". */
-/* { dg-final { scan-tree-dump-times "fallthru" 3 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "FALLTHRU" 3 "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
}
/* We should be able to optimize this to just "return 0.0;" */
-/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "optimized"} } */
-/* { dg-final { scan-tree-dump-times "0.0" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-not "BIT_FIELD_REF" "optimized"} } */
+/* { dg-final { scan-tree-dump-times "return 0.0" 1 "optimized"} } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
mark_dfs_back_edges ();
if (dump_file)
- brief_dump_cfg (dump_file);
+ brief_dump_cfg (dump_file, dump_flags);
/* Trace formation is done on the fly inside tail_duplicate */
changed = tail_duplicate ();
free_dominance_info (CDI_DOMINATORS);
if (dump_file)
- brief_dump_cfg (dump_file);
+ brief_dump_cfg (dump_file, dump_flags);
return changed ? TODO_cleanup_cfg : 0;
}
fprintf (dump_file, "Removing basic block %d\n", bb->index);
if (dump_flags & TDF_DETAILS)
{
- dump_bb (dump_file, bb, 0, 0);
+ dump_bb (dump_file, bb, 0, dump_flags);
fprintf (dump_file, "\n");
}
}
void
gimple_debug_bb (basic_block bb)
{
- dump_bb (stderr, bb, 0, TDF_VOPS|TDF_MEMSYMS);
+ dump_bb (stderr, bb, 0, TDF_VOPS|TDF_MEMSYMS|TDF_BLOCKS);
}
fprintf (file, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
n_basic_blocks, n_edges, last_basic_block);
- brief_dump_cfg (file);
+ brief_dump_cfg (file, flags | TDF_COMMENT);
fprintf (file, "\n");
}
if (cfun && cfun->decl == fn && cfun->cfg && basic_block_info)
{
/* If the CFG has been built, emit a CFG-based dump. */
- check_bb_profile (ENTRY_BLOCK_PTR, file);
if (!ignore_topmost_bind)
fprintf (file, "{\n");
fprintf (file, "\n");
FOR_EACH_BB (bb)
- gimple_dump_bb (file, bb, 2, flags);
+ dump_bb (file, bb, 2, flags | TDF_COMMENT);
fprintf (file, "}\n");
- check_bb_profile (EXIT_BLOCK_PTR, file);
}
else if (DECL_SAVED_TREE (fn) == NULL)
{
if (verbosity >= 3)
{
fprintf (file, "%s {\n", s_indent);
- gimple_dump_bb (file, bb, indent + 4, TDF_VOPS|TDF_MEMSYMS);
+ dump_bb (file, bb, indent + 4, TDF_VOPS|TDF_MEMSYMS);
fprintf (file, "%s }\n", s_indent);
}
}
projects / platform / upstream / linaro-gcc.git / commitdiff