OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

dumpfile.h (TDF_COMMENT): New define. 

* dumpfile.h (TDF_COMMENT): New define.
	* basic-block.h (EDGE_FALLTHRU, EDGE_ABNORMAL, EDGE_ABNORMAL_CALL,
	EDGE_EH, EDGE_FAKE, EDGE_DFS_BACK, EDGE_CAN_FALLTHRU,
	EDGE_IRREDUCIBLE_LOOP, EDGE_SIBCALL, EDGE_LOOP_EXIT, EDGE_TRUE_VALUE,
	EDGE_FALSE_VALUE, EDGE_EXECUTABLE, EDGE_CROSSING, EDGE_PRESERVE):
	Move to new file cfg-flags.h.
	(enum cfg_edge_flags): New enum, using cfg-flags.h.
	(EDGE_ALL_FLAGS): Compute value automatically.
	(BB_NEW, BB_REACHABLE, BB_IRREDUCIBLE_LOOP, BB_SUPERBLOCK,
	BB_DISABLE_SCHEDULE, BB_HOT_PARTITION, BB_COLD_PARTITION,
	BB_DUPLICATED, BB_NON_LOCAL_GOTO_TARGET, BB_RTL,
	BB_FORWARDER_BLOCK, BB_NONTHREADABLE_BLOCK, BB_MODIFIED, BB_VISITED,
	BB_IN_TRANSACTION): Move to new file cfg-flags.h.
	(enum bb_flags): Rename to cfg_bb_flags.  Use cfg-flags.h.
	(BB_ALL_FLAGS): New, compute value automatically.
	(dump_bb_info): Update prototype.
	(dump_edge_info): Update prototype.
	* cfg-flags.h: New file.
	* cfg.c (dump_edge_info): Take flags argument.  Be verbose only if
	TDF_DETAILS and not TDF_SLIM.  Include cfg-flags.h for bitnames.
	Check that the edge flags are within the range of EDGE_ALL_FLAGS.
	(debug_bb): Update dump_bb call.
	(dump_cfg_bb_info): Remove.
	(dump_bb_info): New function.  Use cfg-flags.h for bitnames.
	Adjust verbosity using TDF_* flags.  Check that the basic block flags
	are within the range of BB_ALL_FLAGS.
	(brief_dump_cfg): Use dump_bb_info instead of dump_cfg_bb_info.
	* cfghooks.h (struct cfghooks): Update dump_bb hook, take a FILE
	first for consistency with other dump functions.
	(dump_bb): Update prototype accordingly.
	* cfghooks.c: Include dumpfile.h.
	(verify_flow_info): Update dump_edge_info calls.
	(dump_bb): Take a flags argument and pass it around.
	Use dump_bb_info to dump common information about a basic block.
	(dump_flow_info): Moved here from cfgrtl.c.  Make IL agnostic.
	(debug_flow_info): Moved here from cfgrtl.c.
	* profile.c (is_edge_inconsistent): Update dump_bb calls.
	* loop-invariant.c (find_defs): Update print_rtl_with_bb call.
	* rtl.h (debug_bb_n_slim, debug_bb_slim, print_rtl_slim,
	print_rtl_slim_with_bb): Remove prototypes.
	(dump_insn_slim): Adjust prototype to take a const_rtx.
	(print_rtl_with_bb): Adjust prototype.
	* sched-rgn.c (debug_region): Use dump_bb instead of debug_bb_n_slim.
	* sched-vis.c (dump_insn_slim): Take a const_rtx.
	(debug_insn_slim): Prototype here near DEBUG_FUNCTION marker.
	(print_rtl_slim_with_bb): Remove.
	(print_rtl_slim): Rename to debug_rtl_slim.  Print only insn info,
	not basic block info (print_rtl_with_bb with TDF_SLIM should be used
	for that.  Prototype here near DEBUG_FUNCTION marker.
	(debug_bb_slim): Prototype here near DEBUG_FUNCTION marker.
	Use dump_bb.
	(debug_bb_n_slim): Prototype here near DEBUG_FUNCTION marker.
	* tree-cfg.c (gimple_can_merge_blocks_p): Use EDGE_COMPLEX.
	(remove_bb): Update dump_bb call.
	(gimple_debug_bb): Use dump_bb.
	(dump_function_to_file): Update gimple_dump_bb call.
	(print_loops_bb): Likewise.
	* tree-flow.h (gimple_dump_bb): Update prototype.
	* gimple-pretty-print.c (dump_bb_header): Rename to
	dump_gimple_bb_header.  Write to a stream instead of a pretty
	printer.  Use dump_bb_info to dump basic block info.
	(dump_bb_end): Rename to dump_gimple_bb_footer.  Write to a
	stream instead of a pretty printer.  Use dump_bb_info.
	(gimple_dump_bb_buff): Do not call dump_bb_header and dump_bb_end.
	(gimple_dump_bb): Do it here with dump_gimple_bb_header and
	dump_gimple_bb_footer.
	* cfgrtl.c (rtl_dump_bb): Update prototype.  Only dump DF if the
	dump flags have TDF_DETAILS.  Use dump_insn_slim if TDF_SLIM.
	(print_rtl_with_bb): Take a flags argument and pass it around.
	Use dump_insn_slim if TDF_SLIM.
	(dump_bb_info): Removed and re-incarnated in cfg.c.
	(dump_flow_info): Moved to cfghooks.c.
	(debug_flow_info): Moved to cfghooks.c.
	* passes.c (execute_function_dump): Unconditionally use
	print_rtl_with_bb for RTL dumps, now that it understands TDF_SLIM.
	* final.c (dump_basic_block_info): Update dump_edge_info calls.
	* tree-vrp.c (dump_asserts_for): Likewise.
	* ifcvt.c (if_convert): Unconditionally use print_rtl_with_bb.
	* tree-if-conv.c (if_convertible_bb_p): Don't look at
	EDGE_ABNORMAL_CALL, it has no meaning in the GIMPLE world.
	* trans-mem.c (make_tm_edge): Don't set EDGE_ABNORMAL_CALL,
	for the same reason.
	* config/rl78/rl78.c (rl78_reorg): Update print_rtl_with_bb calls.

From-SVN: r189590
This commit is contained in:
Steven Bosscher 2012-07-17 23:17:20 +00:00
parent 9717f7a145
commit a315c44ce0
23 changed files with 535 additions and 463 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
gcc/ChangeLog
View File

@ -1,3 +1,89 @@
2012-07-18 Steven Bosscher <steven@gcc.gnu.org>
* dumpfile.h (TDF_COMMENT): New define.
* basic-block.h (EDGE_FALLTHRU, EDGE_ABNORMAL, EDGE_ABNORMAL_CALL,
EDGE_EH, EDGE_FAKE, EDGE_DFS_BACK, EDGE_CAN_FALLTHRU,
EDGE_IRREDUCIBLE_LOOP, EDGE_SIBCALL, EDGE_LOOP_EXIT, EDGE_TRUE_VALUE,
EDGE_FALSE_VALUE, EDGE_EXECUTABLE, EDGE_CROSSING, EDGE_PRESERVE):
Move to new file cfg-flags.h.
(enum cfg_edge_flags): New enum, using cfg-flags.h.
(EDGE_ALL_FLAGS): Compute value automatically.
(BB_NEW, BB_REACHABLE, BB_IRREDUCIBLE_LOOP, BB_SUPERBLOCK,
BB_DISABLE_SCHEDULE, BB_HOT_PARTITION, BB_COLD_PARTITION,
BB_DUPLICATED, BB_NON_LOCAL_GOTO_TARGET, BB_RTL,
BB_FORWARDER_BLOCK, BB_NONTHREADABLE_BLOCK, BB_MODIFIED, BB_VISITED,
BB_IN_TRANSACTION): Move to new file cfg-flags.h.
(enum bb_flags): Rename to cfg_bb_flags. Use cfg-flags.h.
(BB_ALL_FLAGS): New, compute value automatically.
(dump_bb_info): Update prototype.
(dump_edge_info): Update prototype.
* cfg-flags.h: New file.
* cfg.c (dump_edge_info): Take flags argument. Be verbose only if
TDF_DETAILS and not TDF_SLIM. Include cfg-flags.h for bitnames.
Check that the edge flags are within the range of EDGE_ALL_FLAGS.
(debug_bb): Update dump_bb call.
(dump_cfg_bb_info): Remove.
(dump_bb_info): New function. Use cfg-flags.h for bitnames.
Adjust verbosity using TDF_* flags. Check that the basic block flags
are within the range of BB_ALL_FLAGS.
(brief_dump_cfg): Use dump_bb_info instead of dump_cfg_bb_info.
* cfghooks.h (struct cfghooks): Update dump_bb hook, take a FILE
first for consistency with other dump functions.
(dump_bb): Update prototype accordingly.
* cfghooks.c: Include dumpfile.h.
(verify_flow_info): Update dump_edge_info calls.
(dump_bb): Take a flags argument and pass it around.
Use dump_bb_info to dump common information about a basic block.
(dump_flow_info): Moved here from cfgrtl.c. Make IL agnostic.
(debug_flow_info): Moved here from cfgrtl.c.
* profile.c (is_edge_inconsistent): Update dump_bb calls.
* loop-invariant.c (find_defs): Update print_rtl_with_bb call.
* rtl.h (debug_bb_n_slim, debug_bb_slim, print_rtl_slim,
print_rtl_slim_with_bb): Remove prototypes.
(dump_insn_slim): Adjust prototype to take a const_rtx.
(print_rtl_with_bb): Adjust prototype.
* sched-rgn.c (debug_region): Use dump_bb instead of debug_bb_n_slim.
* sched-vis.c (dump_insn_slim): Take a const_rtx.
(debug_insn_slim): Prototype here near DEBUG_FUNCTION marker.
(print_rtl_slim_with_bb): Remove.
(print_rtl_slim): Rename to debug_rtl_slim. Print only insn info,
not basic block info (print_rtl_with_bb with TDF_SLIM should be used
for that. Prototype here near DEBUG_FUNCTION marker.
(debug_bb_slim): Prototype here near DEBUG_FUNCTION marker.
Use dump_bb.
(debug_bb_n_slim): Prototype here near DEBUG_FUNCTION marker.
* tree-cfg.c (gimple_can_merge_blocks_p): Use EDGE_COMPLEX.
(remove_bb): Update dump_bb call.
(gimple_debug_bb): Use dump_bb.
(dump_function_to_file): Update gimple_dump_bb call.
(print_loops_bb): Likewise.
* tree-flow.h (gimple_dump_bb): Update prototype.
* gimple-pretty-print.c (dump_bb_header): Rename to
dump_gimple_bb_header. Write to a stream instead of a pretty
printer. Use dump_bb_info to dump basic block info.
(dump_bb_end): Rename to dump_gimple_bb_footer. Write to a
stream instead of a pretty printer. Use dump_bb_info.
(gimple_dump_bb_buff): Do not call dump_bb_header and dump_bb_end.
(gimple_dump_bb): Do it here with dump_gimple_bb_header and
dump_gimple_bb_footer.
* cfgrtl.c (rtl_dump_bb): Update prototype. Only dump DF if the
dump flags have TDF_DETAILS. Use dump_insn_slim if TDF_SLIM.
(print_rtl_with_bb): Take a flags argument and pass it around.
Use dump_insn_slim if TDF_SLIM.
(dump_bb_info): Removed and re-incarnated in cfg.c.
(dump_flow_info): Moved to cfghooks.c.
(debug_flow_info): Moved to cfghooks.c.
* passes.c (execute_function_dump): Unconditionally use
print_rtl_with_bb for RTL dumps, now that it understands TDF_SLIM.
* final.c (dump_basic_block_info): Update dump_edge_info calls.
* tree-vrp.c (dump_asserts_for): Likewise.
* ifcvt.c (if_convert): Unconditionally use print_rtl_with_bb.
* tree-if-conv.c (if_convertible_bb_p): Don't look at
EDGE_ABNORMAL_CALL, it has no meaning in the GIMPLE world.
* trans-mem.c (make_tm_edge): Don't set EDGE_ABNORMAL_CALL,
for the same reason.
* config/rl78/rl78.c (rl78_reorg): Update print_rtl_with_bb calls.
2012-07-17 Richard Guenther <rguenther@suse.de>
* tree-vect-data-refs.c (vect_get_new_vect_var): Add referenced

125
gcc/basic-block.h
View File

@ -55,7 +55,7 @@ struct GTY(()) edge_def {
dest->preds. */
unsigned int dest_idx;
int flags; /* see EDGE_* below */
int flags; /* see cfg-flags.def */
int probability; /* biased by REG_BR_PROB_BASE */
gcov_type count; /* Expected number of executions calculated
in profile.c */
@ -65,32 +65,20 @@ DEF_VEC_P(edge);
DEF_VEC_ALLOC_P(edge,gc);
DEF_VEC_ALLOC_P(edge,heap);
/* Always update the table in cfg.c dump_edge_info. */
#define EDGE_FALLTHRU 0x0001 /* 'Straight line' flow */
#define EDGE_ABNORMAL 0x0002 /* Strange flow, like computed
label, or eh */
#define EDGE_ABNORMAL_CALL 0x0004 /* Call with abnormal exit
like an exception, or sibcall */
#define EDGE_EH 0x0008 /* Exception throw */
#define EDGE_FAKE 0x0010 /* Not a real edge (profile.c) */
#define EDGE_DFS_BACK 0x0020 /* A backwards edge */
#define EDGE_CAN_FALLTHRU 0x0040 /* Candidate for straight line
flow. */
#define EDGE_IRREDUCIBLE_LOOP 0x0080 /* Part of irreducible loop. */
#define EDGE_SIBCALL 0x0100 /* Edge from sibcall to exit. */
#define EDGE_LOOP_EXIT 0x0200 /* Exit of a loop. */
#define EDGE_TRUE_VALUE 0x0400 /* Edge taken when controlling
predicate is nonzero. */
#define EDGE_FALSE_VALUE 0x0800 /* Edge taken when controlling
predicate is zero. */
#define EDGE_EXECUTABLE 0x1000 /* Edge is executable. Only
valid during SSA-CCP. */
#define EDGE_CROSSING 0x2000 /* Edge crosses between hot
and cold sections, when we
do partitioning. */
#define EDGE_PRESERVE 0x4000 /* Never merge blocks via this edge. */
#define EDGE_ALL_FLAGS 0x7fff
/* Masks for edge.flags. */
#define DEF_EDGE_FLAG(NAME,IDX) EDGE_##NAME = 1 << IDX ,
enum cfg_edge_flags {
#include "cfg-flags.def"
LAST_CFG_EDGE_FLAG /* this is only used for EDGE_ALL_FLAGS */
};
#undef DEF_EDGE_FLAG
/* Bit mask for all edge flags. */
#define EDGE_ALL_FLAGS ((LAST_CFG_EDGE_FLAG - 1) * 2 - 1)
/* The following four flags all indicate something special about an edge.
Test the edge flags on EDGE_COMPLEX to detect all forms of "strange"
control flow transfers. */
#define EDGE_COMPLEX \
(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE)
@ -184,10 +172,12 @@ struct GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb"))) basic_block_d
/* Expected frequency. Normalized to be in range 0 to BB_FREQ_MAX. */
int frequency;
/* The discriminator for this block. */
/* The discriminator for this block. The discriminator distinguishes
among several basic blocks that share a common locus, allowing for
more accurate sample-based profiling. */
int discriminator;
/* Various flags. See BB_* below. */
/* Various flags. See cfg-flags.def. */
int flags;
};
@ -204,74 +194,19 @@ DEF_VEC_ALLOC_P(basic_block,heap);
#define BB_FREQ_MAX 10000
/* Masks for basic_block.flags.
BB_HOT_PARTITION and BB_COLD_PARTITION should be preserved throughout
the compilation, so they are never cleared.
All other flags may be cleared by clear_bb_flags(). It is generally
a bad idea to rely on any flags being up-to-date.
Always update the table in cfg.c dump_bb_info. */
enum bb_flags
/* Masks for basic_block.flags. */
#define DEF_BASIC_BLOCK_FLAG(NAME,IDX) BB_##NAME = 1 << IDX ,
enum cfg_bb_flags
{
/* Only set on blocks that have just been created by create_bb. */
BB_NEW = 1 << 0,
/* Set by find_unreachable_blocks. Do not rely on this being set in any
pass. */
BB_REACHABLE = 1 << 1,
/* Set for blocks in an irreducible loop by loop analysis. */
BB_IRREDUCIBLE_LOOP = 1 << 2,
/* Set on blocks that may actually not be single-entry single-exit block. */
BB_SUPERBLOCK = 1 << 3,
/* Set on basic blocks that the scheduler should not touch. This is used
by SMS to prevent other schedulers from messing with the loop schedule. */
BB_DISABLE_SCHEDULE = 1 << 4,
/* Set on blocks that should be put in a hot section. */
BB_HOT_PARTITION = 1 << 5,
/* Set on blocks that should be put in a cold section. */
BB_COLD_PARTITION = 1 << 6,
/* Set on block that was duplicated. */
BB_DUPLICATED = 1 << 7,
/* Set if the label at the top of this block is the target of a non-local goto. */
BB_NON_LOCAL_GOTO_TARGET = 1 << 8,
/* Set on blocks that are in RTL format. */
BB_RTL = 1 << 9 ,
/* Set on blocks that are forwarder blocks.
Only used in cfgcleanup.c. */
BB_FORWARDER_BLOCK = 1 << 10,
/* Set on blocks that cannot be threaded through.
Only used in cfgcleanup.c. */
BB_NONTHREADABLE_BLOCK = 1 << 11,
/* Set on blocks that were modified in some way. This bit is set in
df_set_bb_dirty, but not cleared by df_analyze, so it can be used
to test whether a block has been modified prior to a df_analyze
call. */
BB_MODIFIED = 1 << 12,
/* A general visited flag for passes to use. */
BB_VISITED = 1 << 13,
/* Set on blocks that are in a transaction. This is calculated on
demand, and is available after calling
compute_transaction_bits(). */
BB_IN_TRANSACTION = 1 << 14
#include "cfg-flags.def"
LAST_CFG_BB_FLAG /* this is only used for BB_ALL_FLAGS */
};
#undef DEF_BASIC_BLOCK_FLAG
/* Dummy flag for convenience in the hot/cold partitioning code. */
/* Bit mask for all edge flags. */
#define BB_ALL_FLAGS ((LAST_CFG_BB_FLAG - 1) * 2 - 1)
/* Dummy bitmask for convenience in the hot/cold partitioning code. */
#define BB_UNPARTITIONED 0
/* Partitions, to be used when partitioning hot and cold basic blocks into
@ -458,8 +393,8 @@ extern edge redirect_edge_succ_nodup (edge, basic_block);
extern void redirect_edge_pred (edge, basic_block);
extern basic_block create_basic_block_structure (rtx, rtx, rtx, basic_block);
extern void clear_bb_flags (void);
extern void dump_bb_info (basic_block, bool, bool, bool, const char *, FILE *);
extern void dump_edge_info (FILE *, edge, int);
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 clear_edges (void);
extern void scale_bbs_frequencies_int (basic_block *, int, int, int);

179
gcc/cfg-flags.def Normal file
View File

@ -0,0 +1,179 @@
/* Flags on basic blocks and edges.
Copyright (C) 2012 Free Software Foundation, Inc.
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 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
/* This file defines flags that may appear on basic blocks or on
edges. Source files define DEF_BASIC_BLOCK_FLAG or DEF_EDGE_FLAG
appropriately before including this file. */
#if !defined(DEF_BASIC_BLOCK_FLAG) && !defined(DEF_EDGE_FLAG)
#error "You must define DEF_BASIC_BLOCK_FLAG or DEF_EDGE_FLAG"
#endif
#ifdef DEF_BASIC_BLOCK_FLAG
/* Masks for basic_block.flags.
The format of this file is: DEF_BASIC_BLOCK_FLAG(NAME, IDX).
NAME is the name of the basic block flag. A flag BB_#NAME will be
created and the name is used in dump_edge_info.
IDX is a sequence number that is used to determine the value
of the flag, which is 1 << IDX).
BB_HOT_PARTITION and BB_COLD_PARTITION should be preserved throughout
the compilation, so they are never cleared.
All other flags may be cleared by clear_bb_flags(). It is generally
a bad idea to rely on any flags being up-to-date. */
/* Only set on blocks that have just been created by create_bb. */
DEF_BASIC_BLOCK_FLAG(NEW, 0)
/* Set by find_unreachable_blocks. Do not rely on this being set in any
pass. */
DEF_BASIC_BLOCK_FLAG(REACHABLE, 1)
/* Set for blocks in an irreducible loop by loop analysis. */
DEF_BASIC_BLOCK_FLAG(IRREDUCIBLE_LOOP, 2)
/* Set on blocks that may actually not be single-entry single-exit block. */
DEF_BASIC_BLOCK_FLAG(SUPERBLOCK, 3)
/* Set on basic blocks that the scheduler should not touch. This is used
by SMS to prevent other schedulers from messing with the loop schedule. */
DEF_BASIC_BLOCK_FLAG(DISABLE_SCHEDULE, 4)
/* Set on blocks that should be put in a hot section. */
DEF_BASIC_BLOCK_FLAG(HOT_PARTITION, 5)
/* Set on blocks that should be put in a cold section. */
DEF_BASIC_BLOCK_FLAG(COLD_PARTITION, 6)
/* Set on block that was duplicated. */
DEF_BASIC_BLOCK_FLAG(DUPLICATED, 7)
/* Set if the label at the top of this block is the target of a non-local goto. */
DEF_BASIC_BLOCK_FLAG(NON_LOCAL_GOTO_TARGET, 8)
/* Set on blocks that are in RTL format. */
DEF_BASIC_BLOCK_FLAG(RTL, 9)
/* Set on blocks that are forwarder blocks.
Only used in cfgcleanup.c. */
DEF_BASIC_BLOCK_FLAG(FORWARDER_BLOCK, 10)
/* Set on blocks that cannot be threaded through.
Only used in cfgcleanup.c. */
DEF_BASIC_BLOCK_FLAG(NONTHREADABLE_BLOCK, 11)
/* Set on blocks that were modified in some way. This bit is set in
df_set_bb_dirty, but not cleared by df_analyze, so it can be used
to test whether a block has been modified prior to a df_analyze call. */
DEF_BASIC_BLOCK_FLAG(MODIFIED, 12)
/* A general visited flag for passes to use. */
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(). */
DEF_BASIC_BLOCK_FLAG(IN_TRANSACTION, 14)
#endif
#ifdef DEF_EDGE_FLAG
/* Masks for edge.flags.
The format of this file is: DEF_EDGE_FLAG(NAME, IDX, STRING).
NAME is the name of the edge flag. A flag EDGE_#NAME will be
created and the name is used in dump_edge_info.
IDX is a sequence number that is used to determine the value
of the flag, which is 1 << IDX). */
/* 'Straight line' flow. In GIMPLE and in cfglayout mode, all normal
edges are fallthru edges. In cfgrtl mode, this flag really means
that control flow falls through to the next basic block in the line. */
DEF_EDGE_FLAG(FALLTHRU, 0)
/* Strange flow, like a computed jump or exception handling. Usually
this means that the edge cannot be split. */
DEF_EDGE_FLAG(ABNORMAL, 1)
/* Edge out of a basic block that ends with a CALL_INSN with abnormal
exit, like an exception, or a sibcall.
This flag is only used for the RTL CFG. */
DEF_EDGE_FLAG(ABNORMAL_CALL, 2)
/* Exception edge. Exception handling edges represent possible control
transfers from a trapping instruction to an exception handler. EH
edges also have EDGE_ABNORMAL set. */
DEF_EDGE_FLAG(EH, 3)
/* Never merge blocks via this edge. This is used for exception handling,
to prevent merging away edges to the post-landing-pad basic block.
This flag is only used for the RTL CFG. */
DEF_EDGE_FLAG(PRESERVE, 4)
/* Not a real edge. This is used to connect parts of the CFG that do
not halt, such as infinite loops and noreturn functions, to the
EXIT_BLOCK, so that traversing of the reverse CFG is possible. */
DEF_EDGE_FLAG(FAKE, 5)
/* A back edge, marked in a depth-first search of the CFG. Back edges
are hints that this edge may be part of a loop in the CFG. */
DEF_EDGE_FLAG(DFS_BACK, 6)
/* Edge in a part of the CFG that is an irreducible loop. */
DEF_EDGE_FLAG(IRREDUCIBLE_LOOP, 7)
/* Edge taken when controlling predicate is nonzero.
This is only used for the GIMPLE CFG. */
DEF_EDGE_FLAG(TRUE_VALUE, 8)
/* Edge taken when controlling predicate is zero.
This is only used for the GIMPLE CFG. */
DEF_EDGE_FLAG(FALSE_VALUE, 9)
/* Edge is executable. This is only used in GIMPLE SSA-CCP and VRP.
This is only used for the GIMPLE CFG. */
DEF_EDGE_FLAG(EXECUTABLE, 10)
/* Edge crosses between hot and cold sections, when we do partitioning.
This flag is only used for the RTL CFG. */
DEF_EDGE_FLAG(CROSSING, 11)
/* Edge from a sibcall CALL_INSN to exit.
This flag is only used for the RTL CFG. */
DEF_EDGE_FLAG(SIBCALL, 12)
/* Candidate for straight line flow. Only used in bb-reorder.c.
This flag is only used for the RTL CFG. */
DEF_EDGE_FLAG(CAN_FALLTHRU, 13)
/* Exit of a loop. This is only used in ifcvt.c.
This flag is only used for the RTL CFG. */
DEF_EDGE_FLAG(LOOP_EXIT, 14)
#endif
/*
Local variables:
mode:c
End:
*/

159
gcc/cfg.c
View File

@ -444,9 +444,15 @@ check_bb_profile (basic_block bb, FILE * file)
}
void
dump_edge_info (FILE *file, edge e, int do_succ)
dump_edge_info (FILE *file, edge e, int flags, int do_succ)
{
basic_block side = (do_succ ? e->dest : e->src);
bool do_details = false;
if ((flags & TDF_DETAILS) != 0
&& (flags & TDF_SLIM) == 0)
do_details = true;
/* ENTRY_BLOCK_PTR/EXIT_BLOCK_PTR depend on cfun.
Compare against ENTRY_BLOCK/EXIT_BLOCK to avoid that dependency. */
if (side->index == ENTRY_BLOCK)
@ -456,25 +462,28 @@ dump_edge_info (FILE *file, edge e, int do_succ)
else
fprintf (file, " %d", side->index);
if (e->probability)
if (e->probability && do_details)
fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
if (e->count)
if (e->count && do_details)
{
fputs (" count:", file);
fprintf (file, HOST_WIDEST_INT_PRINT_DEC, e->count);
}
if (e->flags)
if (e->flags && do_details)
{
static const char * const bitnames[] = {
"fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
"can_fallthru", "irreducible", "sibcall", "loop_exit",
"true", "false", "exec", "crossing", "preserve"
};
int comma = 0;
static const char * const bitnames[] =
{
#define DEF_EDGE_FLAG(NAME,IDX) #NAME ,
#include "cfg-flags.def"
NULL
#undef DEF_EDGE_FLAG
};
bool comma = false;
int i, flags = e->flags;
gcc_assert (e->flags <= EDGE_ALL_FLAGS);
fputs (" (", file);
for (i = 0; flags; i++)
if (flags & (1 << i))
@ -483,11 +492,8 @@ dump_edge_info (FILE *file, edge e, int do_succ)
if (comma)
fputc (',', file);
if (i < (int) ARRAY_SIZE (bitnames))
fputs (bitnames[i], file);
else
fprintf (file, "%d", i);
comma = 1;
fputs (bitnames[i], file);
comma = true;
}
fputc (')', file);
@ -641,57 +647,114 @@ free_aux_for_edges (void)
DEBUG_FUNCTION void
debug_bb (basic_block bb)
{
dump_bb (bb, stderr, 0);
dump_bb (stderr, bb, 0, dump_flags | TDF_BLOCKS);
}
DEBUG_FUNCTION basic_block
debug_bb_n (int n)
{
basic_block bb = BASIC_BLOCK (n);
dump_bb (bb, stderr, 0);
debug_bb (bb);
return bb;
}
/* Dumps cfg related information about basic block BB to FILE. */
/* Dumps cfg related information about basic block BB to OUTF.
If HEADER is true, dump things that appear before the instructions
contained in BB. If FOOTER is true, dump things that appear after.
Flags are the TDF_* masks as documented in dumpfile.h.
NB: With TDF_DETAILS, it is assumed that cfun is available, so
that maybe_hot_bb_p and probably_never_executed_bb_p don't ICE. */
static void
dump_cfg_bb_info (FILE *file, basic_block bb)
void
dump_bb_info (FILE *outf, basic_block bb, int indent, int flags,
bool do_header, bool do_footer)
{
unsigned i;
edge_iterator ei;
bool first = true;
edge e;
static const char * const bb_bitnames[] =
{
"new", "reachable", "irreducible_loop", "superblock",
"nosched", "hot", "cold", "dup", "xlabel", "rtl",
"fwdr", "nothrd"
#define DEF_BASIC_BLOCK_FLAG(NAME,IDX) #NAME ,
#include "cfg-flags.def"
NULL
#undef DEF_BASIC_BLOCK_FLAG
};
const unsigned n_bitnames = sizeof (bb_bitnames) / sizeof (char *);
edge e;
char *s_indent = (char *) alloca ((size_t) indent + 1);
memset ((void *) s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';
fprintf (file, "Basic block %d", bb->index);
for (i = 0; i < n_bitnames; i++)
if (bb->flags & (1 << i))
{
if (first)
fputs (" (", file);
else
fputs (", ", file);
first = false;
fputs (bb_bitnames[i], file);
}
if (!first)
putc (')', file);
putc ('\n', file);
gcc_assert (bb->flags <= BB_ALL_FLAGS);
fputs ("Predecessors: ", file);
FOR_EACH_EDGE (e, ei, bb->preds)
dump_edge_info (file, e, 0);
if (do_header)
{
unsigned i;
fprintf (file, "\nSuccessors: ");
FOR_EACH_EDGE (e, ei, bb->succs)
dump_edge_info (file, e, 1);
fputs ("\n\n", file);
if (flags & TDF_COMMENT)
fputs (";; ", outf);
fprintf (outf, "%sbasic block %d", s_indent, bb->index);
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, ", freq %i", bb->frequency);
if (maybe_hot_bb_p (bb))
fputs (", maybe hot", outf);
if (probably_never_executed_bb_p (bb))
fputs (", probably never executed", outf);
}
fputc ('\n', outf);
if (flags & TDF_DETAILS)
{
bool first = true;
if (flags & TDF_COMMENT)
fputs (";; ", outf);
fprintf (outf, "%s prev block ", s_indent);
if (bb->prev_bb)
fprintf (outf, "%d", bb->prev_bb->index);
else
fprintf (outf, "(nil)");
fprintf (outf, ", next block ");
if (bb->next_bb)
fprintf (outf, "%d", bb->next_bb->index);
else
fprintf (outf, "(nil)");
fputs (", flags:", outf);
for (i = 0; i < n_bitnames; i++)
if (bb->flags & (1 << i))
{
if (first)
fputs (" (", outf);
else
fputs (", ", outf);
first = false;
fputs (bb_bitnames[i], outf);
}
if (!first)
fputc (')', outf);
}
fputc ('\n', outf);
if (flags & TDF_COMMENT)
fputs (";; ", outf);
fprintf (outf, "%s pred: ", s_indent);
FOR_EACH_EDGE (e, ei, bb->preds)
dump_edge_info (outf, e, flags, 0);
fputc ('\n', outf);
}
if (do_footer)
{
fputc ('\n', outf);
if (flags & TDF_COMMENT)
fputs (";; ", outf);
fprintf (outf, "%s succ: ", s_indent);
FOR_EACH_EDGE (e, ei, bb->succs)
dump_edge_info (outf, e, flags, 1);
fputs ("\n\n", outf);
}
}
/* Dumps a brief description of cfg to FILE. */
@ -703,7 +766,7 @@ brief_dump_cfg (FILE *file)
FOR_EACH_BB (bb)
{
dump_cfg_bb_info (file, bb);
dump_bb_info (file, bb, 0, 0, true, true);
}
}

