X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fcfghooks.c;h=4f8f18a97c6ea44dd5f2da3f1eae463d321c1898;hb=b7837065e4ec51e8a0ed5fdb0303f2273d3a5d92;hp=9f70604c6f2b50146c1d1db42c0b9263a018a604;hpb=4acc30e5f845ecfe9e2e9a746b002f1099c13e0b;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c index 9f70604c6f2..4f8f18a97c6 100644 --- a/gcc/cfghooks.c +++ b/gcc/cfghooks.c @@ -1,5 +1,5 @@ /* Hooks for cfg representation specific functions. - Copyright (C) 2003, 2004 Free Software Foundation, Inc. + Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc. Contributed by Sebastian Pop This file is part of GCC. @@ -26,6 +26,7 @@ Boston, MA 02111-1307, USA. */ #include "tree.h" #include "rtl.h" #include "basic-block.h" +#include "tree-flow.h" #include "timevar.h" #include "toplev.h" @@ -46,6 +47,22 @@ cfg_layout_rtl_register_cfg_hooks (void) cfg_hooks = &cfg_layout_rtl_cfg_hooks; } +/* Initialization of functions specific to the tree IR. */ + +void +tree_register_cfg_hooks (void) +{ + cfg_hooks = &tree_cfg_hooks; +} + +/* Returns current ir type (rtl = 0, trees = 1). */ + +int +ir_type (void) +{ + return cfg_hooks == &tree_cfg_hooks ? 1 : 0; +} + /* Verify the CFG consistency. Currently it does following: checks edge and basic block list correctness @@ -55,7 +72,7 @@ void verify_flow_info (void) { size_t *edge_checksum; - int num_bb_notes, err = 0; + int err = 0; basic_block bb, last_bb_seen; basic_block *last_visited; @@ -89,6 +106,7 @@ verify_flow_info (void) { int n_fallthru = 0; edge e; + edge_iterator ei; if (bb->count < 0) { @@ -102,7 +120,7 @@ verify_flow_info (void) bb->index, bb->frequency); err = 1; } - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) { if (last_visited [e->dest->index + 2] == bb) { @@ -148,7 +166,7 @@ verify_flow_info (void) err = 1; } - for (e = bb->pred; e; e = e->pred_next) + FOR_EACH_EDGE (e, ei, bb->preds) { if (e->dest != bb) { @@ -160,6 +178,20 @@ verify_flow_info (void) fputc ('\n', stderr); err = 1; } + + if (ei.index != e->dest_idx) + { + error ("basic block %d pred edge is corrupted", bb->index); + error ("its dest_idx should be %d, not %d", + ei.index, e->dest_idx); + 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; } } @@ -167,11 +199,12 @@ verify_flow_info (void) /* Complete edge checksumming for ENTRY and EXIT. */ { edge e; + edge_iterator ei; - for (e = ENTRY_BLOCK_PTR->succ; e ; e = e->succ_next) + FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs) edge_checksum[e->dest->index + 2] += (size_t) e; - for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next) + FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) edge_checksum[e->dest->index + 2] -= (size_t) e; } @@ -182,7 +215,6 @@ verify_flow_info (void) err = 1; } - num_bb_notes = 0; last_bb_seen = ENTRY_BLOCK_PTR; /* Clean up. */ @@ -204,6 +236,7 @@ void dump_bb (basic_block bb, FILE *outf, int indent) { edge e; + edge_iterator ei; char *s_indent; s_indent = alloca ((size_t) indent + 1); @@ -228,12 +261,12 @@ dump_bb (basic_block bb, FILE *outf, int indent) putc ('\n', outf); fprintf (outf, ";;%s pred: ", s_indent); - for (e = bb->pred; e; e = e->pred_next) + FOR_EACH_EDGE (e, ei, bb->preds) dump_edge_info (outf, e, 0); putc ('\n', outf); fprintf (outf, ";;%s succ: ", s_indent); - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) dump_edge_info (outf, e, 1); putc ('\n', outf); @@ -246,10 +279,10 @@ dump_bb (basic_block bb, FILE *outf, int indent) be equivalent to E in the case of duplicate edges being removed) or NULL if edge is not easily redirectable for whatever reason. */ -bool +edge redirect_edge_and_branch (edge e, basic_block dest) { - bool ret; + edge ret; if (!cfg_hooks->redirect_edge_and_branch) internal_error ("%s does not support redirect_edge_and_branch.", @@ -286,7 +319,6 @@ edge split_block (basic_block bb, void *i) { basic_block new_bb; - edge e; if (!cfg_hooks->split_block) internal_error ("%s does not support split_block.", cfg_hooks->name); @@ -299,17 +331,13 @@ split_block (basic_block bb, void *i) new_bb->frequency = bb->frequency; new_bb->loop_depth = bb->loop_depth; - if (dom_computed[CDI_DOMINATORS] >= DOM_CONS_OK) + if (dom_info_available_p (CDI_DOMINATORS)) { redirect_immediate_dominators (CDI_DOMINATORS, bb, new_bb); set_immediate_dominator (CDI_DOMINATORS, new_bb, bb); } - e = make_edge (bb, new_bb, EDGE_FALLTHRU); - e->probability = REG_BR_PROB_BASE; - e->count = bb->count; - - return e; + return make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU); } /* Splits block BB just after labels. The newly created edge is returned. */ @@ -348,13 +376,10 @@ delete_basic_block (basic_block bb) /* Remove the edges into and out of this block. Note that there may indeed be edges in, if we are removing an unreachable loop. */ - while (bb->pred != NULL) - remove_edge (bb->pred); - while (bb->succ != NULL) - remove_edge (bb->succ); - - bb->pred = NULL; - bb->succ = NULL; + while (EDGE_COUNT (bb->preds) != 0) + remove_edge (EDGE_PRED (bb, 0)); + while (EDGE_COUNT (bb->succs) != 0) + remove_edge (EDGE_SUCC (bb, 0)); if (dom_computed[CDI_DOMINATORS]) delete_from_dominance_info (CDI_DOMINATORS, bb); @@ -374,6 +399,7 @@ split_edge (edge e) gcov_type count = e->count; int freq = EDGE_FREQUENCY (e); edge f; + bool irr = (e->flags & EDGE_IRREDUCIBLE_LOOP) != 0; if (!cfg_hooks->split_edge) internal_error ("%s does not support split_edge.", cfg_hooks->name); @@ -381,11 +407,18 @@ split_edge (edge e) ret = cfg_hooks->split_edge (e); ret->count = count; ret->frequency = freq; - ret->succ->probability = REG_BR_PROB_BASE; - ret->succ->count = count; + single_succ_edge (ret)->probability = REG_BR_PROB_BASE; + single_succ_edge (ret)->count = count; + + if (irr) + { + ret->flags |= BB_IRREDUCIBLE_LOOP; + single_pred_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP; + single_succ_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP; + } if (dom_computed[CDI_DOMINATORS]) - set_immediate_dominator (CDI_DOMINATORS, ret, ret->pred->src); + set_immediate_dominator (CDI_DOMINATORS, ret, single_pred (ret)); if (dom_computed[CDI_DOMINATORS] >= DOM_NO_FAST_QUERY) { @@ -398,21 +431,22 @@ split_edge (edge e) ret, provided that all other predecessors of e->dest are dominated by e->dest. */ - if (get_immediate_dominator (CDI_DOMINATORS, ret->succ->dest) - == ret->pred->src) + if (get_immediate_dominator (CDI_DOMINATORS, single_succ (ret)) + == single_pred (ret)) { - for (f = ret->succ->dest->pred; f; f = f->pred_next) + edge_iterator ei; + FOR_EACH_EDGE (f, ei, single_succ (ret)->preds) { - if (f == ret->succ) + if (f == single_succ_edge (ret)) continue; if (!dominated_by_p (CDI_DOMINATORS, f->src, - ret->succ->dest)) + single_succ (ret))) break; } if (!f) - set_immediate_dominator (CDI_DOMINATORS, ret->succ->dest, ret); + set_immediate_dominator (CDI_DOMINATORS, single_succ (ret), ret); } }; @@ -464,12 +498,31 @@ can_merge_blocks_p (basic_block bb1, basic_block bb2) return ret; } +void +predict_edge (edge e, enum br_predictor predictor, int probability) +{ + if (!cfg_hooks->predict_edge) + internal_error ("%s does not support predict_edge.", cfg_hooks->name); + + cfg_hooks->predict_edge (e, predictor, probability); +} + +bool +predicted_by_p (basic_block bb, enum br_predictor predictor) +{ + if (!cfg_hooks->predict_edge) + internal_error ("%s does not support predicted_by_p.", cfg_hooks->name); + + return cfg_hooks->predicted_by_p (bb, predictor); +} + /* Merges basic block B into basic block A. */ void merge_blocks (basic_block a, basic_block b) { edge e; + edge_iterator ei; if (!cfg_hooks->merge_blocks) internal_error ("%s does not support merge_blocks.", cfg_hooks->name); @@ -480,17 +533,18 @@ merge_blocks (basic_block a, basic_block b) partway though the merge of blocks for conditional_execution we'll be merging a TEST block with THEN and ELSE successors. Free the whole lot of them and hope the caller knows what they're doing. */ - while (a->succ) - remove_edge (a->succ); + + while (EDGE_COUNT (a->succs) != 0) + remove_edge (EDGE_SUCC (a, 0)); /* Adjust the edges out of B for the new owner. */ - for (e = b->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, b->succs) e->src = a; - a->succ = b->succ; + a->succs = b->succs; a->flags |= b->flags; /* B hasn't quite yet ceased to exist. Attempt to prevent mishap. */ - b->pred = b->succ = NULL; + b->preds = b->succs = NULL; a->global_live_at_end = b->global_live_at_end; if (dom_computed[CDI_DOMINATORS]) @@ -512,7 +566,8 @@ edge make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge), void (*new_bb_cbk) (basic_block)) { - edge e, next_e, fallthru; + edge e, fallthru; + edge_iterator ei; basic_block dummy, jump; if (!cfg_hooks->make_forwarder_block) @@ -524,11 +579,13 @@ make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge), bb = fallthru->dest; /* Redirect back edges we want to keep. */ - for (e = dummy->pred; e; e = next_e) + for (ei = ei_start (dummy->preds); (e = ei_safe_edge (ei)); ) { - next_e = e->pred_next; if (redirect_edge_p (e)) - continue; + { + ei_next (&ei); + continue; + } dummy->frequency -= EDGE_FREQUENCY (e); dummy->count -= e->count; @@ -536,13 +593,16 @@ make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge), dummy->frequency = 0; if (dummy->count < 0) dummy->count = 0; + fallthru->count -= e->count; + if (fallthru->count < 0) + fallthru->count = 0; jump = redirect_edge_and_branch_force (e, bb); if (jump) new_bb_cbk (jump); } - if (dom_computed[CDI_DOMINATORS] >= DOM_CONS_OK) + if (dom_info_available_p (CDI_DOMINATORS)) { basic_block doms_to_fix[2]; @@ -597,10 +657,169 @@ tidy_fallthru_edges (void) merge the flags for the duplicate edges. So we do not want to check that the edge is not a FALLTHRU edge. */ - if ((s = b->succ) != NULL - && ! (s->flags & EDGE_COMPLEX) - && s->succ_next == NULL - && s->dest == c) - tidy_fallthru_edge (s); + if (single_succ_p (b)) + { + s = single_succ_edge (b); + if (! (s->flags & EDGE_COMPLEX) + && s->dest == c + && !find_reg_note (BB_END (b), REG_CROSSING_JUMP, NULL_RTX)) + tidy_fallthru_edge (s); + } } } + +/* Returns true if we can duplicate basic block BB. */ + +bool +can_duplicate_block_p (basic_block bb) +{ + edge e; + + if (!cfg_hooks->can_duplicate_block_p) + internal_error ("%s does not support can_duplicate_block_p.", + cfg_hooks->name); + + if (bb == EXIT_BLOCK_PTR || bb == ENTRY_BLOCK_PTR) + return false; + + /* Duplicating fallthru block to exit would require adding a jump + and splitting the real last BB. */ + e = find_edge (bb, EXIT_BLOCK_PTR); + if (e && (e->flags & EDGE_FALLTHRU)) + return false; + + return cfg_hooks->can_duplicate_block_p (bb); +} + +/* Duplicates basic block BB and redirects edge E to it. Returns the + new basic block. */ + +basic_block +duplicate_block (basic_block bb, edge e) +{ + edge s, n; + basic_block new_bb; + gcov_type new_count = e ? e->count : 0; + edge_iterator ei; + + if (!cfg_hooks->duplicate_block) + internal_error ("%s does not support duplicate_block.", + cfg_hooks->name); + + if (bb->count < new_count) + new_count = bb->count; + +#ifdef ENABLE_CHECKING + gcc_assert (can_duplicate_block_p (bb)); +#endif + + new_bb = cfg_hooks->duplicate_block (bb); + + new_bb->loop_depth = bb->loop_depth; + new_bb->flags = bb->flags; + FOR_EACH_EDGE (s, ei, bb->succs) + { + /* Since we are creating edges from a new block to successors + of another block (which therefore are known to be disjoint), there + is no need to actually check for duplicated edges. */ + n = unchecked_make_edge (new_bb, s->dest, s->flags); + n->probability = s->probability; + if (e && bb->count) + { + /* Take care for overflows! */ + n->count = s->count * (new_count * 10000 / bb->count) / 10000; + s->count -= n->count; + } + else + n->count = s->count; + n->aux = s->aux; + } + + if (e) + { + new_bb->count = new_count; + bb->count -= new_count; + + new_bb->frequency = EDGE_FREQUENCY (e); + bb->frequency -= EDGE_FREQUENCY (e); + + redirect_edge_and_branch_force (e, new_bb); + + if (bb->count < 0) + bb->count = 0; + if (bb->frequency < 0) + bb->frequency = 0; + } + else + { + new_bb->count = bb->count; + new_bb->frequency = bb->frequency; + } + + new_bb->rbi->original = bb; + bb->rbi->copy = new_bb; + + return new_bb; +} + +/* Return 1 if BB ends with a call, possibly followed by some + instructions that must stay with the call, 0 otherwise. */ + +bool +block_ends_with_call_p (basic_block bb) +{ + if (!cfg_hooks->block_ends_with_call_p) + internal_error ("%s does not support block_ends_with_call_p", cfg_hooks->name); + + return (cfg_hooks->block_ends_with_call_p) (bb); +} + +/* Return 1 if BB ends with a conditional branch, 0 otherwise. */ + +bool +block_ends_with_condjump_p (basic_block bb) +{ + if (!cfg_hooks->block_ends_with_condjump_p) + internal_error ("%s does not support block_ends_with_condjump_p", + cfg_hooks->name); + + return (cfg_hooks->block_ends_with_condjump_p) (bb); +} + +/* Add fake edges to the function exit for any non constant and non noreturn + calls, volatile inline assembly in the bitmap of blocks specified by + BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks + that were split. + + The goal is to expose cases in which entering a basic block does not imply + that all subsequent instructions must be executed. */ + +int +flow_call_edges_add (sbitmap blocks) +{ + if (!cfg_hooks->flow_call_edges_add) + internal_error ("%s does not support flow_call_edges_add", + cfg_hooks->name); + + return (cfg_hooks->flow_call_edges_add) (blocks); +} + +/* This function is called immediately after edge E is added to the + edge vector E->dest->preds. */ + +void +execute_on_growing_pred (edge e) +{ + if (cfg_hooks->execute_on_growing_pred) + cfg_hooks->execute_on_growing_pred (e); +} + +/* This function is called immediately before edge E is removed from + the edge vector E->dest->preds. */ + +void +execute_on_shrinking_pred (edge e) +{ + if (cfg_hooks->execute_on_shrinking_pred) + cfg_hooks->execute_on_shrinking_pred (e); +}