+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
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 */
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)
/* 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;
};
#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
+
+/* Bit mask for all edge flags. */
+#define BB_ALL_FLAGS ((LAST_CFG_BB_FLAG - 1) * 2 - 1)
-/* Dummy flag for convenience in the hot/cold partitioning code. */
+/* 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
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);
--- /dev/null
+/* 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:
+*/
}
\f
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)
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))
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);
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);
-
- fputs ("Predecessors: ", file);
- FOR_EACH_EDGE (e, ei, bb->preds)
- dump_edge_info (file, e, 0);
-
- fprintf (file, "\nSuccessors: ");
- FOR_EACH_EDGE (e, ei, bb->succs)
- dump_edge_info (file, e, 1);
- fputs ("\n\n", file);
+ gcc_assert (bb->flags <= BB_ALL_FLAGS);
+
+ if (do_header)
+ {
+ unsigned i;
+
+ 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. */
FOR_EACH_BB (bb)
{
- dump_cfg_bb_info (file, bb);
+ dump_bb_info (file, bb, 0, 0, true, true);
}
}
#include "config.h"
#include "system.h"
#include "coretypes.h"
+#include "dumpfile.h"
#include "tm.h"
#include "tree.h"
#include "rtl.h"
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;
}
{
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;
}
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;
}
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);
+ dump_bb_info (outf, bb, indent, flags | TDF_COMMENT, true, true);
+ if (cfg_hooks->dump_bb)
+ cfg_hooks->dump_bb (outf, bb, indent, flags);
+}
- 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);
+/* 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 (outf, ";;%s pred: ", s_indent);
- FOR_EACH_EDGE (e, ei, bb->preds)
- dump_edge_info (outf, e, 0);
- putc ('\n', outf);
+ 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);
+ }
- fprintf (outf, ";;%s succ: ", s_indent);
- FOR_EACH_EDGE (e, ei, bb->succs)
- dump_edge_info (outf, e, 1);
- putc ('\n', outf);
+ putc ('\n', file);
+}
- if (cfg_hooks->dump_bb)
- cfg_hooks->dump_bb (bb, outf, indent, 0);
+/* 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
/* 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. */
};
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);
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);
\f
\f
/* 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;
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);
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);
}
\f
/* 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)
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)
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);
}
}
\f
-/* 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);
-}
-\f
/* Update the branch probability of BB if a REG_BR_PROB is present. */
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 ();
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");
}
#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 */
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");
}
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");
}
}
-/* 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);
}
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);
}
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))
}
dump_implicit_edges (buffer, bb, indent, flags);
-
- if (flags & TDF_BLOCKS)
- dump_bb_end (buffer, bb, indent, flags);
}
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);
}
#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);
{
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 ();
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 ());
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;
}
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;
}
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;
}
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;
}
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);
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 */
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");
}
/* 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;
}
/* 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)
{
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);
}
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)
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");
}
}
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);
}
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);
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);
}
}
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);
/* 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");
{
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);
projects / platform / upstream / linaro-gcc.git / commitdiff