diff options
Diffstat (limited to 'contrib/gcc/cfg.c')
-rw-r--r-- | contrib/gcc/cfg.c | 460 |
1 files changed, 304 insertions, 156 deletions
diff --git a/contrib/gcc/cfg.c b/contrib/gcc/cfg.c index 2d11580..8042585 100644 --- a/contrib/gcc/cfg.c +++ b/contrib/gcc/cfg.c @@ -1,6 +1,6 @@ /* 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. @@ -20,7 +20,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA 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). @@ -39,10 +39,16 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA - 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 */ #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "tree.h" #include "rtl.h" #include "hard-reg-set.h" @@ -55,12 +61,21 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #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; @@ -73,11 +88,6 @@ int last_basic_block; int n_edges; -/* First edge in the deleted edges chain. */ - -edge first_deleted_edge; -static basic_block first_deleted_block; - /* The basic block array. */ varray_type basic_block_info; @@ -101,9 +111,11 @@ struct basic_block_def entry_exit_blocks[2] 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 */ @@ -122,56 +134,59 @@ struct basic_block_def entry_exit_blocks[2] 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); /* 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); } /* 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) { basic_block bb; edge e; @@ -211,28 +226,17 @@ clear_edges () /* 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; } /* 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; @@ -242,8 +246,7 @@ link_block (b, 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; @@ -251,11 +254,11 @@ unlink_block (b) /* Sequentially order blocks and compact the arrays. */ void -compact_blocks () +compact_blocks (void) { int i; basic_block bb; - + i = 0; FOR_EACH_BB (bb) { @@ -270,22 +273,15 @@ compact_blocks () last_basic_block = n_basic_blocks; } - /* 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; n_basic_blocks--; - - /* Invalidate data to make bughunting easier. */ - memset (b, 0, sizeof *b); - b->index = -3; - b->succ = (edge) first_deleted_block; - first_deleted_block = (basic_block) b; + pool_free (bb_pool, b); } /* Create an edge connecting SRC and DEST with flags FLAGS. Return newly @@ -293,22 +289,11 @@ expunge_block (b) 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; - - 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); - } + e = pool_alloc (edge_pool); + memset (e, 0, sizeof (*e)); n_edges++; e->succ_next = src->succ; @@ -322,14 +307,12 @@ unchecked_make_edge (src, dst, flags) 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; @@ -351,7 +334,7 @@ cached_make_edge (edge_cache, src, dst, flags) if (flags == 0) return NULL; - /* FALLTHRU */ + /* Fall through. */ case 0: for (e = src->succ; e; e = e->succ_next) if (e->dest == dst) @@ -374,9 +357,7 @@ cached_make_edge (edge_cache, src, dst, flags) 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); } @@ -385,9 +366,7 @@ make_edge (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); @@ -399,8 +378,7 @@ make_single_succ_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; @@ -435,9 +413,7 @@ remove_edge (e) /* 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; @@ -455,9 +431,7 @@ redirect_edge_succ (e, new_succ) /* 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; @@ -485,9 +459,7 @@ redirect_edge_succ_nodup (e, new_succ) /* 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; @@ -504,7 +476,7 @@ redirect_edge_pred (e, new_pred) } void -clear_bb_flags () +clear_bb_flags (void) { basic_block bb; @@ -513,8 +485,7 @@ clear_bb_flags () } void -dump_flow_info (file) - FILE *file; +dump_flow_info (FILE *file) { int i; int max_regno = max_reg_num (); @@ -522,48 +493,49 @@ dump_flow_info (file) 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) @@ -573,7 +545,7 @@ dump_flow_info (file) 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); @@ -603,7 +575,7 @@ dump_flow_info (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 elliminating of conditionals or roundoff errors. + solved graphs, later eliminating of conditionals or roundoff errors. It is still practical to have them reported for debugging of simple testcases. */ sum = 0; @@ -637,16 +609,13 @@ dump_flow_info (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); @@ -668,8 +637,10 @@ dump_edge_info (file, e, do_succ) if (e->flags) { - static const char * const bitnames[] - = {"fallthru", "ab", "abcall", "eh", "fake", "dfs_back", "can_fallthru"}; + 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; @@ -703,9 +674,7 @@ static void *first_edge_aux_obj = 0; 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) @@ -718,8 +687,7 @@ alloc_aux_for_block (bb, size) 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; @@ -732,7 +700,7 @@ alloc_aux_for_blocks (size) /* 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; @@ -745,7 +713,7 @@ alloc_aux_for_blocks (size) /* Clear AUX pointers of all blocks. */ void -clear_aux_for_blocks () +clear_aux_for_blocks (void) { basic_block bb; @@ -757,7 +725,7 @@ clear_aux_for_blocks () of all blocks. */ void -free_aux_for_blocks () +free_aux_for_blocks (void) { if (!first_block_aux_obj) abort (); @@ -771,9 +739,7 @@ free_aux_for_blocks () 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) @@ -786,8 +752,7 @@ alloc_aux_for_edge (e, size) 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; @@ -801,7 +766,7 @@ alloc_aux_for_edges (size) 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; @@ -819,7 +784,7 @@ alloc_aux_for_edges (size) /* Clear AUX pointers of all edges. */ void -clear_aux_for_edges () +clear_aux_for_edges (void) { basic_block bb; edge e; @@ -835,7 +800,7 @@ clear_aux_for_edges () of all edges. */ void -free_aux_for_edges () +free_aux_for_edges (void) { if (!first_edge_aux_obj) abort (); @@ -844,3 +809,186 @@ free_aux_for_edges () clear_aux_for_edges (); } + +/* Verify the CFG consistency. + + Currently it does following checks edge and basic block list correctness + and calls into IL dependent checking then. */ +void +verify_flow_info (void) +{ + size_t *edge_checksum; + int num_bb_notes, err = 0; + basic_block bb, last_bb_seen; + basic_block *last_visited; + + last_visited = xcalloc (last_basic_block + 2, sizeof (basic_block)); + edge_checksum = xcalloc (last_basic_block + 2, sizeof (size_t)); + + /* Check bb chain & numbers. */ + last_bb_seen = ENTRY_BLOCK_PTR; + FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb, NULL, next_bb) + { + if (bb != EXIT_BLOCK_PTR + && bb != BASIC_BLOCK (bb->index)) + { + error ("bb %d on wrong place", bb->index); + err = 1; + } + + if (bb->prev_bb != last_bb_seen) + { + error ("prev_bb of %d should be %d, not %d", + bb->index, last_bb_seen->index, bb->prev_bb->index); + err = 1; + } + + last_bb_seen = bb; + } + + /* Now check the basic blocks (boundaries etc.) */ + FOR_EACH_BB_REVERSE (bb) + { + int n_fallthru = 0; + edge e; + + if (bb->count < 0) + { + error ("verify_flow_info: Wrong count of block %i %i", + bb->index, (int)bb->count); + err = 1; + } + if (bb->frequency < 0) + { + error ("verify_flow_info: Wrong frequency of block %i %i", + bb->index, bb->frequency); + err = 1; + } + for (e = bb->succ; e; e = e->succ_next) + { + if (last_visited [e->dest->index + 2] == bb) + { + error ("verify_flow_info: Duplicate edge %i->%i", + e->src->index, e->dest->index); + err = 1; + } + if (e->probability < 0 || e->probability > REG_BR_PROB_BASE) + { + error ("verify_flow_info: Wrong probability of edge %i->%i %i", + e->src->index, e->dest->index, e->probability); + err = 1; + } + if (e->count < 0) + { + error ("verify_flow_info: Wrong count of edge %i->%i %i", + e->src->index, e->dest->index, (int)e->count); + err = 1; + } + + last_visited [e->dest->index + 2] = bb; + + if (e->flags & EDGE_FALLTHRU) + n_fallthru++; + + if (e->src != bb) + { + error ("verify_flow_info: Basic block %d succ edge is corrupted", + bb->index); + fprintf (stderr, "Predecessor: "); + dump_edge_info (stderr, e, 0); + fprintf (stderr, "\nSuccessor: "); + dump_edge_info (stderr, e, 1); + fprintf (stderr, "\n"); + err = 1; + } + + edge_checksum[e->dest->index + 2] += (size_t) e; + } + if (n_fallthru > 1) + { + error ("Wrong amount of branch edges after unconditional jump %i", bb->index); + err = 1; + } + + for (e = bb->pred; e; e = e->pred_next) + { + if (e->dest != bb) + { + error ("basic block %d pred edge is corrupted", bb->index); + fputs ("Predecessor: ", stderr); + dump_edge_info (stderr, e, 0); + fputs ("\nSuccessor: ", stderr); + dump_edge_info (stderr, e, 1); + fputc ('\n', stderr); + err = 1; + } + edge_checksum[e->dest->index + 2] -= (size_t) e; + } + } + + /* Complete edge checksumming for ENTRY and EXIT. */ + { + edge e; + + for (e = ENTRY_BLOCK_PTR->succ; e ; e = e->succ_next) + edge_checksum[e->dest->index + 2] += (size_t) e; + + for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next) + edge_checksum[e->dest->index + 2] -= (size_t) e; + } + + FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb) + if (edge_checksum[bb->index + 2]) + { + error ("basic block %i edge lists are corrupted", bb->index); + err = 1; + } + + num_bb_notes = 0; + last_bb_seen = ENTRY_BLOCK_PTR; + + /* Clean up. */ + free (last_visited); + free (edge_checksum); + err |= cfg_hooks->cfgh_verify_flow_info (); + if (err) + internal_error ("verify_flow_info failed"); +} + +/* Print out one basic block with live information at start and end. */ + +void +dump_bb (basic_block bb, FILE *outf) +{ + edge e; + + fprintf (outf, ";; Basic block %d, loop depth %d, count ", + bb->index, bb->loop_depth); + fprintf (outf, HOST_WIDEST_INT_PRINT_DEC, (HOST_WIDEST_INT) bb->count); + putc ('\n', outf); + fputs (";; Predecessors: ", outf); + for (e = bb->pred; e; e = e->pred_next) + dump_edge_info (outf, e, 0); + putc ('\n', outf); + + cfg_hooks->dump_bb (bb, outf); + + fputs (";; Successors: ", outf); + for (e = bb->succ; e; e = e->succ_next) + dump_edge_info (outf, e, 1); + putc ('\n', outf); +} + +void +debug_bb (basic_block bb) +{ + dump_bb (bb, stderr); +} + +basic_block +debug_bb_n (int n) +{ + basic_block bb = BASIC_BLOCK (n); + dump_bb (bb, stderr); + return bb; +} |