Daily bump.

[pf3gnuchains/gcc-fork.git] / gcc / cfghooks.c

diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c
index 138bc4a..f5fb18f 100644 (file)
--- a/gcc/cfghooks.c
+++ b/gcc/cfghooks.c
@@ -1,12 +1,12 @@
 /* Hooks for cfg representation specific functions.
 /* 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
    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,
 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
 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"
 
 #include "config.h"
 #include "system.h"


@@ -29,6 +28,7 @@ Boston, MA 02110-1301, USA.  */
 #include "tree-flow.h"
 #include "timevar.h"
 #include "toplev.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;
 
 /* 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;
 }
 
   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.
 }
 
 /* Verify the CFG consistency.


@@ -77,8 +84,8 @@ verify_flow_info (void)
   basic_block *last_visited;
 
   timevar_push (TV_CFG_VERIFY);
   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;
 
   /* Check bb chain & numbers.  */
   last_bb_seen = ENTRY_BLOCK_PTR;


@@ -108,21 +115,33 @@ verify_flow_info (void)
       edge e;
       edge_iterator ei;
 
       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",
       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",
          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)
        {
          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);
            {
              error ("verify_flow_info: Duplicate edge %i->%i",
                     e->src->index, e->dest->index);


@@ -141,7 +160,7 @@ verify_flow_info (void)
              err = 1;
            }
 
              err = 1;
            }
 

-         last_visited [e->dest->index + 2] = bb;
+         last_visited [e->dest->index] = bb;

 
          if (e->flags & EDGE_FALLTHRU)
            n_fallthru++;
 
          if (e->flags & EDGE_FALLTHRU)
            n_fallthru++;


@@ -158,7 +177,7 @@ verify_flow_info (void)
              err = 1;
            }
 
              err = 1;
            }
 

-         edge_checksum[e->dest->index + 2] += (size_t) e;
+         edge_checksum[e->dest->index] += (size_t) e;

        }
       if (n_fallthru > 1)
        {
        }
       if (n_fallthru > 1)
        {


@@ -192,7 +211,7 @@ verify_flow_info (void)
              err = 1;
            }
 
              err = 1;
            }
 

-         edge_checksum[e->dest->index + 2] -= (size_t) e;
+         edge_checksum[e->dest->index] -= (size_t) e;

        }
     }
 
        }
     }
 


@@ -202,14 +221,14 @@ verify_flow_info (void)
     edge_iterator ei;
 
     FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
     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)
 
     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)
   }
 
   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;
       {
        error ("basic block %i edge lists are corrupted", bb->index);
        err = 1;


@@ -238,8 +257,8 @@ dump_bb (basic_block bb, FILE *outf, int indent)
   edge e;
   edge_iterator ei;
   char *s_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';
 
   memset (s_indent, ' ', (size_t) indent);
   s_indent[indent] = '\0';
 


@@ -290,9 +309,64 @@ redirect_edge_and_branch (edge e, basic_block dest)
 
   ret = cfg_hooks->redirect_edge_and_branch (e, dest);
 
 
   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;
 }
 
   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.  */
 /* 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.  */


@@ -300,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
 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 (!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);
   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;
 }
 
   return ret;
 }


@@ -337,6 +430,13 @@ split_block (basic_block bb, void *i)
       set_immediate_dominator (CDI_DOMINATORS, new_bb, bb);
     }
 
       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);
 }
 
   return make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU);
 }
 


@@ -374,6 +474,22 @@ delete_basic_block (basic_block bb)
 
   cfg_hooks->delete_basic_block (bb);
 
 
   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)
   /* 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)


@@ -381,9 +497,9 @@ delete_basic_block (basic_block bb)
   while (EDGE_COUNT (bb->succs) != 0)
     remove_edge (EDGE_SUCC (bb, 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);
     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.  */
     delete_from_dominance_info (CDI_POST_DOMINATORS, bb);
 
   /* Remove the basic block from the array.  */


