/* Hooks for cfg representation specific functions.
- Copyright (C) 2003 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Sebastian Pop <s.pop@laposte.net>
This file is part of GCC.
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. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "basic-block.h"
+#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 = &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. */
+
+enum ir_type
+current_ir_type (void)
+{
+ 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.
Currently it does following: checks edge and basic block list correctness
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;
{
int n_fallthru = 0;
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 (e = bb->succ; e; e = e->succ_next)
+ 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;
}
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
{
if (e->dest != bb)
{
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;
}
}
/* Complete edge checksumming for ENTRY and EXIT. */
{
edge e;
+ edge_iterator ei;
- for (e = ENTRY_BLOCK_PTR->succ; e ; e = e->succ_next)
- edge_checksum[e->dest->index + 2] += (size_t) e;
+ FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
+ edge_checksum[e->dest->index] += (size_t) e;
- for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next)
- edge_checksum[e->dest->index + 2] -= (size_t) e;
+ FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
+ 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. */
dump_bb (basic_block bb, FILE *outf, int indent)
{
edge e;
+ edge_iterator ei;
char *s_indent;
-
- s_indent = (char *) alloca ((size_t) indent + 1);
- memset ((void *) s_indent, ' ', (size_t) indent);
+
+ s_indent = alloca ((size_t) indent + 1);
+ memset (s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';
fprintf (outf, ";;%s basic block %d, loop depth %d, count ",
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);
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.",
+ 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 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.",
+ 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;
}
basic_block new_bb;
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->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);
}
- return make_edge (bb, new_bb, EDGE_FALLTHRU);
+ if (current_loops != NULL)
+ add_bb_to_loop (new_bb, bb->loop_father);
+
+ return make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU);
}
/* Splits block BB just after labels. The newly created edge is returned. */
return split_block (bb, NULL);
}
-/* Moves block BB immediatelly after block AFTER. Returns false if the
+/* Moves block BB immediately after block AFTER. Returns false if the
movement was impossible. */
bool
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 (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);
basic_block ret;
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;
- 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)
- set_immediate_dominator (CDI_DOMINATORS, ret->succ->dest,
- recount_dominator (CDI_DOMINATORS,
- ret->succ->dest));
+ {
+ /* There are two cases:
+
+ If the immediate dominator of e->dest is not e->src, it
+ remains unchanged.
+
+ If immediate dominator of e->dest is e->src, it may become
+ ret, provided that all other predecessors of e->dest are
+ dominated by e->dest. */
+
+ if (get_immediate_dominator (CDI_DOMINATORS, single_succ (ret))
+ == single_pred (ret))
+ {
+ edge_iterator ei;
+ FOR_EACH_EDGE (f, ei, single_succ (ret)->preds)
+ {
+ if (f == single_succ_edge (ret))
+ continue;
+
+ if (!dominated_by_p (CDI_DOMINATORS, f->src,
+ single_succ (ret)))
+ break;
+ }
+
+ 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;
}
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);
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);
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);
+ internal_error ("%s does not support merge_blocks", cfg_hooks->name);
+
+ if (current_loops != NULL)
+ remove_bb_from_loops (b);
cfg_hooks->merge_blocks (a, 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)
+ {
+ 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 (e = b->succ; e; e = e->succ_next)
- e->src = a;
- a->succ = b->succ;
+ FOR_EACH_EDGE (e, ei, b->succs)
+ {
+ 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->pred = b->succ = NULL;
- a->global_live_at_end = b->global_live_at_end;
+ b->preds = b->succs = NULL;
if (dom_computed[CDI_DOMINATORS])
redirect_immediate_dominators (CDI_DOMINATORS, b, a);
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;
+ 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);
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;
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)
+ if (jump != NULL
+ && new_bb_cbk != NULL)
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];
iterate_fix_dominators (CDI_DOMINATORS, doms_to_fix, 2);
}
+ 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);
+ }
+
+ /* In case we split loop latch, update it. */
+ for (ploop = loop; ploop; ploop = ploop->outer)
+ if (ploop->latch == dummy)
+ ploop->latch = bb;
+ }
+
cfg_hooks->make_forwarder_block (fallthru);
return fallthru;
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. The new basic block is placed after the basic block
+ AFTER. */
+
+basic_block
+duplicate_block (basic_block bb, edge e, basic_block after)
+{
+ 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);
+ if (after)
+ move_block_after (new_bb, after);
+
+ 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;
+ }
+
+ set_bb_original (new_bb, bb);
+ set_bb_copy (bb, new_bb);
+
+ /* Add the new block to the prescribed loop. */
+ if (current_loops != NULL)
+ add_bb_to_loop (new_bb, bb->loop_father->copy);
+
+ 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);
+}
+
+/* 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 eges 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, edge e)
+{
+ if (cfg_hooks->lv_adjust_loop_header_phi)
+ cfg_hooks->lv_adjust_loop_header_phi (first, second, new, 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, void *cond)
+{
+ gcc_assert (cfg_hooks->lv_add_condition_to_bb);
+ cfg_hooks->lv_add_condition_to_bb (first, second, new, cond);
}