86
gcc/cfghooks.c
View File

@ -22,6 +22,7 @@ along with GCC; see the file COPYING3. If not see
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "dumpfile.h"
#include "tm.h"
#include "tree.h"
#include "rtl.h"
@ -183,9 +184,9 @@ verify_flow_info (void)
error ("verify_flow_info: Basic block %d succ edge is corrupted",
bb->index);
fprintf (stderr, "Predecessor: ");
dump_edge_info (stderr, e, 0);
dump_edge_info (stderr, e, TDF_DETAILS, 0);
fprintf (stderr, "\nSuccessor: ");
dump_edge_info (stderr, e, 1);
dump_edge_info (stderr, e, TDF_DETAILS, 1);
fprintf (stderr, "\n");
err = 1;
}
@ -204,9 +205,9 @@ verify_flow_info (void)
{
error ("basic block %d pred edge is corrupted", bb->index);
fputs ("Predecessor: ", stderr);
dump_edge_info (stderr, e, 0);
dump_edge_info (stderr, e, TDF_DETAILS, 0);
fputs ("\nSuccessor: ", stderr);
dump_edge_info (stderr, e, 1);
dump_edge_info (stderr, e, TDF_DETAILS, 1);
fputc ('\n', stderr);
err = 1;
}
@ -217,9 +218,9 @@ verify_flow_info (void)
error ("its dest_idx should be %d, not %d",
ei.index, e->dest_idx);
fputs ("Predecessor: ", stderr);
dump_edge_info (stderr, e, 0);
dump_edge_info (stderr, e, TDF_DETAILS, 0);
fputs ("\nSuccessor: ", stderr);
dump_edge_info (stderr, e, 1);
dump_edge_info (stderr, e, TDF_DETAILS, 1);
fputc ('\n', stderr);
err = 1;
}
@ -260,50 +261,43 @@ verify_flow_info (void)
timevar_pop (TV_CFG_VERIFY);
}
/* Print out one basic block. This function takes care of the purely
graph related information. The cfg hook for the active representation
should dump representation-specific information. */
/* Print out one basic block BB to file OUTF. INDENT is printed at the
start of each new line. FLAGS are the TDF_* flags in dumpfile.h.
This function takes care of the purely graph related information.
The cfg hook for the active representation should dump
representation-specific information. */
void
dump_bb (basic_block bb, FILE *outf, int indent)
dump_bb (FILE *outf, basic_block bb, int indent, int flags)
{
edge e;
edge_iterator ei;
char *s_indent;
s_indent = (char *) alloca ((size_t) indent + 1);
memset (s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';
fprintf (outf, ";;%s basic block %d, loop depth %d, count ",
s_indent, bb->index, bb->loop_depth);
fprintf (outf, HOST_WIDEST_INT_PRINT_DEC, (HOST_WIDEST_INT) bb->count);
putc ('\n', outf);
fprintf (outf, ";;%s prev block ", s_indent);
if (bb->prev_bb)
fprintf (outf, "%d, ", bb->prev_bb->index);
else
fprintf (outf, "(nil), ");
fprintf (outf, "next block ");
if (bb->next_bb)
fprintf (outf, "%d", bb->next_bb->index);
else
fprintf (outf, "(nil)");
putc ('\n', outf);
fprintf (outf, ";;%s pred: ", s_indent);
FOR_EACH_EDGE (e, ei, bb->preds)
dump_edge_info (outf, e, 0);
putc ('\n', outf);
fprintf (outf, ";;%s succ: ", s_indent);
FOR_EACH_EDGE (e, ei, bb->succs)
dump_edge_info (outf, e, 1);
putc ('\n', outf);
dump_bb_info (outf, bb, indent, flags | TDF_COMMENT, true, true);
if (cfg_hooks->dump_bb)
cfg_hooks->dump_bb (bb, outf, indent, 0);
cfg_hooks->dump_bb (outf, bb, indent, flags);
}
/* Dump the complete CFG to FILE. FLAGS are the TDF_* flags in dumpfile.h. */
void
dump_flow_info (FILE *file, int flags)
{
basic_block bb;
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);
}
putc ('\n', file);
}
/* Like above, but dump to stderr. To be called from debuggers. */
void debug_flow_info (void);
DEBUG_FUNCTION void
debug_flow_info (void)
{
dump_flow_info (stderr, TDF_DETAILS);
}
/* Redirect edge E to the given basic block DEST and update underlying program

4
gcc/cfghooks.h
View File

@ -28,7 +28,7 @@ struct cfg_hooks
/* Debugging. */
int (*verify_flow_info) (void);
void (*dump_bb) (basic_block, FILE *, int, int);
void (*dump_bb) (FILE *, basic_block, int, int);
/* Basic CFG manipulation. */
@ -141,7 +141,7 @@ struct cfg_hooks
};
extern void verify_flow_info (void);
extern void dump_bb (basic_block, FILE *, int);
extern void dump_bb (FILE *, basic_block, int, int);
extern edge redirect_edge_and_branch (edge, basic_block);
extern basic_block redirect_edge_and_branch_force (edge, basic_block);
extern bool can_remove_branch_p (const_edge);

