/* Control flow graph manipulation code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GCC.
#include "output.h"
#include "function.h"
#include "except.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
#include "tm_p.h"
#include "obstack.h"
#include "timevar.h"
init_flow (struct function *the_fun)
{
if (!the_fun->cfg)
- the_fun->cfg = GGC_CNEW (struct control_flow_graph);
+ the_fun->cfg = ggc_alloc_cleared_control_flow_graph ();
n_edges_for_function (the_fun) = 0;
ENTRY_BLOCK_PTR_FOR_FUNCTION (the_fun)
- = GGC_CNEW (struct basic_block_def);
+ = ggc_alloc_cleared_basic_block_def ();
ENTRY_BLOCK_PTR_FOR_FUNCTION (the_fun)->index = ENTRY_BLOCK;
EXIT_BLOCK_PTR_FOR_FUNCTION (the_fun)
- = GGC_CNEW (struct basic_block_def);
+ = ggc_alloc_cleared_basic_block_def ();
EXIT_BLOCK_PTR_FOR_FUNCTION (the_fun)->index = EXIT_BLOCK;
- ENTRY_BLOCK_PTR_FOR_FUNCTION (the_fun)->next_bb
+ ENTRY_BLOCK_PTR_FOR_FUNCTION (the_fun)->next_bb
= EXIT_BLOCK_PTR_FOR_FUNCTION (the_fun);
- EXIT_BLOCK_PTR_FOR_FUNCTION (the_fun)->prev_bb
+ EXIT_BLOCK_PTR_FOR_FUNCTION (the_fun)->prev_bb
= ENTRY_BLOCK_PTR_FOR_FUNCTION (the_fun);
}
\f
alloc_block (void)
{
basic_block bb;
- bb = GGC_CNEW (struct basic_block_def);
+ bb = ggc_alloc_cleared_basic_block_def ();
return bb;
}
SET_BASIC_BLOCK (ENTRY_BLOCK, ENTRY_BLOCK_PTR);
SET_BASIC_BLOCK (EXIT_BLOCK, EXIT_BLOCK_PTR);
-
+
if (df)
df_compact_blocks ();
- else
+ else
{
basic_block bb;
-
+
i = NUM_FIXED_BLOCKS;
FOR_EACH_BB (bb)
{
unchecked_make_edge (basic_block src, basic_block dst, int flags)
{
edge e;
- e = GGC_CNEW (struct edge_def);
+ e = ggc_alloc_cleared_edge_def ();
n_edges++;
e->src = src;
if (s->probability > REG_BR_PROB_BASE)
s->probability = REG_BR_PROB_BASE;
s->count += e->count;
- remove_edge (e);
redirect_edge_var_map_dup (s, e);
+ remove_edge (e);
e = s;
}
else
basic_block bb;
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
- bb->flags = (BB_PARTITION (bb)
+ bb->flags = (BB_PARTITION (bb)
| (bb->flags & (BB_DISABLE_SCHEDULE + BB_RTL + BB_NON_LOCAL_GOTO_TARGET)));
}
\f
stream. This function is designed to be used from within the
debugger. */
-void
+DEBUG_FUNCTION void
debug_regset (regset r)
{
dump_regset (r, stderr);
fprintf (file, HOST_WIDEST_INT_PRINT_DEC, bb->count);
fprintf (file, ", freq %i", bb->frequency);
/* Both maybe_hot_bb_p & probably_never_executed_bb_p functions
- crash without cfun. */
+ crash without cfun. */
if (cfun && maybe_hot_bb_p (bb))
- fprintf (file, ", maybe hot");
+ fputs (", maybe hot", file);
if (cfun && probably_never_executed_bb_p (bb))
- fprintf (file, ", probably never executed");
- fprintf (file, ".\n");
+ 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)
&& (bb->flags & BB_RTL)
&& df)
{
- fprintf (file, "\n");
+ putc ('\n', file);
df_dump_top (bb, file);
}
}
&& (bb->flags & BB_RTL)
&& df)
{
- fprintf (file, "\n");
+ putc ('\n', file);
df_dump_bottom (bb, file);
}
}
/* Dump the register info to FILE. */
-void
+void
dump_reg_info (FILE *file)
{
unsigned int i, max = max_reg_num ();
for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
{
enum reg_class rclass, altclass;
-
+
if (regstat_n_sets_and_refs)
fprintf (file, "\nRegister %d used %d times across %d insns",
i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
else if (df)
fprintf (file, "\nRegister %d used %d times across %d insns",
i, DF_REG_USE_COUNT (i) + DF_REG_DEF_COUNT (i), REG_LIVE_LENGTH (i));
-
+
if (REG_BASIC_BLOCK (i) >= NUM_FIXED_BLOCKS)
fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
if (regstat_n_sets_and_refs)
fprintf (file, "; set %d time%s", DF_REG_DEF_COUNT (i),
(DF_REG_DEF_COUNT (i) == 1) ? "" : "s");
if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
- fprintf (file, "; user var");
+ fputs ("; user var", file);
if (REG_N_DEATHS (i) != 1)
fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
if (REG_N_CALLS_CROSSED (i) == 1)
- fprintf (file, "; crosses 1 call");
+ fputs ("; crosses 1 call", file);
else if (REG_N_CALLS_CROSSED (i))
fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
if (REG_FREQ_CALLS_CROSSED (i))
if (regno_reg_rtx[i] != NULL
&& PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
-
+
rclass = reg_preferred_class (i);
altclass = reg_alternate_class (i);
if (rclass != GENERAL_REGS || altclass != ALL_REGS)
reg_class_names[(int) rclass],
reg_class_names[(int) altclass]);
}
-
+
if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
- fprintf (file, "; pointer");
- fprintf (file, ".\n");
+ fputs ("; pointer", file);
+ fputs (".\n", file);
}
}
putc ('\n', file);
}
-void
+DEBUG_FUNCTION void
debug_flow_info (void)
{
dump_flow_info (stderr, TDF_DETAILS);
if (e->count)
{
- fprintf (file, " count:");
+ fputs (" count:", file);
fprintf (file, HOST_WIDEST_INT_PRINT_DEC, e->count);
}
static const char * const bitnames[] = {
"fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
"can_fallthru", "irreducible", "sibcall", "loop_exit",
- "true", "false", "exec"
+ "true", "false", "exec", "crossing", "preserve"
};
int comma = 0;
int i, flags = e->flags;
/* Allocate a memory block of SIZE as BB->aux. The obstack must
be first initialized by alloc_aux_for_blocks. */
-inline void
+static void
alloc_aux_for_block (basic_block bb, int size)
{
/* Verify that aux field is clear. */
{
basic_block bb;
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
+ FOR_ALL_BB (bb)
alloc_aux_for_block (bb, size);
}
}
{
basic_block bb;
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
+ FOR_ALL_BB (bb)
bb->aux = NULL;
}
/* Allocate a memory edge of SIZE as BB->aux. The obstack must
be first initialized by alloc_aux_for_edges. */
-inline void
+static void
alloc_aux_for_edge (edge e, int size)
{
/* Verify that aux field is clear. */
clear_aux_for_edges ();
}
-void
+DEBUG_FUNCTION void
debug_bb (basic_block bb)
{
dump_bb (bb, stderr, 0);
}
-basic_block
+DEBUG_FUNCTION basic_block
debug_bb_n (int n)
{
basic_block bb = BASIC_BLOCK (n);
if (bb->flags & (1 << i))
{
if (first)
- fprintf (file, " (");
+ fputs (" (", file);
else
- fprintf (file, ", ");
+ fputs (", ", file);
first = false;
- fprintf (file, bb_bitnames[i]);
+ fputs (bb_bitnames[i], file);
}
if (!first)
- fprintf (file, ")");
- fprintf (file, "\n");
+ putc (')', file);
+ putc ('\n', file);
- fprintf (file, "Predecessors: ");
+ 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);
- fprintf (file, "\n\n");
+ fputs ("\n\n", file);
}
/* Dumps a brief description of cfg to FILE. */
OSDN Git Service
