/* Hooks for cfg representation specific functions.
- Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2004, 2005, 2007, 2008, 2010
+ 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, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "basic-block.h"
#include "tree-flow.h"
#include "timevar.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
+#include "cfgloop.h"
/* A pointer to one of the hooks containers. */
static struct cfg_hooks *cfg_hooks;
/* Initialization of functions specific to the tree IR. */
void
-tree_register_cfg_hooks (void)
+gimple_register_cfg_hooks (void)
{
- cfg_hooks = &tree_cfg_hooks;
+ cfg_hooks = &gimple_cfg_hooks;
}
-/* Returns current ir type (rtl = 0, trees = 1). */
+struct cfg_hooks
+get_cfg_hooks (void)
+{
+ return *cfg_hooks;
+}
-int
-ir_type (void)
+void
+set_cfg_hooks (struct cfg_hooks new_cfg_hooks)
+{
+ *cfg_hooks = new_cfg_hooks;
+}
+
+/* Returns current ir type. */
+
+enum ir_type
+current_ir_type (void)
{
- return cfg_hooks == &tree_cfg_hooks ? 1 : 0;
+ if (cfg_hooks == &gimple_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.
Currently it does following: checks edge and basic block list correctness
and calls into IL dependent checking then. */
-void
+DEBUG_FUNCTION 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;
timevar_push (TV_CFG_VERIFY);
- last_visited = xcalloc (last_basic_block + 2, sizeof (basic_block));
- edge_checksum = xcalloc (last_basic_block + 2, 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;
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)
{
- if (last_visited [e->dest->index + 2] == bb)
+ if (last_visited [e->dest->index] == bb)
{
error ("verify_flow_info: Duplicate edge %i->%i",
e->src->index, e->dest->index);
err = 1;
}
- last_visited [e->dest->index + 2] = bb;
+ last_visited [e->dest->index] = bb;
if (e->flags & EDGE_FALLTHRU)
n_fallthru++;
err = 1;
}
- edge_checksum[e->dest->index + 2] += (size_t) e;
+ edge_checksum[e->dest->index] += (size_t) e;
}
if (n_fallthru > 1)
{
- error ("Wrong amount of branch edges after unconditional jump %i", bb->index);
+ error ("wrong amount of branch edges after unconditional jump %i", bb->index);
err = 1;
}
fputc ('\n', stderr);
err = 1;
}
- edge_checksum[e->dest->index + 2] -= (size_t) e;
+
+ 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] -= (size_t) e;
}
}
edge_iterator ei;
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
- edge_checksum[e->dest->index + 2] += (size_t) e;
+ edge_checksum[e->dest->index] += (size_t) e;
FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
- edge_checksum[e->dest->index + 2] -= (size_t) e;
+ edge_checksum[e->dest->index] -= (size_t) e;
}
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
- if (edge_checksum[bb->index + 2])
+ if (edge_checksum[bb->index])
{
error ("basic block %i edge lists are corrupted", bb->index);
err = 1;
}
- num_bb_notes = 0;
last_bb_seen = ENTRY_BLOCK_PTR;
/* Clean up. */
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';
putc ('\n', outf);
if (cfg_hooks->dump_bb)
- cfg_hooks->dump_bb (bb, outf, indent);
+ cfg_hooks->dump_bb (bb, outf, indent, 0);
}
/* Redirect edge E to the given basic block DEST and update underlying program
edge ret;
if (!cfg_hooks->redirect_edge_and_branch)
- internal_error ("%s does not support redirect_edge_and_branch.",
+ internal_error ("%s does not support redirect_edge_and_branch",
cfg_hooks->name);
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;
if (!cfg_hooks->redirect_edge_and_branch_force)
- internal_error ("%s does not support 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)
+ {
+ struct loop *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;
}
split_block (basic_block bb, void *i)
{
basic_block new_bb;
+ edge res;
if (!cfg_hooks->split_block)
- internal_error ("%s does not support split_block.", cfg_hooks->name);
+ internal_error ("%s does not support split_block", cfg_hooks->name);
new_bb = cfg_hooks->split_block (bb, i);
if (!new_bb)
new_bb->count = bb->count;
new_bb->frequency = bb->frequency;
new_bb->loop_depth = bb->loop_depth;
+ new_bb->discriminator = bb->discriminator;
- 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);
}
- return make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU);
+ 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;
+ }
+
+ res = make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU);
+
+ if (bb->flags & BB_IRREDUCIBLE_LOOP)
+ {
+ new_bb->flags |= BB_IRREDUCIBLE_LOOP;
+ res->flags |= EDGE_IRREDUCIBLE_LOOP;
+ }
+
+ return res;
}
/* Splits block BB just after labels. The newly created edge is returned. */
bool ret;
if (!cfg_hooks->move_block_after)
- internal_error ("%s does not support move_block_after.", cfg_hooks->name);
+ internal_error ("%s does not support move_block_after", cfg_hooks->name);
ret = cfg_hooks->move_block_after (bb, after);
delete_basic_block (basic_block bb)
{
if (!cfg_hooks->delete_basic_block)
- internal_error ("%s does not support delete_basic_block.", cfg_hooks->name);
+ internal_error ("%s does not support delete_basic_block", cfg_hooks->name);
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));
- VEC_truncate (edge, bb->preds, 0);
- VEC_truncate (edge, bb->succs, 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. */
gcov_type count = e->count;
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);
+ 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;
- EDGE_SUCC (ret, 0)->probability = REG_BR_PROB_BASE;
- EDGE_SUCC (ret, 0)->count = count;
+ single_succ_edge (ret)->probability = REG_BR_PROB_BASE;
+ single_succ_edge (ret)->count = count;
- if (dom_computed[CDI_DOMINATORS])
- set_immediate_dominator (CDI_DOMINATORS, ret, EDGE_PRED (ret, 0)->src);
+ 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_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, provided that all other predecessors of e->dest are
dominated by e->dest. */
- if (get_immediate_dominator (CDI_DOMINATORS, EDGE_SUCC (ret, 0)->dest)
- == EDGE_PRED (ret, 0)->src)
+ if (get_immediate_dominator (CDI_DOMINATORS, single_succ (ret))
+ == single_pred (ret))
{
edge_iterator ei;
- FOR_EACH_EDGE (f, ei, EDGE_SUCC (ret, 0)->dest->preds)
+ FOR_EACH_EDGE (f, ei, single_succ (ret)->preds)
{
- if (f == EDGE_SUCC (ret, 0))
+ if (f == single_succ_edge (ret))
continue;
if (!dominated_by_p (CDI_DOMINATORS, f->src,
- EDGE_SUCC (ret, 0)->dest))
+ single_succ (ret)))
break;
}
if (!f)
- set_immediate_dominator (CDI_DOMINATORS, EDGE_SUCC (ret, 0)->dest, ret);
+ 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;
}
basic_block ret;
if (!cfg_hooks->create_basic_block)
- internal_error ("%s does not support create_basic_block.", cfg_hooks->name);
+ internal_error ("%s does not support create_basic_block", cfg_hooks->name);
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 ret;
if (!cfg_hooks->can_merge_blocks_p)
- internal_error ("%s does not support can_merge_blocks_p.", cfg_hooks->name);
+ internal_error ("%s does not support can_merge_blocks_p", cfg_hooks->name);
ret = cfg_hooks->can_merge_blocks_p (bb1, bb2);
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);
+ 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)
+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);
+ internal_error ("%s does not support predicted_by_p", cfg_hooks->name);
return cfg_hooks->predicted_by_p (bb, predictor);
}
edge_iterator ei;
if (!cfg_hooks->merge_blocks)
- internal_error ("%s does not support merge_blocks.", cfg_hooks->name);
+ 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);
+
/* 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;
- a->global_live_at_end = b->global_live_at_end;
- 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.",
+ internal_error ("%s does not support make_forwarder_block",
cfg_hooks->name);
fallthru = split_block_after_labels (bb);
/* Redirect back edges we want to keep. */
for (ei = ei_start (dummy->preds); (e = ei_safe_edge (ei)); )
{
+ basic_block e_src;
+
if (redirect_edge_p (e))
{
ei_next (&ei);
if (fallthru->count < 0)
fallthru->count = 0;
+ e_src = e->src;
jump = redirect_edge_and_branch_force (e, bb);
- if (jump)
- new_bb_cbk (jump);
+ if (jump != NULL)
+ {
+ /* If we redirected the loop latch edge, the JUMP block now acts like
+ the new latch of the loop. */
+ if (current_loops != NULL
+ && dummy->loop_father != NULL
+ && dummy->loop_father->header == dummy
+ && dummy->loop_father->latch == e_src)
+ dummy->loop_father->latch = jump;
+
+ if (new_bb_cbk != NULL)
+ new_bb_cbk (jump);
+ }
+ }
+
+ if (dom_info_available_p (CDI_DOMINATORS))
+ {
+ 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 (dom_computed[CDI_DOMINATORS] >= DOM_CONS_OK)
+ if (current_loops != NULL)
{
- basic_block doms_to_fix[2];
+ /* 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);
return fallthru;
}
+/* Try to make the edge fallthru. */
+
void
tidy_fallthru_edge (edge e)
{
/* Fix up edges that now fall through, or rather should now fall through
but previously required a jump around now deleted blocks. Simplify
the search by only examining blocks numerically adjacent, since this
- is how find_basic_blocks created them. */
+ is how they were created.
+
+ ??? This routine is currently RTL specific. */
void
tidy_fallthru_edges (void)
a single successor.
If we had a conditional branch to the next instruction when
- find_basic_blocks was called, then there will only be one
- out edge for the block which ended with the conditional
- branch (since we do not create duplicate edges).
+ CFG was built, then there will only be one out edge for the
+ block which ended with the conditional branch (since we do
+ not create duplicate edges).
Furthermore, the edge will be marked as a fallthru because we
merge the flags for the duplicate edges. So we do not want to
check that the edge is not a FALLTHRU edge. */
- if (EDGE_COUNT (b->succs) == 1)
+ if (single_succ_p (b))
{
- s = EDGE_SUCC (b, 0);
+ s = single_succ_edge (b);
if (! (s->flags & EDGE_COMPLEX)
&& s->dest == c
&& !find_reg_note (BB_END (b), REG_CROSSING_JUMP, NULL_RTX))
}
}
+/* Edge E is assumed to be fallthru edge. Emit needed jump instruction
+ (and possibly create new basic block) to make edge non-fallthru.
+ Return newly created BB or NULL if none. */
+
+basic_block
+force_nonfallthru (edge e)
+{
+ basic_block ret, src = e->src;
+
+ if (!cfg_hooks->force_nonfallthru)
+ internal_error ("%s does not support force_nonfallthru",
+ cfg_hooks->name);
+
+ ret = cfg_hooks->force_nonfallthru (e);
+ if (ret != NULL)
+ {
+ if (dom_info_available_p (CDI_DOMINATORS))
+ set_immediate_dominator (CDI_DOMINATORS, ret, src);
+
+ if (current_loops != NULL)
+ {
+ struct loop *loop
+ = find_common_loop (single_pred (ret)->loop_father,
+ single_succ (ret)->loop_father);
+ rescan_loop_exit (e, false, true);
+ add_bb_to_loop (ret, loop);
+ }
+ }
+
+ return ret;
+}
+
/* 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;
- edge_iterator ei;
-
if (!cfg_hooks->can_duplicate_block_p)
- internal_error ("%s does not support 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. */
- FOR_EACH_EDGE (e, ei, bb->succs)
- if (e->dest == EXIT_BLOCK_PTR && 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. */
+ new basic block. The new basic block is placed after the basic block
+ AFTER. */
basic_block
-duplicate_block (basic_block bb, edge e)
+duplicate_block (basic_block bb, edge e, basic_block after)
{
edge s, n;
basic_block new_bb;
edge_iterator ei;
if (!cfg_hooks->duplicate_block)
- internal_error ("%s does not support duplicate_block.",
+ internal_error ("%s does not support duplicate_block",
cfg_hooks->name);
if (bb->count < new_count)
new_count = bb->count;
- gcc_assert (EDGE_COUNT (bb->preds) > 0);
-#ifdef ENABLE_CHECKING
- gcc_assert (can_duplicate_block_p (bb));
-#endif
+
+ gcc_checking_assert (can_duplicate_block_p (bb));
new_bb = cfg_hooks->duplicate_block (bb);
+ if (after)
+ move_block_after (new_bb, after);
new_bb->loop_depth = bb->loop_depth;
new_bb->flags = bb->flags;
new_bb->frequency = bb->frequency;
}
- new_bb->rbi->original = bb;
- bb->rbi->copy = new_bb;
+ 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
-block_ends_with_condjump_p (basic_block bb)
+bool
+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",
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);
}
+
+/* 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);
+}
+
+/* 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)
+{
+ if (cfg_hooks->flush_pending_stmts)
+ cfg_hooks->flush_pending_stmts (e);
+}
+
+/* Loop versioning uses the duplicate_loop_to_header_edge to create
+ a new version of the loop basic-blocks, the parameters here are
+ exactly the same as in duplicate_loop_to_header_edge or
+ tree_duplicate_loop_to_header_edge; while in tree-ssa there is
+ additional work to maintain ssa information that's why there is
+ a need to call the tree_duplicate_loop_to_header_edge rather
+ 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,
+ unsigned int ndupl,
+ sbitmap wont_exit, edge orig,
+ 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,
+ ndupl, wont_exit,
+ orig, to_remove,
+ flags);
+}
+
+/* Conditional jumps are represented differently in trees and RTL,
+ this hook takes a basic block that is known to have a cond jump
+ at its end and extracts the taken and not taken edges out of it
+ and store it in E1 and E2 respectively. */
+void
+extract_cond_bb_edges (basic_block b, edge *e1, edge *e2)
+{
+ gcc_assert (cfg_hooks->extract_cond_bb_edges);
+ cfg_hooks->extract_cond_bb_edges (b, e1, e2);
+}
+
+/* Responsible for updating the ssa info (PHI nodes) on the
+ new condition basic block that guards the versioned loop. */
+void
+lv_adjust_loop_header_phi (basic_block first, basic_block second,
+ basic_block new_block, edge e)
+{
+ if (cfg_hooks->lv_adjust_loop_header_phi)
+ cfg_hooks->lv_adjust_loop_header_phi (first, second, new_block, e);
+}
+
+/* Conditions in trees and RTL are different so we need
+ a different handling when we add the condition to the
+ versioning code. */
+void
+lv_add_condition_to_bb (basic_block first, basic_block second,
+ 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_block, cond);
+}