146
gcc/cfgrtl.c
View File

@ -88,7 +88,7 @@ static void rtl_delete_block (basic_block);
static basic_block rtl_redirect_edge_and_branch_force (edge, basic_block);
static edge rtl_redirect_edge_and_branch (edge, basic_block);
static basic_block rtl_split_block (basic_block, void *);
static void rtl_dump_bb (basic_block, FILE *, int, int);
static void rtl_dump_bb (FILE *, basic_block, int, int);
static int rtl_verify_flow_info_1 (void);
static void rtl_make_forwarder_block (edge);
@ -1836,10 +1836,11 @@ commit_edge_insertions (void)
/* Print out RTL-specific basic block information (live information
at start and end). */
at start and end with TDF_DETAILS). FLAGS are the TDF_* masks
documented in dumpfile.h. */
static void
rtl_dump_bb (basic_block bb, FILE *outf, int indent, int flags ATTRIBUTE_UNUSED)
rtl_dump_bb (FILE *outf, basic_block bb, int indent, int flags)
{
rtx insn;
rtx last;
@ -1849,7 +1850,7 @@ rtl_dump_bb (basic_block bb, FILE *outf, int indent, int flags ATTRIBUTE_UNUSED)
memset (s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';
if (df)
if (df && (flags & TDF_DETAILS))
{
df_dump_top (bb, outf);
putc ('\n', outf);
@ -1858,9 +1859,15 @@ rtl_dump_bb (basic_block bb, FILE *outf, int indent, int flags ATTRIBUTE_UNUSED)
if (bb->index != ENTRY_BLOCK && bb->index != EXIT_BLOCK)
for (insn = BB_HEAD (bb), last = NEXT_INSN (BB_END (bb)); insn != last;
insn = NEXT_INSN (insn))
print_rtl_single (outf, insn);
{
if (! (flags & TDF_SLIM))
print_rtl_single (outf, insn);
else
dump_insn_slim (outf, insn);
if (df)
}
if (df && (flags & TDF_DETAILS))
{
df_dump_bottom (bb, outf);
putc ('\n', outf);
@ -1869,10 +1876,10 @@ rtl_dump_bb (basic_block bb, FILE *outf, int indent, int flags ATTRIBUTE_UNUSED)
}
/* Like print_rtl, but also print out live information for the start of each
basic block. */
basic block. FLAGS are the flags documented in dumpfile.h. */
void
print_rtl_with_bb (FILE *outf, const_rtx rtx_first)
print_rtl_with_bb (FILE *outf, const_rtx rtx_first, int flags)
{
const_rtx tmp_rtx;
if (rtx_first == 0)
@ -1911,12 +1918,9 @@ print_rtl_with_bb (FILE *outf, const_rtx rtx_first)
for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
{
int did_output;
bool verbose = ((dump_flags & TDF_DETAILS) != 0);
bb = start[INSN_UID (tmp_rtx)];
if (bb != NULL)
dump_bb_info (bb, true, false, verbose, ";; ", outf);
dump_bb_info (outf, bb, 0, dump_flags | TDF_COMMENT, true, false);
if (in_bb_p[INSN_UID (tmp_rtx)] == NOT_IN_BB
&& !NOTE_P (tmp_rtx)
@ -1925,13 +1929,16 @@ print_rtl_with_bb (FILE *outf, const_rtx rtx_first)
else if (in_bb_p[INSN_UID (tmp_rtx)] == IN_MULTIPLE_BB)
fprintf (outf, ";; Insn is in multiple basic blocks\n");
did_output = print_rtl_single (outf, tmp_rtx);
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 (bb, false, true, verbose, ";; ", outf);
if (did_output)
putc ('\n', outf);
dump_bb_info (outf, bb, 0, dump_flags | TDF_COMMENT, false, true);
putc ('\n', outf);
}
free (start);
@ -1948,113 +1955,6 @@ print_rtl_with_bb (FILE *outf, const_rtx rtx_first)
}
}
/* Emit basic block information for BB. HEADER is true if the user wants
the generic information and the predecessors, FOOTER is true if they want
the successors. If VERBOSE is true, emit global register liveness
information. PREFIX is put in front of every line. The output is emitted
to FILE. This function should only be called by RTL CFG users. */
/* FIXME: Dumping of the basic block shared info (index, prev, next, etc.)
is done here and also in dump_bb_header (but to a pretty-printer buffer).
This should be re-factored to give similar dumps for RTL and GIMPLE. */
void
dump_bb_info (basic_block bb, bool header, bool footer, bool verbose,
const char *prefix, FILE *file)
{
edge e;
edge_iterator ei;
if (header)
{
fprintf (file, "\n%sBasic block %d ", prefix, bb->index);
if (bb->prev_bb)
fprintf (file, ", prev %d", bb->prev_bb->index);
if (bb->next_bb)
fprintf (file, ", next %d", bb->next_bb->index);
fprintf (file, ", loop_depth %d, count ", bb->loop_depth);
fprintf (file, HOST_WIDEST_INT_PRINT_DEC, bb->count);
fprintf (file, ", freq %i", bb->frequency);
if (maybe_hot_bb_p (bb))
fputs (", maybe hot", file);
if (probably_never_executed_bb_p (bb))
fputs (", probably never executed", file);
if (bb->flags)
{
static const char * const bits[] = {
"new", "reachable", "irr_loop", "superblock", "disable_sched",
"hot_partition", "cold_partition", "duplicated",
"non_local_goto_target", "rtl", "forwarder", "nonthreadable",
"modified"
};
unsigned int flags;
fputs (", flags:", file);
for (flags = bb->flags; flags ; flags &= flags - 1)
{
unsigned i = ctz_hwi (flags);
if (i < ARRAY_SIZE (bits))
fprintf (file, " %s", bits[i]);
else
fprintf (file, " <%d>", i);
}
}
fputs (".\n", file);
fprintf (file, "%sPredecessors: ", prefix);
FOR_EACH_EDGE (e, ei, bb->preds)
dump_edge_info (file, e, 0);
if (verbose
&& (bb->flags & BB_RTL)
&& df)
{
putc ('\n', file);
df_dump_top (bb, file);
}
}
if (footer)
{
fprintf (file, "\n%sSuccessors: ", prefix);
FOR_EACH_EDGE (e, ei, bb->succs)
dump_edge_info (file, e, 1);
if (verbose
&& (bb->flags & BB_RTL)
&& df)
{
putc ('\n', file);
df_dump_bottom (bb, file);
}
}
putc ('\n', file);
}
void
dump_flow_info (FILE *file, int flags)
{
basic_block bb;
bool verbose = ((flags & TDF_DETAILS) != 0);
fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
FOR_ALL_BB (bb)
{
dump_bb_info (bb, true, true, verbose, "", file);
check_bb_profile (bb, file);
}
putc ('\n', file);
}
void debug_flow_info (void);
DEBUG_FUNCTION void
debug_flow_info (void)
{
dump_flow_info (stderr, TDF_DETAILS);
}
/* Update the branch probability of BB if a REG_BR_PROB is present. */
void

4
gcc/config/rl78/rl78.c
View File

@ -2663,7 +2663,7 @@ rl78_reorg (void)
if (dump_file)
{
fprintf (dump_file, "\n================DEVIRT:=AFTER=ALLOC=PHYSICAL=REGISTERS================\n");
print_rtl_with_bb (dump_file, get_insns ());
print_rtl_with_bb (dump_file, get_insns (), 0);
}
rl78_propogate_register_origins ();
@ -2672,7 +2672,7 @@ rl78_reorg (void)
if (dump_file)
{
fprintf (dump_file, "\n================DEVIRT:=AFTER=PROPOGATION=============================\n");
print_rtl_with_bb (dump_file, get_insns ());
print_rtl_with_bb (dump_file, get_insns (), 0);
fprintf (dump_file, "\n======================================================================\n");
}

1
gcc/dumpfile.h
View File

@ -81,6 +81,7 @@ enum tree_dump_index
#define TDF_ENUMERATE_LOCALS (1 << 22) /* Enumerate locals by uid. */
#define TDF_CSELIB (1 << 23) /* Dump cselib details. */
#define TDF_SCEV (1 << 24) /* Dump SCEV details. */
#define TDF_COMMENT (1 << 25) /* Dump lines with prefix ";;" */
/* In tree-dump.c */

4
gcc/final.c
View File

@ -1799,7 +1799,7 @@ dump_basic_block_info (FILE *file, rtx insn, basic_block *start_to_bb,
fprintf (file, "\n%s PRED:", ASM_COMMENT_START);
FOR_EACH_EDGE (e, ei, bb->preds)
{
dump_edge_info (file, e, 0);
dump_edge_info (file, e, TDF_DETAILS, 0);
}
fprintf (file, "\n");
}
@ -1812,7 +1812,7 @@ dump_basic_block_info (FILE *file, rtx insn, basic_block *start_to_bb,
fprintf (asm_out_file, "%s SUCC:", ASM_COMMENT_START);
FOR_EACH_EDGE (e, ei, bb->succs)
{
dump_edge_info (asm_out_file, e, 1);
dump_edge_info (asm_out_file, e, TDF_DETAILS, 1);
}
fprintf (file, "\n");
}

100
gcc/gimple-pretty-print.c
View File

@ -2059,83 +2059,52 @@ dump_gimple_stmt (pretty_printer *buffer, gimple gs, int spc, int flags)
}
/* Dumps header of basic block BB to buffer BUFFER indented by INDENT
/* Dumps header of basic block BB to OUTF indented by INDENT
spaces and details described by flags. */
static void
dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
dump_gimple_bb_header (FILE *outf, basic_block bb, int indent, int flags)
{
edge e;
gimple stmt;
edge_iterator ei;
if (flags & TDF_BLOCKS)
{
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);
}
dump_bb_info (outf, bb, indent, flags, true, false);
if (flags & TDF_LINENO)
{
gimple_stmt_iterator gsi;
char *s_indent = (char *) alloca ((size_t) indent + 1);
memset (s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';
if (flags & TDF_COMMENT)
fputs (";; ", outf);
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
if (!is_gimple_debug (gsi_stmt (gsi))
&& get_lineno (gsi_stmt (gsi)) != UNKNOWN_LOCATION)
{
pp_string (buffer, ", starting at line ");
pp_decimal_int (buffer, get_lineno (gsi_stmt (gsi)));
fprintf (outf, "%sstarting at line %d",
s_indent, get_lineno (gsi_stmt (gsi)));
break;
}
if (bb->discriminator)
{
pp_string (buffer, ", discriminator ");
pp_decimal_int (buffer, bb->discriminator);
}
if (bb->discriminator)
fprintf (outf, ", discriminator %i", bb->discriminator);
fputc ('\n', outf);
}
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_character (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);
}
else
{
stmt = first_stmt (bb);
gimple stmt = first_stmt (bb);
if (!stmt || gimple_code (stmt) != GIMPLE_LABEL)
{
INDENT (indent - 2);
pp_string (buffer, "<bb ");
pp_decimal_int (buffer, bb->index);
pp_string (buffer, ">:");
pp_newline (buffer);
char *s_indent = (char *) alloca ((size_t) indent - 2 + 1);
memset (s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';
fprintf (outf, "%s<bb %d>:\n", s_indent, bb->index);
}
}
pp_write_text_to_stream (buffer);
if (cfun)
check_bb_profile (bb, buffer->buffer->stream);
check_bb_profile (bb, outf);
}
@ -2143,26 +2112,9 @@ dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
spaces. */
static void
dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
dump_gimple_bb_footer (FILE *outf, 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_character (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_bb_info (outf, bb, indent, flags, false, true);
}
@ -2292,7 +2244,6 @@ gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent,
if (label_indent < 0)
label_indent = 0;
dump_bb_header (buffer, bb, indent, flags);
dump_phi_nodes (buffer, bb, indent, flags);
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
@ -2310,9 +2261,6 @@ gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent,
}
dump_implicit_edges (buffer, bb, indent, flags);
if (flags & TDF_BLOCKS)
dump_bb_end (buffer, bb, indent, flags);
}
@ -2320,9 +2268,11 @@ gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent,
indented by INDENT spaces. */
void
gimple_dump_bb (basic_block bb, FILE *file, int indent, int flags)
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);
dump_gimple_bb_footer (file, bb, indent, flags);
}

