/* 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 <s.pop@laposte.net>
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,
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
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
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';
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 (const_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. */
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 (current_loops != NULL && ret != NULL)
+ if (ret != NULL
+ && dom_info_available_p (CDI_DOMINATORS))
+ set_immediate_dominator (CDI_DOMINATORS, ret, src);
+
+ if (current_loops != NULL)
{
- loop = find_common_loop (single_pred (ret)->loop_father,
- single_succ (ret)->loop_father);
- add_bb_to_loop (ret, loop);
+ 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;
}
if (current_loops != NULL)
- add_bb_to_loop (new_bb, bb->loop_father);
+ {
+ 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);
}
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. */
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;
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:
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;
}
bool
-predicted_by_p (basic_block bb, enum br_predictor predictor)
+predicted_by_p (const_basic_block bb, enum br_predictor predictor)
{
if (!cfg_hooks->predict_edge)
internal_error ("%s does not support predicted_by_p", cfg_hooks->name);
if (!cfg_hooks->merge_blocks)
internal_error ("%s does not support merge_blocks", cfg_hooks->name);
+ cfg_hooks->merge_blocks (a, b);
+
if (current_loops != NULL)
remove_bb_from_loops (b);
- cfg_hooks->merge_blocks (a, 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);
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];
-
- doms_to_fix[0] = dummy;
- doms_to_fix[1] = bb;
- iterate_fix_dominators (CDI_DOMINATORS, 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. */
+ 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);
}
/* In case we split loop latch, update it. */
- for (ploop = loop; ploop; ploop = ploop->outer)
+ for (ploop = loop; ploop; ploop = loop_outer (ploop))
if (ploop->latch == dummy)
ploop->latch = bb;
}
/* Returns true if we can duplicate basic block BB. */
bool
-can_duplicate_block_p (basic_block bb)
+can_duplicate_block_p (const_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);
}
set_bb_original (new_bb, bb);
set_bb_copy (bb, new_bb);
- /* Add the new block to the prescribed loop. */
+ /* 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)
- add_bb_to_loop (new_bb, bb->loop_father->copy);
+ {
+ 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 conditional branch, 0 otherwise. */
bool
-block_ends_with_condjump_p (basic_block bb)
+block_ends_with_condjump_p (const_basic_block bb)
{
if (!cfg_hooks->block_ends_with_condjump_p)
internal_error ("%s does not support block_ends_with_condjump_p",
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
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);
}