/* Control flow graph manipulation code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
02111-1307, USA. */
/* This file contains low level functions to manipulate the CFG and
- analyze it. All other modules should not transform the datastructure
+ analyze it. All other modules should not transform the data structure
directly and use abstraction instead. The file is supposed to be
ordered bottom-up and should not contain any code dependent on a
particular intermediate language (RTL or trees).
- Allocation of AUX fields for basic blocks
alloc_aux_for_blocks, free_aux_for_blocks, alloc_aux_for_block
- clear_bb_flags
+ - Consistency checking
+ verify_flow_info
+ - Dumping and debugging
+ print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n
*/
\f
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "tree.h"
#include "rtl.h"
#include "hard-reg-set.h"
#include "toplev.h"
#include "tm_p.h"
#include "obstack.h"
+#include "alloc-pool.h"
/* The obstack on which the flow graph components are allocated. */
struct obstack flow_obstack;
static char *flow_firstobj;
+/* Basic block object pool. */
+
+static alloc_pool bb_pool;
+
+/* Edge object pool. */
+
+static alloc_pool edge_pool;
+
/* Number of basic blocks in the current function. */
int n_basic_blocks;
-/* Number of edges in the current function. */
+/* First free basic block number. */
-int n_edges;
+int last_basic_block;
-/* First edge in the deleted edges chain. */
+/* Number of edges in the current function. */
-edge first_deleted_edge;
-static basic_block first_deleted_block;
+int n_edges;
/* The basic block array. */
NULL, /* global_live_at_end */
NULL, /* aux */
ENTRY_BLOCK, /* index */
+ NULL, /* prev_bb */
+ EXIT_BLOCK_PTR, /* next_bb */
0, /* loop_depth */
+ NULL, /* loop_father */
+ { NULL, NULL }, /* dom */
0, /* count */
0, /* frequency */
- 0 /* flags */
+ 0, /* flags */
+ NULL /* rbi */
},
{
NULL, /* head */
NULL, /* global_live_at_end */
NULL, /* aux */
EXIT_BLOCK, /* index */
+ ENTRY_BLOCK_PTR, /* prev_bb */
+ NULL, /* next_bb */
0, /* loop_depth */
+ NULL, /* loop_father */
+ { NULL, NULL }, /* dom */
0, /* count */
0, /* frequency */
- 0 /* flags */
+ 0, /* flags */
+ NULL /* rbi */
}
};
-void debug_flow_info PARAMS ((void));
-static void free_edge PARAMS ((edge));
+void debug_flow_info (void);
+static void free_edge (edge);
\f
/* Called once at initialization time. */
void
-init_flow ()
+init_flow (void)
{
static int initialized;
- first_deleted_edge = 0;
- first_deleted_block = 0;
n_edges = 0;
if (!initialized)
{
gcc_obstack_init (&flow_obstack);
- flow_firstobj = (char *) obstack_alloc (&flow_obstack, 0);
+ flow_firstobj = obstack_alloc (&flow_obstack, 0);
initialized = 1;
}
else
{
+ free_alloc_pool (bb_pool);
+ free_alloc_pool (edge_pool);
obstack_free (&flow_obstack, flow_firstobj);
- flow_firstobj = (char *) obstack_alloc (&flow_obstack, 0);
+ flow_firstobj = obstack_alloc (&flow_obstack, 0);
}
+ bb_pool = create_alloc_pool ("Basic block pool",
+ sizeof (struct basic_block_def), 100);
+ edge_pool = create_alloc_pool ("Edge pool",
+ sizeof (struct edge_def), 100);
}
\f
/* Helper function for remove_edge and clear_edges. Frees edge structure
without actually unlinking it from the pred/succ lists. */
static void
-free_edge (e)
- edge e;
+free_edge (edge e)
{
n_edges--;
- memset (e, 0, sizeof *e);
- e->succ_next = first_deleted_edge;
- first_deleted_edge = e;
+ pool_free (edge_pool, e);
}
/* Free the memory associated with the edge structures. */
void
-clear_edges ()
+clear_edges (void)
{
- int i;
+ basic_block bb;
edge e;
- for (i = 0; i < n_basic_blocks; ++i)
+ FOR_EACH_BB (bb)
{
- basic_block bb = BASIC_BLOCK (i);
edge e = bb->succ;
while (e)
/* Allocate memory for basic_block. */
basic_block
-alloc_block ()
+alloc_block (void)
{
basic_block bb;
-
- if (first_deleted_block)
- {
- bb = first_deleted_block;
- first_deleted_block = (basic_block) bb->succ;
- bb->succ = NULL;
- }
- else
- {
- bb = (basic_block) obstack_alloc (&flow_obstack, sizeof *bb);
- memset (bb, 0, sizeof *bb);
- }
+ bb = pool_alloc (bb_pool);
+ memset (bb, 0, sizeof (*bb));
return bb;
}
-/* Remove block B from the basic block array and compact behind it. */
+/* Link block B to chain after AFTER. */
+void
+link_block (basic_block b, basic_block after)
+{
+ b->next_bb = after->next_bb;
+ b->prev_bb = after;
+ after->next_bb = b;
+ b->next_bb->prev_bb = b;
+}
+/* Unlink block B from chain. */
void
-expunge_block (b)
- basic_block b;
+unlink_block (basic_block b)
{
- int i, n = n_basic_blocks;
+ b->next_bb->prev_bb = b->prev_bb;
+ b->prev_bb->next_bb = b->next_bb;
+}
+
+/* Sequentially order blocks and compact the arrays. */
+void
+compact_blocks (void)
+{
+ int i;
+ basic_block bb;
- for (i = b->index; i + 1 < n; ++i)
+ i = 0;
+ FOR_EACH_BB (bb)
{
- basic_block x = BASIC_BLOCK (i + 1);
- BASIC_BLOCK (i) = x;
- x->index = i;
+ BASIC_BLOCK (i) = bb;
+ bb->index = i;
+ i++;
}
- /* Invalidate data to make bughunting easier. */
- memset (b, 0, sizeof *b);
- b->index = -3;
- basic_block_info->num_elements--;
+ if (i != n_basic_blocks)
+ abort ();
+
+ last_basic_block = n_basic_blocks;
+}
+
+/* Remove block B from the basic block array. */
+
+void
+expunge_block (basic_block b)
+{
+ unlink_block (b);
+ BASIC_BLOCK (b->index) = NULL;
n_basic_blocks--;
- b->succ = (edge) first_deleted_block;
- first_deleted_block = (basic_block) b;
+ pool_free (bb_pool, b);
}
\f
+/* Create an edge connecting SRC and DEST with flags FLAGS. Return newly
+ created edge. Use this only if you are sure that this edge can't
+ possibly already exist. */
+
+edge
+unchecked_make_edge (basic_block src, basic_block dst, int flags)
+{
+ edge e;
+ e = pool_alloc (edge_pool);
+ memset (e, 0, sizeof (*e));
+ n_edges++;
+
+ e->succ_next = src->succ;
+ e->pred_next = dst->pred;
+ e->src = src;
+ e->dest = dst;
+ e->flags = flags;
+
+ src->succ = e;
+ dst->pred = e;
+
+ return e;
+}
+
/* Create an edge connecting SRC and DST with FLAGS optionally using
edge cache CACHE. Return the new edge, NULL if already exist. */
edge
-cached_make_edge (edge_cache, src, dst, flags)
- sbitmap *edge_cache;
- basic_block src, dst;
- int flags;
+cached_make_edge (sbitmap *edge_cache, basic_block src, basic_block dst, int flags)
{
int use_edge_cache;
edge e;
if (flags == 0)
return NULL;
- /* FALLTHRU */
+ /* Fall through. */
case 0:
for (e = src->succ; e; e = e->succ_next)
if (e->dest == dst)
break;
}
- if (first_deleted_edge)
- {
- e = first_deleted_edge;
- first_deleted_edge = e->succ_next;
- }
- else
- {
- e = (edge) obstack_alloc (&flow_obstack, sizeof *e);
- memset (e, 0, sizeof *e);
- }
- n_edges++;
-
- e->succ_next = src->succ;
- e->pred_next = dst->pred;
- e->src = src;
- e->dest = dst;
- e->flags = flags;
-
- src->succ = e;
- dst->pred = e;
+ e = unchecked_make_edge (src, dst, flags);
if (use_edge_cache)
SET_BIT (edge_cache[src->index], dst->index);
created edge or NULL if already exist. */
edge
-make_edge (src, dest, flags)
- basic_block src, dest;
- int flags;
+make_edge (basic_block src, basic_block dest, int flags)
{
return cached_make_edge (NULL, src, dest, flags);
}
that it is the single edge leaving SRC. */
edge
-make_single_succ_edge (src, dest, flags)
- basic_block src, dest;
- int flags;
+make_single_succ_edge (basic_block src, basic_block dest, int flags)
{
edge e = make_edge (src, dest, flags);
/* This function will remove an edge from the flow graph. */
void
-remove_edge (e)
- edge e;
+remove_edge (edge e)
{
edge last_pred = NULL;
edge last_succ = NULL;
/* Redirect an edge's successor from one block to another. */
void
-redirect_edge_succ (e, new_succ)
- edge e;
- basic_block new_succ;
+redirect_edge_succ (edge e, basic_block new_succ)
{
edge *pe;
/* Like previous but avoid possible duplicate edge. */
edge
-redirect_edge_succ_nodup (e, new_succ)
- edge e;
- basic_block new_succ;
+redirect_edge_succ_nodup (edge e, basic_block new_succ)
{
edge s;
{
s->flags |= e->flags;
s->probability += e->probability;
+ if (s->probability > REG_BR_PROB_BASE)
+ s->probability = REG_BR_PROB_BASE;
s->count += e->count;
remove_edge (e);
e = s;
/* Redirect an edge's predecessor from one block to another. */
void
-redirect_edge_pred (e, new_pred)
- edge e;
- basic_block new_pred;
+redirect_edge_pred (edge e, basic_block new_pred)
{
edge *pe;
}
void
-clear_bb_flags ()
+clear_bb_flags (void)
{
- int i;
- ENTRY_BLOCK_PTR->flags = 0;
- EXIT_BLOCK_PTR->flags = 0;
- for (i = 0; i < n_basic_blocks; i++)
- BASIC_BLOCK (i)->flags = 0;
+ basic_block bb;
+
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
+ bb->flags = 0;
}
\f
void
-dump_flow_info (file)
- FILE *file;
+dump_flow_info (FILE *file)
{
int i;
+ int max_regno = max_reg_num ();
+ basic_block bb;
static const char * const reg_class_names[] = REG_CLASS_NAMES;
fprintf (file, "%d registers.\n", max_regno);
- for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
- if (REG_N_REFS (i))
- {
- enum reg_class class, altclass;
-
- fprintf (file, "\nRegister %d used %d times across %d insns",
- i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
- if (REG_BASIC_BLOCK (i) >= 0)
- fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
- if (REG_N_SETS (i))
- fprintf (file, "; set %d time%s", REG_N_SETS (i),
- (REG_N_SETS (i) == 1) ? "" : "s");
- if (REG_USERVAR_P (regno_reg_rtx[i]))
- fprintf (file, "; user var");
- 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");
- else if (REG_N_CALLS_CROSSED (i))
- fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
- if (PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
- fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
-
- class = reg_preferred_class (i);
- altclass = reg_alternate_class (i);
- if (class != GENERAL_REGS || altclass != ALL_REGS)
- {
- if (altclass == ALL_REGS || class == ALL_REGS)
- fprintf (file, "; pref %s", reg_class_names[(int) class]);
- else if (altclass == NO_REGS)
- fprintf (file, "; %s or none", reg_class_names[(int) class]);
- else
- fprintf (file, "; pref %s, else %s",
- reg_class_names[(int) class],
- reg_class_names[(int) altclass]);
- }
-
- if (REG_POINTER (regno_reg_rtx[i]))
- fprintf (file, "; pointer");
- fprintf (file, ".\n");
- }
+ if (reg_n_info)
+ for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
+ if (REG_N_REFS (i))
+ {
+ enum reg_class class, altclass;
+
+ fprintf (file, "\nRegister %d used %d times across %d insns",
+ i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
+ if (REG_BASIC_BLOCK (i) >= 0)
+ fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
+ if (REG_N_SETS (i))
+ fprintf (file, "; set %d time%s", REG_N_SETS (i),
+ (REG_N_SETS (i) == 1) ? "" : "s");
+ if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
+ fprintf (file, "; user var");
+ 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");
+ else if (REG_N_CALLS_CROSSED (i))
+ fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
+ if (regno_reg_rtx[i] != NULL
+ && PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
+ fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
+
+ class = reg_preferred_class (i);
+ altclass = reg_alternate_class (i);
+ if (class != GENERAL_REGS || altclass != ALL_REGS)
+ {
+ if (altclass == ALL_REGS || class == ALL_REGS)
+ fprintf (file, "; pref %s", reg_class_names[(int) class]);
+ else if (altclass == NO_REGS)
+ fprintf (file, "; %s or none", reg_class_names[(int) class]);
+ else
+ fprintf (file, "; pref %s, else %s",
+ reg_class_names[(int) class],
+ reg_class_names[(int) altclass]);
+ }
+
+ if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
+ fprintf (file, "; pointer");
+ fprintf (file, ".\n");
+ }
fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
- for (i = 0; i < n_basic_blocks; i++)
+ FOR_EACH_BB (bb)
{
- basic_block bb = BASIC_BLOCK (i);
edge e;
+ int sum;
+ gcov_type lsum;
fprintf (file, "\nBasic block %d: first insn %d, last %d, ",
- i, INSN_UID (bb->head), INSN_UID (bb->end));
+ bb->index, INSN_UID (BB_HEAD (bb)), INSN_UID (BB_END (bb)));
+ fprintf (file, "prev %d, next %d, ",
+ bb->prev_bb->index, 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.\n", bb->frequency);
+ fprintf (file, ", freq %i", bb->frequency);
+ if (maybe_hot_bb_p (bb))
+ fprintf (file, ", maybe hot");
+ if (probably_never_executed_bb_p (bb))
+ fprintf (file, ", probably never executed");
+ fprintf (file, ".\n");
fprintf (file, "Predecessors: ");
for (e = bb->pred; e; e = e->pred_next)
dump_regset (bb->global_live_at_end, file);
putc ('\n', file);
+
+ /* Check the consistency of profile information. We can't do that
+ in verify_flow_info, as the counts may get invalid for incompletely
+ solved graphs, later eliminating of conditionals or roundoff errors.
+ It is still practical to have them reported for debugging of simple
+ testcases. */
+ sum = 0;
+ for (e = bb->succ; e; e = e->succ_next)
+ sum += e->probability;
+ if (bb->succ && abs (sum - REG_BR_PROB_BASE) > 100)
+ fprintf (file, "Invalid sum of outgoing probabilities %.1f%%\n",
+ sum * 100.0 / REG_BR_PROB_BASE);
+ sum = 0;
+ for (e = bb->pred; e; e = e->pred_next)
+ sum += EDGE_FREQUENCY (e);
+ if (abs (sum - bb->frequency) > 100)
+ fprintf (file,
+ "Invalid sum of incomming frequencies %i, should be %i\n",
+ sum, bb->frequency);
+ lsum = 0;
+ for (e = bb->pred; e; e = e->pred_next)
+ lsum += e->count;
+ if (lsum - bb->count > 100 || lsum - bb->count < -100)
+ fprintf (file, "Invalid sum of incomming counts %i, should be %i\n",
+ (int)lsum, (int)bb->count);
+ lsum = 0;
+ for (e = bb->succ; e; e = e->succ_next)
+ lsum += e->count;
+ if (bb->succ && (lsum - bb->count > 100 || lsum - bb->count < -100))
+ fprintf (file, "Invalid sum of incomming counts %i, should be %i\n",
+ (int)lsum, (int)bb->count);
}
putc ('\n', file);
}
void
-debug_flow_info ()
+debug_flow_info (void)
{
dump_flow_info (stderr);
}
void
-dump_edge_info (file, e, do_succ)
- FILE *file;
- edge e;
- int do_succ;
+dump_edge_info (FILE *file, edge e, int do_succ)
{
basic_block side = (do_succ ? e->dest : e->src);
if (e->flags)
{
- static const char * const bitnames[]
- = {"fallthru", "ab", "abcall", "eh", "fake", "dfs_back"};
+ static const char * const bitnames[] = {
+ "fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
+ "can_fallthru", "irreducible", "sibcall", "loop_exit"
+ };
int comma = 0;
int i, flags = e->flags;
static struct obstack edge_aux_obstack;
static void *first_edge_aux_obj = 0;
-/* Allocate an memory block of SIZE as BB->aux. The obstack must
+/* Allocate a memory block of SIZE as BB->aux. The obstack must
be first initialized by alloc_aux_for_blocks. */
inline void
-alloc_aux_for_block (bb, size)
- basic_block bb;
- int size;
+alloc_aux_for_block (basic_block bb, int size)
{
/* Verify that aux field is clear. */
if (bb->aux || !first_block_aux_obj)
alloc_aux_for_block for each basic block. */
void
-alloc_aux_for_blocks (size)
- int size;
+alloc_aux_for_blocks (int size)
{
static int initialized;
/* Check whether AUX data are still allocated. */
else if (first_block_aux_obj)
abort ();
- first_block_aux_obj = (char *) obstack_alloc (&block_aux_obstack, 0);
+ first_block_aux_obj = obstack_alloc (&block_aux_obstack, 0);
if (size)
{
- int i;
-
- for (i = 0; i < n_basic_blocks; i++)
- alloc_aux_for_block (BASIC_BLOCK (i), size);
+ basic_block bb;
- alloc_aux_for_block (ENTRY_BLOCK_PTR, size);
- alloc_aux_for_block (EXIT_BLOCK_PTR, size);
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
+ alloc_aux_for_block (bb, size);
}
}
/* Clear AUX pointers of all blocks. */
void
-clear_aux_for_blocks ()
+clear_aux_for_blocks (void)
{
- int i;
-
- for (i = 0; i < n_basic_blocks; i++)
- BASIC_BLOCK (i)->aux = NULL;
+ basic_block bb;
- ENTRY_BLOCK_PTR->aux = NULL;
- EXIT_BLOCK_PTR->aux = NULL;
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
+ bb->aux = NULL;
}
/* Free data allocated in block_aux_obstack and clear AUX pointers
of all blocks. */
void
-free_aux_for_blocks ()
+free_aux_for_blocks (void)
{
if (!first_block_aux_obj)
abort ();
clear_aux_for_blocks ();
}
-/* Allocate an memory edge of SIZE as BB->aux. The obstack must
+/* Allocate a memory edge of SIZE as BB->aux. The obstack must
be first initialized by alloc_aux_for_edges. */
inline void
-alloc_aux_for_edge (e, size)
- edge e;
- int size;
+alloc_aux_for_edge (edge e, int size)
{
/* Verify that aux field is clear. */
if (e->aux || !first_edge_aux_obj)
alloc_aux_for_edge for each basic edge. */
void
-alloc_aux_for_edges (size)
- int size;
+alloc_aux_for_edges (int size)
{
static int initialized;
else if (first_edge_aux_obj)
abort ();
- first_edge_aux_obj = (char *) obstack_alloc (&edge_aux_obstack, 0);
+ first_edge_aux_obj = obstack_alloc (&edge_aux_obstack, 0);
if (size)
{
- int i;
- for (i = -1; i < n_basic_blocks; i++)
+ basic_block bb;
+
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
{
- basic_block bb;
edge e;
- if (i >= 0)
- bb = BASIC_BLOCK (i);
- else
- bb = ENTRY_BLOCK_PTR;
-
for (e = bb->succ; e; e = e->succ_next)
alloc_aux_for_edge (e, size);
}
/* Clear AUX pointers of all edges. */
void
-clear_aux_for_edges ()
+clear_aux_for_edges (void)
{
- int i;
+ basic_block bb;
+ edge e;
- for (i = -1; i < n_basic_blocks; i++)
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
{
- basic_block bb;
- edge e;
-
- if (i >= 0)
- bb = BASIC_BLOCK (i);
- else
- bb = ENTRY_BLOCK_PTR;
-
for (e = bb->succ; e; e = e->succ_next)
e->aux = NULL;
}
of all edges. */
void
-free_aux_for_edges ()
+free_aux_for_edges (void)
{
if (!first_edge_aux_obj)
abort ();
clear_aux_for_edges ();
}
+
+void
+debug_bb (basic_block bb)
+{
+ dump_bb (bb, stderr, 0);
+}
+
+basic_block
+debug_bb_n (int n)
+{
+ basic_block bb = BASIC_BLOCK (n);
+ dump_bb (bb, stderr, 0);
+ return bb;
+}
OSDN Git Service