7
gcc/ifcvt.c
View File

@ -4391,12 +4391,7 @@ if_convert (void)
#ifdef IFCVT_MULTIPLE_DUMPS
if (dump_file && cond_exec_changed_p)
{
if (dump_flags & TDF_SLIM)
print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
else
print_rtl_with_bb (dump_file, get_insns ());
}
print_rtl_with_bb (dump_file, get_insns (), dump_flags);
#endif
}
while (cond_exec_changed_p);

2
gcc/loop-invariant.c
View File

@ -675,7 +675,7 @@ find_defs (struct loop *loop, basic_block *body)
{
df_dump_region (dump_file);
fprintf (dump_file, "*****starting processing of loop ******\n");
print_rtl_with_bb (dump_file, get_insns ());
print_rtl_with_bb (dump_file, get_insns (), dump_flags);
fprintf (dump_file, "*****ending processing of loop ******\n");
}
check_invariant_table_size ();

8
gcc/passes.c
View File

@ -1725,11 +1725,9 @@ execute_function_dump (void *data ATTRIBUTE_UNUSED)
dump_function_to_file (current_function_decl, dump_file, dump_flags);
else
{
if (dump_flags & TDF_SLIM)
print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
else if ((cfun->curr_properties & PROP_cfg)
&& (dump_flags & TDF_BLOCKS))
print_rtl_with_bb (dump_file, get_insns ());
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 ());

