/* Control flow graph manipulation code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002 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"
EXIT_BLOCK_PTR, /* next_bb */
0, /* loop_depth */
NULL, /* loop_father */
+ { NULL, NULL }, /* dom */
0, /* count */
0, /* frequency */
- 0 /* flags */
+ 0, /* flags */
+ 0, /* partition */
+ NULL /* rbi */
},
{
NULL, /* head */
NULL, /* next_bb */
0, /* loop_depth */
NULL, /* loop_father */
+ { NULL, NULL }, /* dom */
0, /* count */
0, /* frequency */
- 0 /* flags */
+ 0, /* flags */
+ 0, /* partition */
+ 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;
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",
+ 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);
without actually unlinking it from the pred/succ lists. */
static void
-free_edge (e)
- edge e;
+free_edge (edge e)
{
n_edges--;
pool_free (edge_pool, e);
/* Free the memory associated with the edge structures. */
void
-clear_edges ()
+clear_edges (void)
{
basic_block bb;
edge e;
/* Allocate memory for basic_block. */
basic_block
-alloc_block ()
+alloc_block (void)
{
basic_block bb;
bb = pool_alloc (bb_pool);
/* Link block B to chain after AFTER. */
void
-link_block (b, after)
- basic_block b, after;
+link_block (basic_block b, basic_block after)
{
b->next_bb = after->next_bb;
b->prev_bb = after;
/* Unlink block B from chain. */
void
-unlink_block (b)
- basic_block b;
+unlink_block (basic_block b)
{
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 ()
+compact_blocks (void)
{
int i;
basic_block bb;
-
+
i = 0;
FOR_EACH_BB (bb)
{
/* Remove block B from the basic block array. */
void
-expunge_block (b)
- basic_block b;
+expunge_block (basic_block b)
{
unlink_block (b);
BASIC_BLOCK (b->index) = NULL;
possibly already exist. */
edge
-unchecked_make_edge (src, dst, flags)
- basic_block src, dst;
- int flags;
+unchecked_make_edge (basic_block src, basic_block dst, int flags)
{
edge e;
e = pool_alloc (edge_pool);
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;
}
-
+
e = unchecked_make_edge (src, dst, flags);
if (use_edge_cache)
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;
/* 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)
{
basic_block bb;
}
\f
void
-dump_flow_info (file)
- FILE *file;
+dump_flow_info (FILE *file)
{
int i;
int max_regno = max_reg_num ();
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 (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");
- }
+ 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_EACH_BB (bb)
gcov_type lsum;
fprintf (file, "\nBasic block %d: first insn %d, last %d, ",
- bb->index, 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);
}
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);
{
static const char * const bitnames[] = {
"fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
- "can_fallthru", "irreducible", "sibcall"
+ "can_fallthru", "irreducible", "sibcall", "loop_exit"
};
int comma = 0;
int i, flags = e->flags;
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)
{
basic_block bb;
/* Clear AUX pointers of all blocks. */
void
-clear_aux_for_blocks ()
+clear_aux_for_blocks (void)
{
basic_block bb;
of all blocks. */
void
-free_aux_for_blocks ()
+free_aux_for_blocks (void)
{
if (!first_block_aux_obj)
abort ();
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)
{
basic_block bb;
/* Clear AUX pointers of all edges. */
void
-clear_aux_for_edges ()
+clear_aux_for_edges (void)
{
basic_block bb;
edge e;
of all edges. */
void
-free_aux_for_edges ()
+free_aux_for_edges (void)
{
if (!first_edge_aux_obj)
abort ();
clear_aux_for_edges ();
}
-/* Verify the CFG consistency.
- ??? In the future move IL idepdendent checks here. */
void
-verify_flow_info ()
+debug_bb (basic_block bb)
{
- cfg_hooks->cfgh_verify_flow_info ();
+ 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
