X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fcfghooks.c;h=e224ad81ca24f1bda63556e1ea85f35240eaefe9;hb=f7a00bdb09cb3716b05e56bcacfaab14f81102be;hp=42d1183841a6ee0bf327c697eeca8de1fbe4f2c4;hpb=532f6ac12898fe43f5e2f172bd72a5a14c4c00cc;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c
index 42d1183841a..e224ad81ca2 100644
--- a/gcc/cfghooks.c
+++ b/gcc/cfghooks.c
@@ -1,12 +1,12 @@
 /* Hooks for cfg representation specific functions.
-   Copyright (C) 2003, 2004 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,
@@ -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, 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"
@@ -29,6 +28,7 @@ Boston, MA 02111-1307, 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.
@@ -72,13 +79,13 @@ 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;
@@ -108,21 +115,33 @@ 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)
 	{
-	  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);
@@ -141,7 +160,7 @@ verify_flow_info (void)
 	      err = 1;
 	    }
 
-	  last_visited [e->dest->index + 2] = bb;
+	  last_visited [e->dest->index] = bb;
 
 	  if (e->flags & EDGE_FALLTHRU)
 	    n_fallthru++;
@@ -158,11 +177,11 @@ verify_flow_info (void)
 	      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;
 	}
 
@@ -192,7 +211,7 @@ verify_flow_info (void)
 	      err = 1;
 	    }
 
-	  edge_checksum[e->dest->index + 2] -= (size_t) e;
+	  edge_checksum[e->dest->index] -= (size_t) e;
 	}
     }
 
@@ -202,20 +221,19 @@ verify_flow_info (void)
     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.  */
@@ -239,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';
 
@@ -286,14 +304,69 @@ redirect_edge_and_branch (edge e, basic_block dest)
   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 (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.  */
@@ -301,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.",
+    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;
 }
@@ -322,7 +414,7 @@ split_block (basic_block bb, void *i)
   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)
@@ -338,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);
 }
 
@@ -358,7 +457,7 @@ move_block_after (basic_block bb, basic_block after)
   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);
 
@@ -371,10 +470,26 @@ void
 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)
@@ -382,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.  */
@@ -401,27 +516,32 @@ 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);
+    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 (irr)
     {
       ret->flags |= BB_IRREDUCIBLE_LOOP;
-      EDGE_PRED (ret, 0)->flags |= EDGE_IRREDUCIBLE_LOOP;
-      EDGE_SUCC (ret, 0)->flags |= EDGE_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, EDGE_PRED (ret, 0)->src);
+  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:
 
@@ -432,24 +552,33 @@ split_edge (edge e)
 	 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;
 }
@@ -464,13 +593,13 @@ create_basic_block (void *head, void *end, basic_block after)
   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;
@@ -492,7 +621,7 @@ can_merge_blocks_p (basic_block bb1, basic_block bb2)
   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);
 
@@ -503,7 +632,7 @@ 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);
+    internal_error ("%s does not support predict_edge", cfg_hooks->name);
 
   cfg_hooks->predict_edge (e, predictor, probability);
 }
@@ -512,7 +641,7 @@ 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);
+    internal_error ("%s does not support predicted_by_p", cfg_hooks->name);
 
   return cfg_hooks->predicted_by_p (bb, predictor);
 }
@@ -526,34 +655,40 @@ merge_blocks (basic_block a, basic_block b)
   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);
@@ -570,9 +705,10 @@ 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.",
+    internal_error ("%s does not support make_forwarder_block",
 		    cfg_hooks->name);
 
   fallthru = split_block_after_labels (bb);
@@ -599,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);
+    }
 
-      doms_to_fix[0] = dummy;
-      doms_to_fix[1] = bb;
-      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 = loop_outer (ploop))
+	if (ploop->latch == dummy)
+	  ploop->latch = bb;
     }
 
   cfg_hooks->make_forwarder_block (fallthru);
@@ -658,9 +825,9 @@ tidy_fallthru_edges (void)
 	 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))
@@ -674,30 +841,22 @@ tidy_fallthru_edges (void)
 bool
 can_duplicate_block_p (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;
@@ -705,7 +864,7 @@ duplicate_block (basic_block bb, edge e)
   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)
@@ -716,6 +875,8 @@ duplicate_block (basic_block bb, edge e)
 #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;
@@ -758,8 +919,17 @@ duplicate_block (basic_block bb, edge e)
       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;
 }
@@ -767,7 +937,7 @@ duplicate_block (basic_block bb, edge e)
 /* 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,8 +970,91 @@ 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);
 }
+
+/* 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_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);
+}