10
gcc/profile.c
View File

@ -276,8 +276,8 @@ is_edge_inconsistent (VEC(edge,gc) *edges)
fprintf (dump_file,
"Edge %i->%i is inconsistent, count"HOST_WIDEST_INT_PRINT_DEC,
e->src->index, e->dest->index, e->count);
dump_bb (e->src, dump_file, 0);
dump_bb (e->dest, dump_file, 0);
dump_bb (dump_file, e->src, 0, TDF_DETAILS);
dump_bb (dump_file, e->dest, 0, TDF_DETAILS);
}
return true;
}
@ -326,7 +326,7 @@ is_inconsistent (void)
HOST_WIDEST_INT_PRINT_DEC,
bb->index,
bb->count);
dump_bb (bb, dump_file, 0);
dump_bb (dump_file, bb, 0, TDF_DETAILS);
}
inconsistent = true;
}
@ -339,7 +339,7 @@ is_inconsistent (void)
bb->index,
bb->count,
sum_edge_counts (bb->preds));
dump_bb (bb, dump_file, 0);
dump_bb (dump_file, bb, 0, TDF_DETAILS);
}
inconsistent = true;
}
@ -353,7 +353,7 @@ is_inconsistent (void)
bb->index,
bb->count,
sum_edge_counts (bb->succs));
dump_bb (bb, dump_file, 0);
dump_bb (dump_file, bb, 0, TDF_DETAILS);
}
inconsistent = true;
}

