X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fcfghooks.c;h=e224ad81ca24f1bda63556e1ea85f35240eaefe9;hb=f7a00bdb09cb3716b05e56bcacfaab14f81102be;hp=a42e4d74b7bfa23da9542ce157cc21c73935a1f4;hpb=4d2e5d528864f897011ae82014889955d1558c97;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c index a42e4d74b7b..e224ad81ca2 100644 --- a/gcc/cfghooks.c +++ b/gcc/cfghooks.c @@ -1,12 +1,12 @@ /* Hooks for cfg representation specific functions. - Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc. + Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc. Contributed by Sebastian Pop This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) +the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, @@ -15,9 +15,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING. If not, write to -the Free Software Foundation, 51 Franklin Street, Fifth Floor, -Boston, MA 02110-1301, USA. */ +along with GCC; see the file COPYING3. If not see +. */ #include "config.h" #include "system.h" @@ -29,6 +28,7 @@ Boston, MA 02110-1301, USA. */ #include "tree-flow.h" #include "timevar.h" #include "toplev.h" +#include "cfgloop.h" /* A pointer to one of the hooks containers. */ static struct cfg_hooks *cfg_hooks; @@ -55,12 +55,19 @@ tree_register_cfg_hooks (void) cfg_hooks = &tree_cfg_hooks; } -/* Returns current ir type (rtl = 0, trees = 1). */ +/* Returns current ir type. */ -int -ir_type (void) +enum ir_type +current_ir_type (void) { - return cfg_hooks == &tree_cfg_hooks ? 1 : 0; + if (cfg_hooks == &tree_cfg_hooks) + return IR_GIMPLE; + else if (cfg_hooks == &rtl_cfg_hooks) + return IR_RTL_CFGRTL; + else if (cfg_hooks == &cfg_layout_rtl_cfg_hooks) + return IR_RTL_CFGLAYOUT; + else + gcc_unreachable (); } /* Verify the CFG consistency. @@ -77,8 +84,8 @@ verify_flow_info (void) basic_block *last_visited; timevar_push (TV_CFG_VERIFY); - last_visited = xcalloc (last_basic_block, sizeof (basic_block)); - edge_checksum = xcalloc (last_basic_block, sizeof (size_t)); + last_visited = XCNEWVEC (basic_block, last_basic_block); + edge_checksum = XCNEWVEC (size_t, last_basic_block); /* Check bb chain & numbers. */ last_bb_seen = ENTRY_BLOCK_PTR; @@ -108,16 +115,28 @@ verify_flow_info (void) edge e; edge_iterator ei; + if (bb->loop_father != NULL && current_loops == NULL) + { + error ("verify_flow_info: Block %i has loop_father, but there are no loops", + bb->index); + err = 1; + } + if (bb->loop_father == NULL && current_loops != NULL) + { + error ("verify_flow_info: Block %i lacks loop_father", bb->index); + err = 1; + } + if (bb->count < 0) { error ("verify_flow_info: Wrong count of block %i %i", - bb->index, (int)bb->count); + 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); + bb->index, bb->frequency); err = 1; } FOR_EACH_EDGE (e, ei, bb->succs) @@ -238,8 +257,8 @@ dump_bb (basic_block bb, FILE *outf, int indent) edge e; edge_iterator ei; char *s_indent; - - s_indent = alloca ((size_t) indent + 1); + + s_indent = (char *) alloca ((size_t) indent + 1); memset (s_indent, ' ', (size_t) indent); s_indent[indent] = '\0'; @@ -290,9 +309,64 @@ redirect_edge_and_branch (edge e, basic_block dest) ret = cfg_hooks->redirect_edge_and_branch (e, dest); + /* If RET != E, then either the redirection failed, or the edge E + was removed since RET already lead to the same destination. */ + if (current_loops != NULL && ret == e) + rescan_loop_exit (e, false, false); + return ret; } +/* Returns true if it is possible to remove the edge E by redirecting it + to the destination of the other edge going from its source. */ + +bool +can_remove_branch_p (edge e) +{ + if (!cfg_hooks->can_remove_branch_p) + internal_error ("%s does not support can_remove_branch_p", + cfg_hooks->name); + + if (EDGE_COUNT (e->src->succs) != 2) + return false; + + return cfg_hooks->can_remove_branch_p (e); +} + +/* Removes E, by redirecting it to the destination of the other edge going + from its source. Can_remove_branch_p must be true for E, hence this + operation cannot fail. */ + +void +remove_branch (edge e) +{ + edge other; + basic_block src = e->src; + int irr; + + gcc_assert (EDGE_COUNT (e->src->succs) == 2); + + other = EDGE_SUCC (src, EDGE_SUCC (src, 0) == e); + irr = other->flags & EDGE_IRREDUCIBLE_LOOP; + + e = redirect_edge_and_branch (e, other->dest); + gcc_assert (e != NULL); + + e->flags &= ~EDGE_IRREDUCIBLE_LOOP; + e->flags |= irr; +} + +/* Removes edge E from cfg. Unlike remove_branch, it does not update IL. */ + +void +remove_edge (edge e) +{ + if (current_loops != NULL) + rescan_loop_exit (e, false, true); + + remove_edge_raw (e); +} + /* Redirect the edge E to basic block DEST even if it requires creating of a new basic block; then it returns the newly created basic block. Aborts when redirection is impossible. */ @@ -300,13 +374,32 @@ redirect_edge_and_branch (edge e, basic_block dest) basic_block redirect_edge_and_branch_force (edge e, basic_block dest) { - basic_block ret; + basic_block ret, src = e->src; + struct loop *loop; if (!cfg_hooks->redirect_edge_and_branch_force) internal_error ("%s does not support redirect_edge_and_branch_force", cfg_hooks->name); + if (current_loops != NULL) + rescan_loop_exit (e, false, true); + ret = cfg_hooks->redirect_edge_and_branch_force (e, dest); + if (ret != NULL + && dom_info_available_p (CDI_DOMINATORS)) + set_immediate_dominator (CDI_DOMINATORS, ret, src); + + if (current_loops != NULL) + { + if (ret != NULL) + { + loop = find_common_loop (single_pred (ret)->loop_father, + single_succ (ret)->loop_father); + add_bb_to_loop (ret, loop); + } + else if (find_edge (src, dest) == e) + rescan_loop_exit (e, true, false); + } return ret; } @@ -337,6 +430,13 @@ split_block (basic_block bb, void *i) set_immediate_dominator (CDI_DOMINATORS, new_bb, bb); } + if (current_loops != NULL) + { + add_bb_to_loop (new_bb, bb->loop_father); + if (bb->loop_father->latch == bb) + bb->loop_father->latch = new_bb; + } + return make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU); } @@ -374,6 +474,22 @@ delete_basic_block (basic_block bb) cfg_hooks->delete_basic_block (bb); + if (current_loops != NULL) + { + struct loop *loop = bb->loop_father; + + /* If we remove the header or the latch of a loop, mark the loop for + removal by setting its header and latch to NULL. */ + if (loop->latch == bb + || loop->header == bb) + { + loop->header = NULL; + loop->latch = NULL; + } + + remove_bb_from_loops (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 (EDGE_COUNT (bb->preds) != 0) @@ -381,9 +497,9 @@ delete_basic_block (basic_block bb) while (EDGE_COUNT (bb->succs) != 0) remove_edge (EDGE_SUCC (bb, 0)); - if (dom_computed[CDI_DOMINATORS]) + if (dom_info_available_p (CDI_DOMINATORS)) delete_from_dominance_info (CDI_DOMINATORS, bb); - if (dom_computed[CDI_POST_DOMINATORS]) + if (dom_info_available_p (CDI_POST_DOMINATORS)) delete_from_dominance_info (CDI_POST_DOMINATORS, bb); /* Remove the basic block from the array. */ @@ -400,10 +516,15 @@ split_edge (edge e) int freq = EDGE_FREQUENCY (e); edge f; bool irr = (e->flags & EDGE_IRREDUCIBLE_LOOP) != 0; + struct loop *loop; + basic_block src = e->src, dest = e->dest; if (!cfg_hooks->split_edge) internal_error ("%s does not support split_edge", cfg_hooks->name); + if (current_loops != NULL) + rescan_loop_exit (e, false, true); + ret = cfg_hooks->split_edge (e); ret->count = count; ret->frequency = freq; @@ -417,10 +538,10 @@ split_edge (edge e) single_succ_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP; } - if (dom_computed[CDI_DOMINATORS]) + if (dom_info_available_p (CDI_DOMINATORS)) set_immediate_dominator (CDI_DOMINATORS, ret, single_pred (ret)); - if (dom_computed[CDI_DOMINATORS] >= DOM_NO_FAST_QUERY) + if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY) { /* There are two cases: @@ -448,7 +569,16 @@ split_edge (edge e) if (!f) set_immediate_dominator (CDI_DOMINATORS, single_succ (ret), ret); } - }; + } + + if (current_loops != NULL) + { + loop = find_common_loop (src->loop_father, dest->loop_father); + add_bb_to_loop (ret, loop); + + if (loop->latch == src) + loop->latch = ret; + } return ret; } @@ -467,9 +597,9 @@ create_basic_block (void *head, void *end, basic_block after) ret = cfg_hooks->create_basic_block (head, end, after); - if (dom_computed[CDI_DOMINATORS]) + if (dom_info_available_p (CDI_DOMINATORS)) add_to_dominance_info (CDI_DOMINATORS, ret); - if (dom_computed[CDI_POST_DOMINATORS]) + if (dom_info_available_p (CDI_POST_DOMINATORS)) add_to_dominance_info (CDI_POST_DOMINATORS, ret); return ret; @@ -529,29 +659,36 @@ merge_blocks (basic_block a, basic_block b) cfg_hooks->merge_blocks (a, b); + if (current_loops != NULL) + remove_bb_from_loops (b); + /* Normally there should only be one successor of A and that is B, but 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 (EDGE_COUNT (a->succs) != 0) - remove_edge (EDGE_SUCC (a, 0)); + remove_edge (EDGE_SUCC (a, 0)); /* Adjust the edges out of B for the new owner. */ FOR_EACH_EDGE (e, ei, b->succs) - e->src = a; + { + e->src = a; + if (current_loops != NULL) + rescan_loop_exit (e, true, false); + } a->succs = b->succs; a->flags |= b->flags; /* B hasn't quite yet ceased to exist. Attempt to prevent mishap. */ b->preds = b->succs = NULL; - if (dom_computed[CDI_DOMINATORS]) + if (dom_info_available_p (CDI_DOMINATORS)) redirect_immediate_dominators (CDI_DOMINATORS, b, a); - if (dom_computed[CDI_DOMINATORS]) + if (dom_info_available_p (CDI_DOMINATORS)) delete_from_dominance_info (CDI_DOMINATORS, b); - if (dom_computed[CDI_POST_DOMINATORS]) + if (dom_info_available_p (CDI_POST_DOMINATORS)) delete_from_dominance_info (CDI_POST_DOMINATORS, b); expunge_block (b); @@ -568,6 +705,7 @@ make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge), edge e, fallthru; edge_iterator ei; basic_block dummy, jump; + struct loop *loop, *ploop, *cloop; if (!cfg_hooks->make_forwarder_block) internal_error ("%s does not support make_forwarder_block", @@ -597,17 +735,48 @@ make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge), fallthru->count = 0; jump = redirect_edge_and_branch_force (e, bb); - if (jump) + if (jump != NULL + && new_bb_cbk != NULL) new_bb_cbk (jump); } if (dom_info_available_p (CDI_DOMINATORS)) { - basic_block doms_to_fix[2]; + VEC (basic_block, heap) *doms_to_fix = VEC_alloc (basic_block, heap, 2); + VEC_quick_push (basic_block, doms_to_fix, dummy); + VEC_quick_push (basic_block, doms_to_fix, bb); + iterate_fix_dominators (CDI_DOMINATORS, doms_to_fix, false); + VEC_free (basic_block, heap, doms_to_fix); + } + + if (current_loops != NULL) + { + /* If we do not split a loop header, then both blocks belong to the + same loop. In case we split loop header and do not redirect the + latch edge to DUMMY, then DUMMY belongs to the outer loop, and + BB becomes the new header. If latch is not recorded for the loop, + we leave this updating on the caller (this may only happen during + loop analysis). */ + loop = dummy->loop_father; + if (loop->header == dummy + && loop->latch != NULL + && find_edge (loop->latch, dummy) == NULL) + { + remove_bb_from_loops (dummy); + loop->header = bb; + + cloop = loop; + FOR_EACH_EDGE (e, ei, dummy->preds) + { + cloop = find_common_loop (cloop, e->src->loop_father); + } + add_bb_to_loop (dummy, cloop); + } - doms_to_fix[0] = dummy; - doms_to_fix[1] = bb; - iterate_fix_dominators (CDI_DOMINATORS, doms_to_fix, 2); + /* In case we split loop latch, update it. */ + for (ploop = loop; ploop; ploop = loop_outer (ploop)) + if (ploop->latch == dummy) + ploop->latch = bb; } cfg_hooks->make_forwarder_block (fallthru); @@ -672,8 +841,6 @@ tidy_fallthru_edges (void) 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); @@ -681,12 +848,6 @@ can_duplicate_block_p (basic_block bb) 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); } @@ -761,13 +922,22 @@ duplicate_block (basic_block bb, edge e, basic_block after) set_bb_original (new_bb, bb); set_bb_copy (bb, new_bb); + /* Add the new block to the copy of the loop of BB, or directly to the loop + of BB if the loop is not being copied. */ + if (current_loops != NULL) + { + struct loop *cloop = bb->loop_father; + struct loop *copy = get_loop_copy (cloop); + add_bb_to_loop (new_bb, copy ? copy : cloop); + } + 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 +bool block_ends_with_call_p (basic_block bb) { if (!cfg_hooks->block_ends_with_call_p) @@ -778,7 +948,7 @@ block_ends_with_call_p (basic_block bb) /* Return 1 if BB ends with a conditional branch, 0 otherwise. */ -bool +bool block_ends_with_condjump_p (basic_block bb) { if (!cfg_hooks->block_ends_with_condjump_p) @@ -800,7 +970,7 @@ int flow_call_edges_add (sbitmap blocks) { if (!cfg_hooks->flow_call_edges_add) - internal_error ("%s does not support 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); @@ -826,8 +996,8 @@ execute_on_shrinking_pred (edge e) cfg_hooks->execute_on_shrinking_pred (e); } -/* This is used inside loop versioning when we want to insert - stmts/insns on the edges, which have a different behavior +/* This is used inside loop versioning when we want to insert + stmts/insns on the edges, which have a different behavior in tree's and in RTL, so we made a CFG hook. */ void lv_flush_pending_stmts (edge e) @@ -845,16 +1015,16 @@ lv_flush_pending_stmts (edge e) than duplicate_loop_to_header_edge when we are in tree mode. */ bool cfg_hook_duplicate_loop_to_header_edge (struct loop *loop, edge e, - struct loops *loops, unsigned int ndupl, + unsigned int ndupl, sbitmap wont_exit, edge orig, - edge *to_remove, - unsigned int *n_to_remove, int flags) + VEC (edge, heap) **to_remove, + int flags) { gcc_assert (cfg_hooks->cfg_hook_duplicate_loop_to_header_edge); - return cfg_hooks->cfg_hook_duplicate_loop_to_header_edge (loop, e, loops, + return cfg_hooks->cfg_hook_duplicate_loop_to_header_edge (loop, e, ndupl, wont_exit, orig, to_remove, - n_to_remove, flags); + flags); } /* Conditional jumps are represented differently in trees and RTL, @@ -872,10 +1042,10 @@ extract_cond_bb_edges (basic_block b, edge *e1, edge *e2) new condition basic block that guards the versioned loop. */ void lv_adjust_loop_header_phi (basic_block first, basic_block second, - basic_block new, edge e) + basic_block new_block, edge e) { if (cfg_hooks->lv_adjust_loop_header_phi) - cfg_hooks->lv_adjust_loop_header_phi (first, second, new, e); + cfg_hooks->lv_adjust_loop_header_phi (first, second, new_block, e); } /* Conditions in trees and RTL are different so we need @@ -883,8 +1053,8 @@ lv_adjust_loop_header_phi (basic_block first, basic_block second, versioning code. */ void lv_add_condition_to_bb (basic_block first, basic_block second, - basic_block new, void *cond) + basic_block new_block, void *cond) { gcc_assert (cfg_hooks->lv_add_condition_to_bb); - cfg_hooks->lv_add_condition_to_bb (first, second, new, cond); -} + cfg_hooks->lv_add_condition_to_bb (first, second, new_block, cond); +}