From bec2cf98763e9ec1a4d41bd1db78a74ca8fefbd9 Mon Sep 17 00:00:00 2001 From: steven Date: Fri, 20 Jul 2012 12:25:55 +0000 Subject: [PATCH] gcc/ * 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. testsuite/ * 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. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@189717 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 41 +++++++++++++- gcc/basic-block.h | 11 +++- gcc/cfg-flags.def | 3 +- gcc/cfg.c | 74 +++++++++++++++++-------- gcc/cfghooks.c | 9 ++- gcc/cfgrtl.c | 77 +++++++++++++++++--------- gcc/gimple-pretty-print.c | 34 +++++++----- gcc/passes.c | 6 +- gcc/pretty-print.c | 1 + gcc/sched-rgn.c | 2 +- gcc/sched-vis.c | 2 +- gcc/testsuite/ChangeLog | 9 +++ gcc/testsuite/gcc.dg/tree-prof/update-loopch.c | 6 +- gcc/testsuite/gcc.dg/tree-ssa/20031021-1.c | 2 +- gcc/testsuite/gcc.dg/tree-ssa/pr18133-1.c | 12 ++-- gcc/testsuite/gcc.dg/tree-ssa/vector-2.c | 4 +- gcc/tracer.c | 4 +- gcc/tree-cfg.c | 12 ++-- 18 files changed, 207 insertions(+), 102 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 187b81c..3bb9763 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,42 @@ +2012-07-20 Steven Bosscher + + * 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 PR tree-optimization/54031 @@ -1398,7 +1437,7 @@ (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 diff --git a/gcc/basic-block.h b/gcc/basic-block.h index bf18bae..24f178f 100644 --- a/gcc/basic-block.h +++ b/gcc/basic-block.h @@ -203,9 +203,15 @@ enum cfg_bb_flags }; #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 @@ -395,7 +401,7 @@ extern basic_block create_basic_block_structure (rtx, rtx, rtx, basic_block); 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, @@ -816,7 +822,6 @@ unsigned bb_dom_dfs_out (enum cdi_direction, basic_block); 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); diff --git a/gcc/cfg-flags.def b/gcc/cfg-flags.def index a9aaf18..839b9b3 100644 --- a/gcc/cfg-flags.def +++ b/gcc/cfg-flags.def @@ -90,8 +90,7 @@ DEF_BASIC_BLOCK_FLAG(MODIFIED, 12) 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 diff --git a/gcc/cfg.c b/gcc/cfg.c index 66458e3..f861407 100644 --- a/gcc/cfg.c +++ b/gcc/cfg.c @@ -382,16 +382,14 @@ redirect_edge_pred (edge e, basic_block new_pred) 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; } /* Check the consistency of profile information. We can't do that @@ -399,13 +397,16 @@ clear_bb_flags (void) 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; @@ -415,14 +416,16 @@ check_bb_profile (basic_block bb, FILE * file) 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) @@ -432,13 +435,15 @@ check_bb_profile (basic_block bb, FILE * file) 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); } } @@ -679,6 +684,7 @@ dump_bb_info (FILE *outf, basic_block bb, int indent, int flags, #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'; @@ -691,11 +697,12 @@ dump_bb_info (FILE *outf, basic_block bb, int indent, int flags, 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); @@ -703,11 +710,11 @@ dump_bb_info (FILE *outf, basic_block bb, int indent, int flags, 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); @@ -722,6 +729,7 @@ dump_bb_info (FILE *outf, basic_block bb, int indent, int flags, fprintf (outf, "(nil)"); fputs (", flags:", outf); + first = true; for (i = 0; i < n_bitnames; i++) if (bb->flags & (1 << i)) { @@ -734,15 +742,25 @@ dump_bb_info (FILE *outf, basic_block bb, int indent, int flags, } 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) @@ -750,22 +768,34 @@ dump_bb_info (FILE *outf, basic_block bb, int indent, int flags, 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); } } diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c index 6965539..be117cf 100644 --- a/gcc/cfghooks.c +++ b/gcc/cfghooks.c @@ -271,9 +271,11 @@ verify_flow_info (void) 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. */ @@ -284,10 +286,7 @@ dump_flow_info (FILE *file, int flags) 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); } diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c index e87f06d..2bf22d8 100644 --- a/gcc/cfgrtl.c +++ b/gcc/cfgrtl.c @@ -1875,8 +1875,9 @@ rtl_dump_bb (FILE *outf, basic_block bb, int indent, int flags) } -/* 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) @@ -1891,52 +1892,74 @@ 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); } diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c index febf1d9..ce9a3ac 100644 --- a/gcc/gimple-pretty-print.c +++ b/gcc/gimple-pretty-print.c @@ -115,7 +115,9 @@ print_gimple_expr (FILE *file, gimple g, int spc, int flags) /* 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) @@ -1578,8 +1580,9 @@ dump_gimple_asm (pretty_printer *buffer, gimple gs, 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) @@ -1843,7 +1846,8 @@ dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, 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) @@ -2067,8 +2071,6 @@ dump_gimple_bb_header (FILE *outf, basic_block bb, int indent, int flags) { if (flags & TDF_BLOCKS) { - dump_bb_info (outf, bb, indent, flags, true, false); - if (flags & TDF_LINENO) { gimple_stmt_iterator gsi; @@ -2103,8 +2105,6 @@ dump_gimple_bb_header (FILE *outf, basic_block bb, int indent, int flags) fprintf (outf, "%s:\n", s_indent, bb->index); } } - if (cfun) - check_bb_profile (bb, outf); } @@ -2112,9 +2112,13 @@ dump_gimple_bb_header (FILE *outf, basic_block bb, int indent, int flags) 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; } @@ -2256,7 +2260,7 @@ gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent, 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); } @@ -2271,8 +2275,10 @@ void 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); } diff --git a/gcc/passes.c b/gcc/passes.c index 5612a35..7709671 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -1725,11 +1725,7 @@ execute_function_dump (void *data ATTRIBUTE_UNUSED) 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 diff --git a/gcc/pretty-print.c b/gcc/pretty-print.c index 8aa9978..4033ba3 100644 --- a/gcc/pretty-print.c +++ b/gcc/pretty-print.c @@ -759,6 +759,7 @@ void pp_base_newline (pretty_printer *pp) { obstack_1grow (pp->buffer->obstack, '\n'); + pp_needs_newline (pp) = false; pp->buffer->line_length = 0; } diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c index 69645b4..1dd0d81 100644 --- a/gcc/sched-rgn.c +++ b/gcc/sched-rgn.c @@ -397,7 +397,7 @@ debug_region (int rgn) 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"); } diff --git a/gcc/sched-vis.c b/gcc/sched-vis.c index 768aa13..d5a8747 100644 --- a/gcc/sched-vis.c +++ b/gcc/sched-vis.c @@ -810,7 +810,7 @@ extern void debug_bb_slim (basic_block); 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); diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index f02f16e..56aace3 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,12 @@ +2012-07-20 Steven Bosscher + + * 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 PR c++/28656 diff --git a/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c b/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c index 2bce8a2..3388996 100644 --- a/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c +++ b/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c @@ -1,4 +1,4 @@ -/* { 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 @@ -14,8 +14,8 @@ main () /* 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" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/20031021-1.c b/gcc/testsuite/gcc.dg/tree-ssa/20031021-1.c index 117cddf..7c34ff4 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/20031021-1.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/20031021-1.c @@ -17,5 +17,5 @@ int main() } /* 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" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr18133-1.c b/gcc/testsuite/gcc.dg/tree-ssa/pr18133-1.c index f225f66..8a26479 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/pr18133-1.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr18133-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O1 -fdump-tree-optimized-blocks" } */ +/* { dg-options "-O1 -fdump-tree-optimized-details" } */ void foo (void) { @@ -12,17 +12,17 @@ return; /* 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" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vector-2.c b/gcc/testsuite/gcc.dg/tree-ssa/vector-2.c index e34532d..2d214df 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/vector-2.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/vector-2.c @@ -17,7 +17,7 @@ float f(vector float a, int b, vector float c) } /* 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" } } */ diff --git a/gcc/tracer.c b/gcc/tracer.c index bbf973a..f60f348 100644 --- a/gcc/tracer.c +++ b/gcc/tracer.c @@ -374,7 +374,7 @@ tracer (void) 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 (); @@ -382,7 +382,7 @@ tracer (void) 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; } diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index e4cf076..c9187b9 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -1844,7 +1844,7 @@ remove_bb (basic_block bb) 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"); } } @@ -2063,7 +2063,7 @@ find_case_label_for_value (gimple switch_stmt, tree val) 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); } @@ -2103,7 +2103,7 @@ gimple_dump_cfg (FILE *file, int flags) 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"); } @@ -6687,7 +6687,6 @@ dump_function_to_file (tree fn, FILE *file, int flags) 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"); @@ -6695,10 +6694,9 @@ dump_function_to_file (tree fn, FILE *file, int flags) 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) { @@ -6821,7 +6819,7 @@ print_loops_bb (FILE *file, basic_block bb, int indent, int verbosity) 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); } } -- 2.7.4