9
gcc/rtl.h
View File

@ -2460,12 +2460,7 @@ extern void dump_combine_total_stats (FILE *);
extern void delete_dead_jumptables (void);
/* In sched-vis.c. */
extern void debug_bb_n_slim (int);
extern void debug_bb_slim (basic_block);
extern void print_rtl_slim (FILE *, rtx, rtx, int, int);
extern void print_rtl_slim_with_bb (FILE *, rtx, int);
extern void dump_insn_slim (FILE *f, rtx x);
extern void debug_insn_slim (rtx x);
extern void dump_insn_slim (FILE *, const_rtx x);
/* In sched-rgn.c. */
extern void schedule_insns (void);
@ -2508,7 +2503,7 @@ extern HOST_WIDE_INT find_args_size_adjust (rtx);
extern int fixup_args_size_notes (rtx, rtx, int);
/* In cfgrtl.c */
extern void print_rtl_with_bb (FILE *, const_rtx);
extern void print_rtl_with_bb (FILE *, const_rtx, int);
extern rtx duplicate_insn_chain (rtx, rtx);
/* In expmed.c */

3
gcc/sched-rgn.c
View File

@ -396,7 +396,8 @@ debug_region (int rgn)
for (bb = 0; bb < rgn_table[rgn].rgn_nr_blocks; bb++)
{
debug_bb_n_slim (rgn_bb_table[current_blocks + bb]);
dump_bb (stderr, BASIC_BLOCK (rgn_bb_table[current_blocks + bb]),
0, TDF_SLIM);
fprintf (stderr, "\n");
}

