#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;
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.
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)
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';
ret = cfg_hooks->redirect_edge_and_branch (e, dest);
+ /* If RET != E, then the edge E was removed since RET already lead to the
+ same destination. */
+ if (ret != NULL && current_loops != NULL)
+ rescan_loop_exit (e, false, ret != e);
+
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;
+
+ if (current_loops != NULL)
+ rescan_loop_exit (e, false, true);
+
+ e = redirect_edge_and_branch (e, other->dest);
+ gcc_assert (e != NULL);
+
+ e->flags &= ~EDGE_IRREDUCIBLE_LOOP;
+ e->flags |= irr;
+}
+
/* 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 (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;
}
set_immediate_dominator (CDI_DOMINATORS, new_bb, bb);
}
+ if (current_loops != NULL)
+ add_bb_to_loop (new_bb, bb->loop_father);
+
return make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU);
}
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)
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. */
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;
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:
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;
}
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;
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));
+ {
+ if (current_loops != NULL)
+ rescan_loop_exit (EDGE_SUCC (a, 0), false, true);
+ 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);
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",
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);
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)
/* 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)
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);
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)
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,
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);
+}