@@ -400,10 +516,15 @@ split_edge (edge e)
   int freq = EDGE_FREQUENCY (e);
   edge f;
   bool irr = (e->flags & EDGE_IRREDUCIBLE_LOOP) != 0;
   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 (!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;
   ret = cfg_hooks->split_edge (e);
   ret->count = count;
   ret->frequency = freq;


@@ -417,10 +538,10 @@ split_edge (edge e)
       single_succ_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP;
     }
 
       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));
 
     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:
 
     {
       /* There are two cases:
 


@@ -448,7 +569,16 @@ split_edge (edge e)
          if (!f)
            set_immediate_dominator (CDI_DOMINATORS, single_succ (ret), ret);
        }
          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;
 }
 
   return ret;
 }


@@ -467,9 +597,9 @@ create_basic_block (void *head, void *end, basic_block after)
 
   ret = cfg_hooks->create_basic_block (head, end, after);
 
 
   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);
     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;
     add_to_dominance_info (CDI_POST_DOMINATORS, ret);
 
   return ret;


@@ -508,7 +638,7 @@ predict_edge (edge e, enum br_predictor predictor, int probability)
 }
 
 bool
 }
 
 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->predict_edge)
     internal_error ("%s does not support predicted_by_p", cfg_hooks->name);


@@ -529,29 +659,36 @@ merge_blocks (basic_block a, basic_block b)
 
   cfg_hooks->merge_blocks (a, b);
 
 
   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)
   /* 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)
 
   /* 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->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);
 
     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);
     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);
     delete_from_dominance_info (CDI_POST_DOMINATORS, b);
 
   expunge_block (b);


@@ -568,6 +705,7 @@ make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge),
   edge e, fallthru;
   edge_iterator ei;
   basic_block dummy, jump;
   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",
 
   if (!cfg_hooks->make_forwarder_block)
     internal_error ("%s does not support make_forwarder_block",


@@ -597,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);
        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))
     {
        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);
     }
 
   cfg_hooks->make_forwarder_block (fallthru);


@@ -670,10 +839,8 @@ tidy_fallthru_edges (void)
 /* Returns true if we can duplicate basic block BB.  */
 
 bool
 /* 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 (!cfg_hooks->can_duplicate_block_p)
     internal_error ("%s does not support can_duplicate_block_p",
                    cfg_hooks->name);


@@ -681,12 +848,6 @@ can_duplicate_block_p (basic_block bb)
   if (bb == EXIT_BLOCK_PTR || bb == ENTRY_BLOCK_PTR)
     return false;
 
   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);
 }
 
   return cfg_hooks->can_duplicate_block_p (bb);
 }
 


@@ -761,13 +922,22 @@ duplicate_block (basic_block bb, edge e, basic_block after)
   set_bb_original (new_bb, bb);
   set_bb_copy (bb, 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.  */
 
   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)
 block_ends_with_call_p (basic_block bb)
 {
   if (!cfg_hooks->block_ends_with_call_p)


@@ -778,8 +948,8 @@ block_ends_with_call_p (basic_block bb)
 
 /* Return 1 if BB ends with a conditional branch, 0 otherwise.  */
 
 
 /* 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",
 {
   if (!cfg_hooks->block_ends_with_condjump_p)
     internal_error ("%s does not support block_ends_with_condjump_p",


@@ -800,7 +970,7 @@ int
 flow_call_edges_add (sbitmap blocks)
 {
   if (!cfg_hooks->flow_call_edges_add)
 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->name);
 
   return (cfg_hooks->flow_call_edges_add) (blocks);


@@ -826,8 +996,8 @@ execute_on_shrinking_pred (edge e)
     cfg_hooks->execute_on_shrinking_pred (e);
 }
 
     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)
    in tree's and in RTL, so we made a CFG hook.  */
 void
 lv_flush_pending_stmts (edge e)


@@ -845,16 +1015,16 @@ 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,
    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,
                                        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);
 {
   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,
                                                            ndupl, wont_exit,
                                                            orig, to_remove,

-                                                           n_to_remove, flags);
+                                                           flags);

 }
 
 /* Conditional jumps are represented differently in trees and RTL,
 }
 
 /* Conditional jumps are represented differently in trees and RTL,


@@ -872,10 +1042,10 @@ extract_cond_bb_edges (basic_block b, edge *e1, edge *e2)
    new condition basic block that guards the versioned loop.  */
 void
 lv_adjust_loop_header_phi (basic_block first, basic_block second,
    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)
 {
   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
 }
 
 /* Conditions in trees and RTL are different so we need


@@ -883,8 +1053,8 @@ lv_adjust_loop_header_phi (basic_block first, basic_block second,
    versioning code.  */
 void
 lv_add_condition_to_bb (basic_block first, basic_block second,
    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);
 {
   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);
+}