46
gcc/sched-vis.c
View File

@ -761,7 +761,7 @@ print_insn (char *buf, const_rtx x, int verbose)
/* Emit a slim dump of X (an insn) to the file F, including any register
note attached to the instruction. */
void
dump_insn_slim (FILE *f, rtx x)
dump_insn_slim (FILE *f, const_rtx x)
{
char t[BUF_LEN + 32];
rtx note;
@ -779,65 +779,41 @@ dump_insn_slim (FILE *f, rtx x)
}
/* Emit a slim dump of X (an insn) to stderr. */
extern void debug_insn_slim (const_rtx);
DEBUG_FUNCTION void
debug_insn_slim (rtx x)
debug_insn_slim (const_rtx x)
{
dump_insn_slim (stderr, x);
}
/* Provide a slim dump the instruction chain starting at FIRST to F, honoring
the dump flags given in FLAGS. Currently, TDF_BLOCKS and TDF_DETAILS
include more information on the basic blocks. */
void
print_rtl_slim_with_bb (FILE *f, rtx first, int flags)
{
print_rtl_slim (f, first, NULL, -1, flags);
}
/* Same as above, but stop at LAST or when COUNT == 0.
If COUNT < 0 it will stop only at LAST or NULL rtx. */
void
print_rtl_slim (FILE *f, rtx first, rtx last, int count, int flags)
extern void debug_rtl_slim (FILE *, const_rtx, const_rtx, int, int);
DEBUG_FUNCTION void
debug_rtl_slim (FILE *f, const_rtx first, const_rtx last,
int count, int flags ATTRIBUTE_UNUSED)
{
basic_block current_bb = NULL;
rtx insn, tail;
const_rtx insn, tail;
tail = last ? NEXT_INSN (last) : NULL_RTX;
for (insn = first;
(insn != NULL) && (insn != tail) && (count != 0);
insn = NEXT_INSN (insn))
{
bool verbose = ((flags & TDF_DETAILS) != 0);
if ((flags & TDF_BLOCKS)
&& (INSN_P (insn) || NOTE_P (insn))
&& BLOCK_FOR_INSN (insn)
&& !current_bb)
{
current_bb = BLOCK_FOR_INSN (insn);
dump_bb_info (current_bb, true, false, verbose, ";; ", f);
}
dump_insn_slim (f, insn);
if ((flags & TDF_BLOCKS)
&& current_bb
&& insn == BB_END (current_bb))
{
dump_bb_info (current_bb, false, true, verbose, ";; ", f);
current_bb = NULL;
}
if (count > 0)
count--;
}
}
extern void debug_bb_slim (basic_block);
DEBUG_FUNCTION void
debug_bb_slim (basic_block bb)
{
print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32);
dump_bb (stderr, bb, 0, TDF_SLIM);
}
extern void debug_bb_n_slim (int);
DEBUG_FUNCTION void
debug_bb_n_slim (int n)
{

2
gcc/trans-mem.c
View File

@ -2576,7 +2576,7 @@ make_tm_edge (gimple stmt, basic_block bb, struct tm_region *region)
n->label_or_list = tree_cons (NULL, dummy.label_or_list, old);
}
make_edge (bb, region->entry_block, EDGE_ABNORMAL | EDGE_ABNORMAL_CALL);
make_edge (bb, region->entry_block, EDGE_ABNORMAL);
}

10
gcc/tree-cfg.c
View File

@ -1448,7 +1448,7 @@ gimple_can_merge_blocks_p (basic_block a, basic_block b)
if (!single_succ_p (a))
return false;
if (single_succ_edge (a)->flags & (EDGE_ABNORMAL | EDGE_EH | EDGE_PRESERVE))
if (single_succ_edge (a)->flags & EDGE_COMPLEX)
return false;
if (single_succ (a) != b)
@ -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 (bb, dump_file, 0);
dump_bb (dump_file, bb, 0, 0);
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)
{
gimple_dump_bb (bb, stderr, 0, TDF_VOPS|TDF_MEMSYMS);
dump_bb (stderr, bb, 0, TDF_VOPS|TDF_MEMSYMS);
}
@ -6695,7 +6695,7 @@ dump_function_to_file (tree fn, FILE *file, int flags)
fprintf (file, "\n");
FOR_EACH_BB (bb)
gimple_dump_bb (bb, file, 2, flags);
gimple_dump_bb (file, bb, 2, flags);
fprintf (file, "}\n");
check_bb_profile (EXIT_BLOCK_PTR, file);
@ -6821,7 +6821,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 (bb, file, indent + 4, TDF_VOPS|TDF_MEMSYMS);
gimple_dump_bb (file, bb, indent + 4, TDF_VOPS|TDF_MEMSYMS);
fprintf (file, "%s }\n", s_indent);
}
}

2
gcc/tree-flow.h
View File

@ -414,7 +414,7 @@ extern bool is_ctrl_altering_stmt (gimple);
extern bool simple_goto_p (gimple);
extern bool stmt_can_make_abnormal_goto (gimple);
extern basic_block single_noncomplex_succ (basic_block bb);
extern void gimple_dump_bb (basic_block, FILE *, int, int);
extern void gimple_dump_bb (FILE *, basic_block, int, int);
extern void gimple_debug_bb (basic_block);
extern basic_block gimple_debug_bb_n (int);
extern void gimple_dump_cfg (FILE *, int);

3
gcc/tree-if-conv.c
View File

@ -819,8 +819,7 @@ if_convertible_bb_p (struct loop *loop, basic_block bb, basic_block exit_bb)
/* Be less adventurous and handle only normal edges. */
FOR_EACH_EDGE (e, ei, bb->succs)
if (e->flags &
(EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_ABNORMAL | EDGE_IRREDUCIBLE_LOOP))
if (e->flags & (EDGE_EH | EDGE_ABNORMAL | EDGE_IRREDUCIBLE_LOOP))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Difficult to handle edges\n");

2
gcc/tree-vrp.c
View File

@ -4121,7 +4121,7 @@ dump_asserts_for (FILE *file, tree name)
{
fprintf (file, "\n\tEDGE %d->%d", loc->e->src->index,
loc->e->dest->index);
dump_edge_info (file, loc->e, 0);
dump_edge_info (file, loc->e, dump_flags, 0);
}
fprintf (file, "\n\tPREDICATE: ");
print_generic_expr (file, name, 0);