* obj-c++.dg/comp-types-10.mm: XFAIL for ICE.

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

diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index bb70bdf..994fb16 100644 (file)
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -1,12 +1,13 @@
 /* Control flow graph manipulation code for GNU compiler.
    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
 /* Control flow graph manipulation code for GNU compiler.
    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

-   1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+   Free Software Foundation, Inc.

 
 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
 
 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) any later
+Software Foundation; either version 3, or (at your option) any later

 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY


@@ -15,9 +16,8 @@ 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
 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/>.  */

 
 /* This file contains low level functions to manipulate the CFG and analyze it
    that are aware of the RTL intermediate language.
 
 /* This file contains low level functions to manipulate the CFG and analyze it
    that are aware of the RTL intermediate language.


@@ -60,9 +60,10 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #include "cfgloop.h"
 #include "ggc.h"
 #include "tree-pass.h"
 #include "cfgloop.h"
 #include "ggc.h"
 #include "tree-pass.h"

+#include "df.h"

 
 

-static int can_delete_note_p (rtx);
-static int can_delete_label_p (rtx);
+static int can_delete_note_p (const_rtx);
+static int can_delete_label_p (const_rtx);

 static void commit_one_edge_insertion (edge);
 static basic_block rtl_split_edge (edge);
 static bool rtl_move_block_after (basic_block, basic_block);
 static void commit_one_edge_insertion (edge);
 static basic_block rtl_split_edge (edge);
 static bool rtl_move_block_after (basic_block, basic_block);


@@ -83,16 +84,16 @@ static void rtl_make_forwarder_block (edge);
    so that we may simply delete it.  */
 
 static int
    so that we may simply delete it.  */
 
 static int

-can_delete_note_p (rtx note)
+can_delete_note_p (const_rtx note)

 {
 {

-  return (NOTE_LINE_NUMBER (note) == NOTE_INSN_DELETED
-         || NOTE_LINE_NUMBER (note) == NOTE_INSN_BASIC_BLOCK);
+  return (NOTE_KIND (note) == NOTE_INSN_DELETED
+         || NOTE_KIND (note) == NOTE_INSN_BASIC_BLOCK);

 }
 
 /* True if a given label can be deleted.  */
 
 static int
 }
 
 /* True if a given label can be deleted.  */
 
 static int

-can_delete_label_p (rtx label)
+can_delete_label_p (const_rtx label)

 {
   return (!LABEL_PRESERVE_P (label)
          /* User declared labels must be preserved.  */
 {
   return (!LABEL_PRESERVE_P (label)
          /* User declared labels must be preserved.  */


@@ -120,7 +121,7 @@ delete_insn (rtx insn)
 
          really_delete = false;
          PUT_CODE (insn, NOTE);
 
          really_delete = false;
          PUT_CODE (insn, NOTE);

-         NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED_LABEL;
+         NOTE_KIND (insn) = NOTE_INSN_DELETED_LABEL;

          NOTE_DELETED_LABEL_NAME (insn) = name;
        }
 
          NOTE_DELETED_LABEL_NAME (insn) = name;
        }
 


@@ -137,15 +138,15 @@ delete_insn (rtx insn)
 
   /* If deleting a jump, decrement the use count of the label.  Deleting
      the label itself should happen in the normal course of block merging.  */
 
   /* If deleting a jump, decrement the use count of the label.  Deleting
      the label itself should happen in the normal course of block merging.  */

-  if (JUMP_P (insn)
-      && JUMP_LABEL (insn)
-      && LABEL_P (JUMP_LABEL (insn)))
-    LABEL_NUSES (JUMP_LABEL (insn))--;
-
-  /* Also if deleting an insn that references a label.  */
-  else
+  if (JUMP_P (insn))

     {
     {

-      while ((note = find_reg_note (insn, REG_LABEL, NULL_RTX)) != NULL_RTX
+      if (JUMP_LABEL (insn)
+         && LABEL_P (JUMP_LABEL (insn)))
+       LABEL_NUSES (JUMP_LABEL (insn))--;
+
+      /* If there are more targets, remove them too.  */
+      while ((note
+             = find_reg_note (insn, REG_LABEL_TARGET, NULL_RTX)) != NULL_RTX

             && LABEL_P (XEXP (note, 0)))
        {
          LABEL_NUSES (XEXP (note, 0))--;
             && LABEL_P (XEXP (note, 0)))
        {
          LABEL_NUSES (XEXP (note, 0))--;


@@ -153,6 +154,14 @@ delete_insn (rtx insn)
        }
     }
 
        }
     }
 

+  /* Also if deleting any insn that references a label as an operand.  */
+  while ((note = find_reg_note (insn, REG_LABEL_OPERAND, NULL_RTX)) != NULL_RTX
+        && LABEL_P (XEXP (note, 0)))
+    {
+      LABEL_NUSES (XEXP (note, 0))--;
+      remove_note (insn, note);
+    }
+

   if (JUMP_P (insn)
       && (GET_CODE (PATTERN (insn)) == ADDR_VEC
          || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC))
   if (JUMP_P (insn)
       && (GET_CODE (PATTERN (insn)) == ADDR_VEC
          || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC))


@@ -178,6 +187,7 @@ delete_insn (rtx insn)
 }
 
 /* Like delete_insn but also purge dead edges from BB.  */
 }
 
 /* Like delete_insn but also purge dead edges from BB.  */

+

 rtx
 delete_insn_and_edges (rtx insn)
 {
 rtx
 delete_insn_and_edges (rtx insn)
 {


@@ -195,10 +205,11 @@ delete_insn_and_edges (rtx insn)
 }
 
 /* Unlink a chain of insns between START and FINISH, leaving notes
 }
 
 /* Unlink a chain of insns between START and FINISH, leaving notes

-   that must be paired.  */
+   that must be paired.  If CLEAR_BB is true, we set bb field for
+   insns that cannot be removed to NULL.  */

 
 void
 
 void

-delete_insn_chain (rtx start, rtx finish)
+delete_insn_chain (rtx start, rtx finish, bool clear_bb)

 {
   rtx next;
 
 {
   rtx next;
 


@@ -213,13 +224,17 @@ delete_insn_chain (rtx start, rtx finish)
       else
        next = delete_insn (start);
 
       else
        next = delete_insn (start);
 

+      if (clear_bb && !INSN_DELETED_P (start))
+       set_block_for_insn (start, NULL);
+

       if (start == finish)
        break;
       start = next;
     }
 }
 
       if (start == finish)
        break;
       start = next;
     }
 }
 

-/* Like delete_insn but also purge dead edges from BB.  */
+/* Like delete_insn_chain but also purge dead edges from BB.  */
+

 void
 delete_insn_chain_and_edges (rtx first, rtx last)
 {
 void
 delete_insn_chain_and_edges (rtx first, rtx last)
 {


@@ -229,7 +244,7 @@ delete_insn_chain_and_edges (rtx first, rtx last)
       && BLOCK_FOR_INSN (last)
       && BB_END (BLOCK_FOR_INSN (last)) == last)
     purge = true;
       && BLOCK_FOR_INSN (last)
       && BB_END (BLOCK_FOR_INSN (last)) == last)
     purge = true;

-  delete_insn_chain (first, last);
+  delete_insn_chain (first, last, false);

   if (purge)
     purge_dead_edges (BLOCK_FOR_INSN (last));
 }
   if (purge)
     purge_dead_edges (BLOCK_FOR_INSN (last));
 }


@@ -303,6 +318,7 @@ create_basic_block_structure (rtx head, rtx end, rtx bb_note, basic_block after)
   bb->flags = BB_NEW | BB_RTL;
   link_block (bb, after);
   SET_BASIC_BLOCK (bb->index, bb);
   bb->flags = BB_NEW | BB_RTL;
   link_block (bb, after);
   SET_BASIC_BLOCK (bb->index, bb);

+  df_bb_refs_record (bb->index, false);

   update_bb_for_insn (bb);
   BB_SET_PARTITION (bb, BB_UNPARTITIONED);
 
   update_bb_for_insn (bb);
   BB_SET_PARTITION (bb, BB_UNPARTITIONED);
 


@@ -321,18 +337,14 @@ create_basic_block_structure (rtx head, rtx end, rtx bb_note, basic_block after)
 static basic_block
 rtl_create_basic_block (void *headp, void *endp, basic_block after)
 {
 static basic_block
 rtl_create_basic_block (void *headp, void *endp, basic_block after)
 {

-  rtx head = headp, end = endp;
+  rtx head = (rtx) headp, end = (rtx) endp;

   basic_block bb;
 
   /* Grow the basic block array if needed.  */
   if ((size_t) last_basic_block >= VEC_length (basic_block, basic_block_info))
     {
   basic_block bb;
 
   /* Grow the basic block array if needed.  */
   if ((size_t) last_basic_block >= VEC_length (basic_block, basic_block_info))
     {

-      size_t old_size = VEC_length (basic_block, basic_block_info);

       size_t new_size = last_basic_block + (last_basic_block + 3) / 4;
       size_t new_size = last_basic_block + (last_basic_block + 3) / 4;

-      basic_block *p;
-      VEC_safe_grow (basic_block, gc, basic_block_info, new_size);
-      p = VEC_address (basic_block, basic_block_info);
-      memset (&p[old_size], 0, sizeof (basic_block) * (new_size - old_size));
+      VEC_safe_grow_cleared (basic_block, gc, basic_block_info, new_size);

     }
 
   n_basic_blocks++;
     }
 
   n_basic_blocks++;


@@ -374,14 +386,12 @@ rtl_delete_block (basic_block b)
 
   /* Selectively delete the entire chain.  */
   BB_HEAD (b) = NULL;
 
   /* Selectively delete the entire chain.  */
   BB_HEAD (b) = NULL;

-  delete_insn_chain (insn, end);
-  if (b->il.rtl->global_live_at_start)
-    {
-      FREE_REG_SET (b->il.rtl->global_live_at_start);
-      FREE_REG_SET (b->il.rtl->global_live_at_end);
-      b->il.rtl->global_live_at_start = NULL;
-      b->il.rtl->global_live_at_end = NULL;
-    }
+  delete_insn_chain (insn, end, true);
+
+
+  if (dump_file)
+    fprintf (dump_file, "deleting block %d\n", b->index);
+  df_bb_delete (b->index);

 }
 \f
 /* Records the basic block struct in BLOCK_FOR_INSN for every insn.  */
 }
 \f
 /* Records the basic block struct in BLOCK_FOR_INSN for every insn.  */


@@ -417,8 +427,10 @@ free_bb_for_insn (void)
   return 0;
 }
 
   return 0;
 }
 

-struct tree_opt_pass pass_free_cfg =
+struct rtl_opt_pass pass_free_cfg =

 {
 {

+ {
+  RTL_PASS,

   NULL,                                 /* name */
   NULL,                                 /* gate */
   free_bb_for_insn,                     /* execute */
   NULL,                                 /* name */
   NULL,                                 /* gate */
   free_bb_for_insn,                     /* execute */


@@ -431,7 +443,7 @@ struct tree_opt_pass pass_free_cfg =
   PROP_cfg,                             /* properties_destroyed */
   0,                                    /* todo_flags_start */
   0,                                    /* todo_flags_finish */
   PROP_cfg,                             /* properties_destroyed */
   0,                                    /* todo_flags_start */
   0,                                    /* todo_flags_finish */

-  0                                     /* letter */
+ }

 };
 
 /* Return RTX to emit after when we want to emit code on the entry of function.  */
 };
 
 /* Return RTX to emit after when we want to emit code on the entry of function.  */


@@ -455,22 +467,52 @@ emit_insn_at_entry (rtx insn)
   commit_edge_insertions ();
 }
 
   commit_edge_insertions ();
 }
 

-/* Update insns block within BB.  */
+/* Update BLOCK_FOR_INSN of insns between BEGIN and END
+   (or BARRIER if found) and notify df of the bb change. 
+   The insn chain range is inclusive
+   (i.e. both BEGIN and END will be updated. */
+
+static void
+update_bb_for_insn_chain (rtx begin, rtx end, basic_block bb)
+{
+  rtx insn;
+
+  end = NEXT_INSN (end);
+  for (insn = begin; insn != end; insn = NEXT_INSN (insn))
+    if (!BARRIER_P (insn))
+      df_insn_change_bb (insn, bb);
+}
+
+/* Update BLOCK_FOR_INSN of insns in BB to BB,
+   and notify df of the change.  */

 
 void
 update_bb_for_insn (basic_block bb)
 {
 
 void
 update_bb_for_insn (basic_block bb)
 {

+  update_bb_for_insn_chain (BB_HEAD (bb), BB_END (bb), bb);
+}
+
+\f
+/* Return the INSN immediately following the NOTE_INSN_BASIC_BLOCK
+   note associated with the BLOCK.  */
+
+static rtx
+first_insn_after_basic_block_note (basic_block block)
+{

   rtx insn;
 
   rtx insn;
 

-  for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
-    {
-      if (!BARRIER_P (insn))
-       set_block_for_insn (insn, bb);
-      if (insn == BB_END (bb))
-       break;
-    }
+  /* Get the first instruction in the block.  */
+  insn = BB_HEAD (block);
+
+  if (insn == NULL_RTX)
+    return NULL_RTX;
+  if (LABEL_P (insn))
+    insn = NEXT_INSN (insn);
+  gcc_assert (NOTE_INSN_BASIC_BLOCK_P (insn));
+
+  return NEXT_INSN (insn);

 }
 }

-\f
+

 /* Creates a new basic block just after basic block B by splitting
    everything after specified instruction I.  */
 
 /* Creates a new basic block just after basic block B by splitting
    everything after specified instruction I.  */
 


@@ -478,7 +520,7 @@ static basic_block
 rtl_split_block (basic_block bb, void *insnp)
 {
   basic_block new_bb;
 rtl_split_block (basic_block bb, void *insnp)
 {
   basic_block new_bb;

-  rtx insn = insnp;
+  rtx insn = (rtx) insnp;

   edge e;
   edge_iterator ei;
 
   edge e;
   edge_iterator ei;
 


@@ -509,32 +551,8 @@ rtl_split_block (basic_block bb, void *insnp)
   FOR_EACH_EDGE (e, ei, new_bb->succs)
     e->src = new_bb;
 
   FOR_EACH_EDGE (e, ei, new_bb->succs)
     e->src = new_bb;
 

-  if (bb->il.rtl->global_live_at_start)
-    {
-      new_bb->il.rtl->global_live_at_start = ALLOC_REG_SET (&reg_obstack);
-      new_bb->il.rtl->global_live_at_end = ALLOC_REG_SET (&reg_obstack);
-      COPY_REG_SET (new_bb->il.rtl->global_live_at_end, bb->il.rtl->global_live_at_end);
-
-      /* We now have to calculate which registers are live at the end
-        of the split basic block and at the start of the new basic
-        block.  Start with those registers that are known to be live
-        at the end of the original basic block and get
-        propagate_block to determine which registers are live.  */
-      COPY_REG_SET (new_bb->il.rtl->global_live_at_start, bb->il.rtl->global_live_at_end);
-      propagate_block (new_bb, new_bb->il.rtl->global_live_at_start, NULL, NULL, 0);
-      COPY_REG_SET (bb->il.rtl->global_live_at_end,
-                   new_bb->il.rtl->global_live_at_start);
-#ifdef HAVE_conditional_execution
-      /* In the presence of conditional execution we are not able to update
-        liveness precisely.  */
-      if (reload_completed)
-       {
-         bb->flags |= BB_DIRTY;
-         new_bb->flags |= BB_DIRTY;
-       }
-#endif
-    }
-
+  /* The new block starts off being dirty.  */
+  df_set_bb_dirty (bb);

   return new_bb;
 }
 
   return new_bb;
 }
 


@@ -548,6 +566,9 @@ rtl_merge_blocks (basic_block a, basic_block b)
   rtx del_first = NULL_RTX, del_last = NULL_RTX;
   int b_empty = 0;
 
   rtx del_first = NULL_RTX, del_last = NULL_RTX;
   int b_empty = 0;
 

+  if (dump_file)
+    fprintf (dump_file, "merging block %d into block %d\n", b->index, a->index);
+

   /* If there was a CODE_LABEL beginning B, delete it.  */
   if (LABEL_P (b_head))
     {
   /* If there was a CODE_LABEL beginning B, delete it.  */
   if (LABEL_P (b_head))
     {


@@ -584,7 +605,7 @@ rtl_merge_blocks (basic_block a, basic_block b)
 
       for (prev = PREV_INSN (a_end); ; prev = PREV_INSN (prev))
        if (!NOTE_P (prev)
 
       for (prev = PREV_INSN (a_end); ; prev = PREV_INSN (prev))
        if (!NOTE_P (prev)

-           || NOTE_LINE_NUMBER (prev) == NOTE_INSN_BASIC_BLOCK
+           || NOTE_INSN_BASIC_BLOCK_P (prev)

            || prev == BB_HEAD (a))
          break;
 
            || prev == BB_HEAD (a))
          break;
 


@@ -612,28 +633,25 @@ rtl_merge_blocks (basic_block a, basic_block b)
   /* Delete everything marked above as well as crap that might be
      hanging out between the two blocks.  */
   BB_HEAD (b) = NULL;
   /* Delete everything marked above as well as crap that might be
      hanging out between the two blocks.  */
   BB_HEAD (b) = NULL;

-  delete_insn_chain (del_first, del_last);
+  delete_insn_chain (del_first, del_last, true);

 
   /* Reassociate the insns of B with A.  */
   if (!b_empty)
     {
 
   /* Reassociate the insns of B with A.  */
   if (!b_empty)
     {

-      rtx x;
-
-      for (x = a_end; x != b_end; x = NEXT_INSN (x))
-       set_block_for_insn (x, a);
-
-      set_block_for_insn (b_end, a);
+      update_bb_for_insn_chain (a_end, b_end, a);

 
       a_end = b_end;
     }
 
 
       a_end = b_end;
     }
 

+  df_bb_delete (b->index);

   BB_END (a) = a_end;
   BB_END (a) = a_end;

-  a->il.rtl->global_live_at_end = b->il.rtl->global_live_at_end;

 }
 
 }
 

+

 /* Return true when block A and B can be merged.  */
 /* Return true when block A and B can be merged.  */

+

 static bool
 static bool

-rtl_can_merge_blocks (basic_block a,basic_block b)
+rtl_can_merge_blocks (basic_block a, basic_block b)

 {
   /* If we are partitioning hot/cold basic blocks, we don't want to
      mess up unconditional or indirect jumps that cross between hot
 {
   /* If we are partitioning hot/cold basic blocks, we don't want to
      mess up unconditional or indirect jumps that cross between hot


@@ -732,7 +750,8 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
      the cc0 setter too.  */
   kill_from = insn;
 #ifdef HAVE_cc0
      the cc0 setter too.  */
   kill_from = insn;
 #ifdef HAVE_cc0

-  if (reg_mentioned_p (cc0_rtx, PATTERN (insn)))
+  if (reg_mentioned_p (cc0_rtx, PATTERN (insn))
+      && only_sets_cc0_p (PREV_INSN (insn)))

     kill_from = PREV_INSN (insn);
 #endif
 
     kill_from = PREV_INSN (insn);
 #endif
 


@@ -748,7 +767,7 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
        {
          rtx insn = src->il.rtl->footer;
 
        {
          rtx insn = src->il.rtl->footer;
 

-         delete_insn_chain (kill_from, BB_END (src));
+         delete_insn_chain (kill_from, BB_END (src), false);

 
          /* Remove barriers but keep jumptables.  */
          while (insn)
 
          /* Remove barriers but keep jumptables.  */
          while (insn)


@@ -768,7 +787,8 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
            }
        }
       else
            }
        }
       else

-       delete_insn_chain (kill_from, PREV_INSN (BB_HEAD (target)));
+       delete_insn_chain (kill_from, PREV_INSN (BB_HEAD (target)),
+                          false);

     }
 
   /* If this already is simplejump, redirect it.  */
     }
 
   /* If this already is simplejump, redirect it.  */


@@ -804,13 +824,13 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
                 INSN_UID (insn), INSN_UID (BB_END (src)));
 
 
                 INSN_UID (insn), INSN_UID (BB_END (src)));
 
 

-      delete_insn_chain (kill_from, insn);
+      delete_insn_chain (kill_from, insn, false);

 
       /* Recognize a tablejump that we are converting to a
         simple jump and remove its associated CODE_LABEL
         and ADDR_VEC or ADDR_DIFF_VEC.  */
       if (tablejump_p (insn, &label, &table))
 
       /* Recognize a tablejump that we are converting to a
         simple jump and remove its associated CODE_LABEL
         and ADDR_VEC or ADDR_DIFF_VEC.  */
       if (tablejump_p (insn, &label, &table))

-       delete_insn_chain (label, table);
+       delete_insn_chain (label, table, false);

 
       barrier = next_nonnote_insn (BB_END (src));
       if (!barrier || !BARRIER_P (barrier))
 
       barrier = next_nonnote_insn (BB_END (src));
       if (!barrier || !BARRIER_P (barrier))


@@ -823,11 +843,9 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
                 which originally were or were created before jump table are
                 inside the basic block.  */
              rtx new_insn = BB_END (src);
                 which originally were or were created before jump table are
                 inside the basic block.  */
              rtx new_insn = BB_END (src);

-             rtx tmp;

 
 

-             for (tmp = NEXT_INSN (BB_END (src)); tmp != barrier;
-                  tmp = NEXT_INSN (tmp))
-               set_block_for_insn (tmp, src);
+             update_bb_for_insn_chain (NEXT_INSN (BB_END (src)),
+                                       PREV_INSN (barrier), src);

 
              NEXT_INSN (PREV_INSN (new_insn)) = NEXT_INSN (new_insn);
              PREV_INSN (NEXT_INSN (new_insn)) = PREV_INSN (new_insn);
 
              NEXT_INSN (PREV_INSN (new_insn)) = NEXT_INSN (new_insn);
              PREV_INSN (NEXT_INSN (new_insn)) = PREV_INSN (new_insn);


@@ -857,7 +875,6 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
 
   if (e->dest != target)
     redirect_edge_succ (e, target);
 
   if (e->dest != target)
     redirect_edge_succ (e, target);

-

   return e;
 }
 
   return e;
 }
 


@@ -941,6 +958,7 @@ redirect_branch_edge (edge e, basic_block target)
 
   if (e->dest != target)
     e = redirect_edge_succ_nodup (e, target);
 
   if (e->dest != target)
     e = redirect_edge_succ_nodup (e, target);

+

   return e;
 }
 
   return e;
 }
 


@@ -969,7 +987,7 @@ rtl_redirect_edge_and_branch (edge e, basic_block target)
 
   if ((ret = try_redirect_by_replacing_jump (e, target, false)) != NULL)
     {
 
   if ((ret = try_redirect_by_replacing_jump (e, target, false)) != NULL)
     {

-      src->flags |= BB_DIRTY;
+      df_set_bb_dirty (src);

       return ret;
     }
 
       return ret;
     }
 


@@ -977,7 +995,7 @@ rtl_redirect_edge_and_branch (edge e, basic_block target)
   if (!ret)
     return NULL;
 
   if (!ret)
     return NULL;
 

-  src->flags |= BB_DIRTY;
+  df_set_bb_dirty (src);

   return ret;
 }
 
   return ret;
 }
 


@@ -1085,16 +1103,6 @@ force_nonfallthru_and_redirect (edge e, basic_block target)
       jump_block->frequency = EDGE_FREQUENCY (e);
       jump_block->loop_depth = target->loop_depth;
 
       jump_block->frequency = EDGE_FREQUENCY (e);
       jump_block->loop_depth = target->loop_depth;
 

-      if (target->il.rtl->global_live_at_start)
-       {
-         jump_block->il.rtl->global_live_at_start = ALLOC_REG_SET (&reg_obstack);
-         jump_block->il.rtl->global_live_at_end = ALLOC_REG_SET (&reg_obstack);
-         COPY_REG_SET (jump_block->il.rtl->global_live_at_start,
-                       target->il.rtl->global_live_at_start);
-         COPY_REG_SET (jump_block->il.rtl->global_live_at_end,
-                       target->il.rtl->global_live_at_start);
-       }
-

       /* Make sure new block ends up in correct hot/cold section.  */
 
       BB_COPY_PARTITION (jump_block, e->src);
       /* Make sure new block ends up in correct hot/cold section.  */
 
       BB_COPY_PARTITION (jump_block, e->src);


@@ -1146,6 +1154,7 @@ force_nonfallthru_and_redirect (edge e, basic_block target)
   if (abnormal_edge_flags)
     make_edge (src, target, abnormal_edge_flags);
 
   if (abnormal_edge_flags)
     make_edge (src, target, abnormal_edge_flags);
 

+  df_mark_solutions_dirty (); 

   return new_bb;
 }
 
   return new_bb;
 }
 


@@ -1172,7 +1181,7 @@ rtl_redirect_edge_and_branch_force (edge e, basic_block target)
 
   /* In case the edge redirection failed, try to force it to be non-fallthru
      and redirect newly created simplejump.  */
 
   /* In case the edge redirection failed, try to force it to be non-fallthru
      and redirect newly created simplejump.  */

-  e->src->flags |= BB_DIRTY;
+  df_set_bb_dirty (e->src);

   return force_nonfallthru_and_redirect (e, target);
 }
 
   return force_nonfallthru_and_redirect (e, target);
 }
 


@@ -1220,7 +1229,7 @@ rtl_tidy_fallthru_edge (edge e)
 
   /* Selectively unlink the sequence.  */
   if (q != PREV_INSN (BB_HEAD (c)))
 
   /* Selectively unlink the sequence.  */
   if (q != PREV_INSN (BB_HEAD (c)))

-    delete_insn_chain (NEXT_INSN (q), PREV_INSN (BB_HEAD (c)));
+    delete_insn_chain (NEXT_INSN (q), PREV_INSN (BB_HEAD (c)), false);

 
   e->flags |= EDGE_FALLTHRU;
 }
 
   e->flags |= EDGE_FALLTHRU;
 }


@@ -1286,17 +1295,6 @@ rtl_split_edge (edge edge_in)
       BB_COPY_PARTITION (bb, edge_in->dest);
     }
 
       BB_COPY_PARTITION (bb, edge_in->dest);
     }
 

-  /* ??? This info is likely going to be out of date very soon.  */
-  if (edge_in->dest->il.rtl->global_live_at_start)
-    {
-      bb->il.rtl->global_live_at_start = ALLOC_REG_SET (&reg_obstack);
-      bb->il.rtl->global_live_at_end = ALLOC_REG_SET (&reg_obstack);
-      COPY_REG_SET (bb->il.rtl->global_live_at_start,
-                   edge_in->dest->il.rtl->global_live_at_start);
-      COPY_REG_SET (bb->il.rtl->global_live_at_end,
-                   edge_in->dest->il.rtl->global_live_at_start);
-    }
-

   make_single_succ_edge (bb, edge_in->dest, EDGE_FALLTHRU);
 
   /* For non-fallthru edges, we must adjust the predecessor's
   make_single_succ_edge (bb, edge_in->dest, EDGE_FALLTHRU);
 
   /* For non-fallthru edges, we must adjust the predecessor's


@@ -1411,8 +1409,7 @@ commit_one_edge_insertion (edge e)
              bb_note = NULL_RTX;
              for (cur_insn = BB_HEAD (bb); cur_insn != NEXT_INSN (BB_END (bb));
                   cur_insn = NEXT_INSN (cur_insn))
              bb_note = NULL_RTX;
              for (cur_insn = BB_HEAD (bb); cur_insn != NEXT_INSN (BB_END (bb));
                   cur_insn = NEXT_INSN (cur_insn))

-               if (NOTE_P (cur_insn)
-                   && NOTE_LINE_NUMBER (cur_insn) == NOTE_INSN_BASIC_BLOCK)
+               if (NOTE_INSN_BASIC_BLOCK_P (cur_insn))

                  {
                    bb_note = cur_insn;
                    break;
                  {
                    bb_note = cur_insn;
                    break;


@@ -1431,11 +1428,11 @@ commit_one_edge_insertion (edge e)
 
   if (before)
     {
 
   if (before)
     {

-      emit_insn_before_noloc (insns, before);
+      emit_insn_before_noloc (insns, before, bb);

       last = prev_nonnote_insn (before);
     }
   else
       last = prev_nonnote_insn (before);
     }
   else

-    last = emit_insn_after_noloc (insns, after);
+    last = emit_insn_after_noloc (insns, after, bb);

 
   if (returnjump_p (last))
     {
 
   if (returnjump_p (last))
     {


@@ -1513,6 +1510,7 @@ commit_edge_insertions (void)
   sbitmap_free (blocks);
 }
 \f
   sbitmap_free (blocks);
 }
 \f

+

 /* Print out RTL-specific basic block information (live information
    at start and end).  */
 
 /* Print out RTL-specific basic block information (live information
    at start and end).  */
 


@@ -1523,31 +1521,35 @@ rtl_dump_bb (basic_block bb, FILE *outf, int indent)
   rtx last;
   char *s_indent;
 
   rtx last;
   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';

-
-  fprintf (outf, ";;%s Registers live at start: ", s_indent);
-  dump_regset (bb->il.rtl->global_live_at_start, outf);
-  putc ('\n', outf);
+  
+  if (df)
+    {
+      df_dump_top (bb, outf);
+      putc ('\n', outf);
+    }

 
   for (insn = BB_HEAD (bb), last = NEXT_INSN (BB_END (bb)); insn != last;
        insn = NEXT_INSN (insn))
     print_rtl_single (outf, insn);
 
 
   for (insn = BB_HEAD (bb), last = NEXT_INSN (BB_END (bb)); insn != last;
        insn = NEXT_INSN (insn))
     print_rtl_single (outf, insn);
 

-  fprintf (outf, ";;%s Registers live at end: ", s_indent);
-  dump_regset (bb->il.rtl->global_live_at_end, outf);
-  putc ('\n', outf);
+  if (df)
+    {
+      df_dump_bottom (bb, outf);
+      putc ('\n', outf);
+    }
+

 }
 \f
 /* Like print_rtl, but also print out live information for the start of each
    basic block.  */
 
 void
 }
 \f
 /* Like print_rtl, but also print out live information for the start of each
    basic block.  */
 
 void

-print_rtl_with_bb (FILE *outf, rtx rtx_first)
+print_rtl_with_bb (FILE *outf, const_rtx rtx_first)

 {
 {

-  rtx tmp_rtx;
-
+  const_rtx tmp_rtx;

   if (rtx_first == 0)
     fprintf (outf, "(nil)\n");
   else
   if (rtx_first == 0)
     fprintf (outf, "(nil)\n");
   else


@@ -1560,6 +1562,9 @@ print_rtl_with_bb (FILE *outf, rtx rtx_first)
 
       basic_block bb;
 
 
       basic_block bb;
 

+      if (df)
+       df_dump_start (outf);
+

       FOR_EACH_BB_REVERSE (bb)
        {
          rtx x;
       FOR_EACH_BB_REVERSE (bb)
        {
          rtx x;


@@ -1582,15 +1587,21 @@ print_rtl_with_bb (FILE *outf, rtx rtx_first)
       for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
        {
          int did_output;
       for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
        {
          int did_output;

-         edge_iterator ei;
-         edge e;
-

          if ((bb = start[INSN_UID (tmp_rtx)]) != NULL)
            {
          if ((bb = start[INSN_UID (tmp_rtx)]) != NULL)
            {

-             fprintf (outf, ";; Start of basic block %d, registers live:",
-                      bb->index);
-             dump_regset (bb->il.rtl->global_live_at_start, outf);
-             putc ('\n', outf);
+             edge e;
+             edge_iterator ei;
+             
+             fprintf (outf, ";; Start of basic block (");
+             FOR_EACH_EDGE (e, ei, bb->preds)
+               fprintf (outf, " %d", e->src->index);
+             fprintf (outf, ") -> %d\n", bb->index);
+
+             if (df)
+               {
+                 df_dump_top (bb, outf);
+                 putc ('\n', outf);
+               }

              FOR_EACH_EDGE (e, ei, bb->preds)
                {
                  fputs (";; Pred edge ", outf);
              FOR_EACH_EDGE (e, ei, bb->preds)
                {
                  fputs (";; Pred edge ", outf);


@@ -1610,9 +1621,19 @@ print_rtl_with_bb (FILE *outf, rtx rtx_first)
 
          if ((bb = end[INSN_UID (tmp_rtx)]) != NULL)
            {
 
          if ((bb = end[INSN_UID (tmp_rtx)]) != NULL)
            {

-             fprintf (outf, ";; End of basic block %d, registers live:",
-                      bb->index);
-             dump_regset (bb->il.rtl->global_live_at_end, outf);
+             edge e;
+             edge_iterator ei;
+
+             fprintf (outf, ";; End of basic block %d -> (", bb->index);
+             FOR_EACH_EDGE (e, ei, bb->succs)
+               fprintf (outf, " %d", e->dest->index);
+             fprintf (outf, ")\n");
+
+             if (df)
+               {
+                 df_dump_bottom (bb, outf);
+                 putc ('\n', outf);
+               }

              putc ('\n', outf);
              FOR_EACH_EDGE (e, ei, bb->succs)
                {
              putc ('\n', outf);
              FOR_EACH_EDGE (e, ei, bb->succs)
                {


@@ -1621,7 +1642,6 @@ print_rtl_with_bb (FILE *outf, rtx rtx_first)
                  fputc ('\n', outf);
                }
            }
                  fputc ('\n', outf);
                }
            }

-

          if (did_output)
            putc ('\n', outf);
        }
          if (did_output)
            putc ('\n', outf);
        }


@@ -1631,10 +1651,10 @@ print_rtl_with_bb (FILE *outf, rtx rtx_first)
       free (in_bb_p);
     }
 
       free (in_bb_p);
     }
 

-  if (current_function_epilogue_delay_list != 0)
+  if (crtl->epilogue_delay_list != 0)

     {
       fprintf (outf, "\n;; Insns in epilogue delay list:\n\n");
     {
       fprintf (outf, "\n;; Insns in epilogue delay list:\n\n");

-      for (tmp_rtx = current_function_epilogue_delay_list; tmp_rtx != 0;
+      for (tmp_rtx = crtl->epilogue_delay_list; tmp_rtx != 0;

           tmp_rtx = XEXP (tmp_rtx, 1))
        print_rtl_single (outf, XEXP (tmp_rtx, 0));
     }
           tmp_rtx = XEXP (tmp_rtx, 1))
        print_rtl_single (outf, XEXP (tmp_rtx, 0));
     }


@@ -1680,13 +1700,14 @@ get_last_bb_insn (basic_block bb)
 
    Currently it does following checks:
 
 
    Currently it does following checks:
 

-   - test head/end pointers

    - overlapping of basic blocks
    - overlapping of basic blocks

+   - insns with wrong BLOCK_FOR_INSN pointers

    - headers of basic blocks (the NOTE_INSN_BASIC_BLOCK note)
    - tails of basic blocks (ensure that boundary is necessary)
    - scans body of the basic block for JUMP_INSN, CODE_LABEL
      and NOTE_INSN_BASIC_BLOCK
    - verify that no fall_thru edge crosses hot/cold partition boundaries
    - headers of basic blocks (the NOTE_INSN_BASIC_BLOCK note)
    - tails of basic blocks (ensure that boundary is necessary)
    - scans body of the basic block for JUMP_INSN, CODE_LABEL
      and NOTE_INSN_BASIC_BLOCK
    - verify that no fall_thru edge crosses hot/cold partition boundaries

+   - verify that there are no pending RTL branch predictions

 
    In future it can be extended check a lot of other stuff as well
    (reachability of basic blocks, life information, etc. etc.).  */
 
    In future it can be extended check a lot of other stuff as well
    (reachability of basic blocks, life information, etc. etc.).  */


@@ -1694,24 +1715,14 @@ get_last_bb_insn (basic_block bb)
 static int
 rtl_verify_flow_info_1 (void)
 {
 static int
 rtl_verify_flow_info_1 (void)
 {

-  const int max_uid = get_max_uid ();
-  rtx last_head = get_last_insn ();
-  basic_block *bb_info;

   rtx x;
   int err = 0;
   basic_block bb;
 
   rtx x;
   int err = 0;
   basic_block bb;
 

-  bb_info = XCNEWVEC (basic_block, max_uid);
-
+  /* Check the general integrity of the basic blocks.  */

   FOR_EACH_BB_REVERSE (bb)
     {
   FOR_EACH_BB_REVERSE (bb)
     {

-      rtx head = BB_HEAD (bb);
-      rtx end = BB_END (bb);
-
-      /* Verify the end of the basic block is in the INSN chain.  */
-      for (x = last_head; x != NULL_RTX; x = PREV_INSN (x))
-       if (x == end)
-         break;
+      rtx insn;

 
       if (!(bb->flags & BB_RTL))
        {
 
       if (!(bb->flags & BB_RTL))
        {


@@ -1719,40 +1730,32 @@ rtl_verify_flow_info_1 (void)
          err = 1;
        }
 
          err = 1;
        }
 

-      if (!x)
-       {
-         error ("end insn %d for block %d not found in the insn stream",
-                INSN_UID (end), bb->index);
-         err = 1;
-       }
-
-      /* Work backwards from the end to the head of the basic block
-        to verify the head is in the RTL chain.  */
-      for (; x != NULL_RTX; x = PREV_INSN (x))
-       {
-         /* While walking over the insn chain, verify insns appear
-            in only one basic block and initialize the BB_INFO array
-            used by other passes.  */
-         if (bb_info[INSN_UID (x)] != NULL)
-           {
-             error ("insn %d is in multiple basic blocks (%d and %d)",
-                    INSN_UID (x), bb->index, bb_info[INSN_UID (x)]->index);
-             err = 1;
-           }
-
-         bb_info[INSN_UID (x)] = bb;
-
-         if (x == head)
-           break;
-       }
-      if (!x)
-       {
-         error ("head insn %d for block %d not found in the insn stream",
-                INSN_UID (head), bb->index);
-         err = 1;
-       }
+      FOR_BB_INSNS (bb, insn)
+       if (BLOCK_FOR_INSN (insn) != bb)
+         {
+           error ("insn %d basic block pointer is %d, should be %d",
+                  INSN_UID (insn),
+                  BLOCK_FOR_INSN (insn) ? BLOCK_FOR_INSN (insn)->index : 0,
+                  bb->index);
+           err = 1;
+         }

 
 

-      last_head = x;
+      for (insn = bb->il.rtl->header; insn; insn = NEXT_INSN (insn))
+       if (!BARRIER_P (insn)
+           && BLOCK_FOR_INSN (insn) != NULL)
+         {
+           error ("insn %d in header of bb %d has non-NULL basic block",
+                  INSN_UID (insn), bb->index);
+           err = 1;
+         }
+      for (insn = bb->il.rtl->footer; insn; insn = NEXT_INSN (insn))
+       if (!BARRIER_P (insn)
+           && BLOCK_FOR_INSN (insn) != NULL)
+         {
+           error ("insn %d in footer of bb %d has non-NULL basic block",
+                  INSN_UID (insn), bb->index);
+           err = 1;
+         }

     }
 
   /* Now check the basic blocks (boundaries etc.) */
     }
 
   /* Now check the basic blocks (boundaries etc.) */


@@ -1920,7 +1923,6 @@ rtl_verify_flow_info_1 (void)
     }
 
   /* Clean up.  */
     }
 
   /* Clean up.  */

-  free (bb_info);

   return err;
 }
 
   return err;
 }
 


@@ -1929,31 +1931,84 @@ rtl_verify_flow_info_1 (void)
 
    Currently it does following checks:
    - all checks of rtl_verify_flow_info_1
 
    Currently it does following checks:
    - all checks of rtl_verify_flow_info_1

+   - test head/end pointers

    - check that all insns are in the basic blocks
      (except the switch handling code, barriers and notes)
    - check that all returns are followed by barriers
    - check that all fallthru edge points to the adjacent blocks.  */
    - check that all insns are in the basic blocks
      (except the switch handling code, barriers and notes)
    - check that all returns are followed by barriers
    - check that all fallthru edge points to the adjacent blocks.  */

+

 static int
 rtl_verify_flow_info (void)
 {
   basic_block bb;
   int err = rtl_verify_flow_info_1 ();
   rtx x;
 static int
 rtl_verify_flow_info (void)
 {
   basic_block bb;
   int err = rtl_verify_flow_info_1 ();
   rtx x;

+  rtx last_head = get_last_insn ();
+  basic_block *bb_info;

   int num_bb_notes;
   const rtx rtx_first = get_insns ();
   basic_block last_bb_seen = ENTRY_BLOCK_PTR, curr_bb = NULL;
   int num_bb_notes;
   const rtx rtx_first = get_insns ();
   basic_block last_bb_seen = ENTRY_BLOCK_PTR, curr_bb = NULL;

+  const int max_uid = get_max_uid ();
+
+  bb_info = XCNEWVEC (basic_block, max_uid);

 
   FOR_EACH_BB_REVERSE (bb)
     {
       edge e;
       edge_iterator ei;
 
   FOR_EACH_BB_REVERSE (bb)
     {
       edge e;
       edge_iterator ei;

+      rtx head = BB_HEAD (bb);
+      rtx end = BB_END (bb);
+
+      for (x = last_head; x != NULL_RTX; x = PREV_INSN (x))
+       {
+         /* Verify the end of the basic block is in the INSN chain.  */
+         if (x == end)
+           break;
+
+         /* And that the code outside of basic blocks has NULL bb field.  */
+       if (!BARRIER_P (x)
+           && BLOCK_FOR_INSN (x) != NULL)
+         {
+           error ("insn %d outside of basic blocks has non-NULL bb field",
+                  INSN_UID (x));
+           err = 1;
+         }
+       }
+
+      if (!x)
+       {
+         error ("end insn %d for block %d not found in the insn stream",
+                INSN_UID (end), bb->index);
+         err = 1;
+       }
+
+      /* Work backwards from the end to the head of the basic block
+        to verify the head is in the RTL chain.  */
+      for (; x != NULL_RTX; x = PREV_INSN (x))
+       {
+         /* While walking over the insn chain, verify insns appear
+            in only one basic block.  */
+         if (bb_info[INSN_UID (x)] != NULL)
+           {
+             error ("insn %d is in multiple basic blocks (%d and %d)",
+                    INSN_UID (x), bb->index, bb_info[INSN_UID (x)]->index);
+             err = 1;
+           }

 
 

-      if (bb->predictions)
+         bb_info[INSN_UID (x)] = bb;
+
+         if (x == head)
+           break;
+       }
+      if (!x)

        {
        {

-         error ("bb prediction set for block %i, but it is not used in RTL land", bb->index);
+         error ("head insn %d for block %d not found in the insn stream",
+                INSN_UID (head), bb->index);

          err = 1;
        }
 
          err = 1;
        }
 

+      last_head = PREV_INSN (x);
+

       FOR_EACH_EDGE (e, ei, bb->succs)
        if (e->flags & EDGE_FALLTHRU)
          break;
       FOR_EACH_EDGE (e, ei, bb->succs)
        if (e->flags & EDGE_FALLTHRU)
          break;


@@ -1965,8 +2020,7 @@ rtl_verify_flow_info (void)
          for (insn = BB_END (bb); !insn || !BARRIER_P (insn);
               insn = NEXT_INSN (insn))
            if (!insn
          for (insn = BB_END (bb); !insn || !BARRIER_P (insn);
               insn = NEXT_INSN (insn))
            if (!insn

-               || (NOTE_P (insn)
-                   && NOTE_LINE_NUMBER (insn) == NOTE_INSN_BASIC_BLOCK))
+               || NOTE_INSN_BASIC_BLOCK_P (insn))

                {
                  error ("missing barrier after block %i", bb->index);
                  err = 1;
                {
                  error ("missing barrier after block %i", bb->index);
                  err = 1;


@@ -1998,6 +2052,20 @@ rtl_verify_flow_info (void)
        }
     }
 
        }
     }
 

+  for (x = last_head; x != NULL_RTX; x = PREV_INSN (x))
+    {
+      /* Check that the code before the first basic block has NULL
+        bb field.  */
+      if (!BARRIER_P (x)
+         && BLOCK_FOR_INSN (x) != NULL)
+       {
+         error ("insn %d outside of basic blocks has non-NULL bb field",
+                INSN_UID (x));
+         err = 1;
+       }
+    }
+  free (bb_info);
+

   num_bb_notes = 0;
   last_bb_seen = ENTRY_BLOCK_PTR;
 
   num_bb_notes = 0;
   last_bb_seen = ENTRY_BLOCK_PTR;
 


@@ -2040,7 +2108,7 @@ rtl_verify_flow_info (void)
 
       if (JUMP_P (x)
          && returnjump_p (x) && ! condjump_p (x)
 
       if (JUMP_P (x)
          && returnjump_p (x) && ! condjump_p (x)

-         && ! (NEXT_INSN (x) && BARRIER_P (NEXT_INSN (x))))
+         && ! (next_nonnote_insn (x) && BARRIER_P (next_nonnote_insn (x))))

            fatal_insn ("return not followed by barrier", x);
       if (curr_bb && x == BB_END (curr_bb))
        curr_bb = NULL;
            fatal_insn ("return not followed by barrier", x);
       if (curr_bb && x == BB_END (curr_bb))
        curr_bb = NULL;


@@ -2113,7 +2181,7 @@ purge_dead_edges (basic_block bb)
        }
 
       remove_edge (e);
        }
 
       remove_edge (e);

-      bb->flags |= BB_DIRTY;
+      df_set_bb_dirty (bb);

       purged = true;
     }
 
       purged = true;
     }
 


@@ -2181,7 +2249,7 @@ purge_dead_edges (basic_block bb)
            }
 
          /* We do not need this edge.  */
            }
 
          /* We do not need this edge.  */

-         bb->flags |= BB_DIRTY;
+         df_set_bb_dirty (bb);

          purged = true;
          remove_edge (e);
        }
          purged = true;
          remove_edge (e);
        }


@@ -2253,7 +2321,7 @@ purge_dead_edges (basic_block bb)
     {
       if (!(e->flags & (EDGE_FALLTHRU | EDGE_FAKE)))
        {
     {
       if (!(e->flags & (EDGE_FALLTHRU | EDGE_FAKE)))
        {

-         bb->flags |= BB_DIRTY;
+         df_set_bb_dirty (bb);

          remove_edge (e);
          purged = true;
        }
          remove_edge (e);
          purged = true;
        }


@@ -2296,7 +2364,7 @@ purge_all_dead_edges (void)
 static basic_block
 cfg_layout_split_block (basic_block bb, void *insnp)
 {
 static basic_block
 cfg_layout_split_block (basic_block bb, void *insnp)
 {

-  rtx insn = insnp;
+  rtx insn = (rtx) insnp;

   basic_block new_bb = rtl_split_block (bb, insn);
 
   new_bb->il.rtl->footer = bb->il.rtl->footer;
   basic_block new_bb = rtl_split_block (bb, insn);
 
   new_bb->il.rtl->footer = bb->il.rtl->footer;


@@ -2305,7 +2373,6 @@ cfg_layout_split_block (basic_block bb, void *insnp)
   return new_bb;
 }
 
   return new_bb;
 }
 

-

 /* Redirect Edge to DEST.  */
 static edge
 cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
 /* Redirect Edge to DEST.  */
 static edge
 cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)


@@ -2322,7 +2389,7 @@ cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
   if (e->src != ENTRY_BLOCK_PTR
       && (ret = try_redirect_by_replacing_jump (e, dest, true)))
     {
   if (e->src != ENTRY_BLOCK_PTR
       && (ret = try_redirect_by_replacing_jump (e, dest, true)))
     {

-      src->flags |= BB_DIRTY;
+      df_set_bb_dirty (src);

       return ret;
     }
 
       return ret;
     }
 


@@ -2333,7 +2400,7 @@ cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
        fprintf (dump_file, "Redirecting entry edge from bb %i to %i\n",
                 e->src->index, dest->index);
 
        fprintf (dump_file, "Redirecting entry edge from bb %i to %i\n",
                 e->src->index, dest->index);
 

-      e->src->flags |= BB_DIRTY;
+      df_set_bb_dirty (e->src);

       redirect_edge_succ (e, dest);
       return e;
     }
       redirect_edge_succ (e, dest);
       return e;
     }


@@ -2359,7 +2426,7 @@ cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
          redirected = redirect_branch_edge (e, dest);
          gcc_assert (redirected);
          e->flags |= EDGE_FALLTHRU;
          redirected = redirect_branch_edge (e, dest);
          gcc_assert (redirected);
          e->flags |= EDGE_FALLTHRU;

-         e->src->flags |= BB_DIRTY;
+         df_set_bb_dirty (e->src);

          return e;
        }
       /* In case we are redirecting fallthru edge to the branch edge
          return e;
        }
       /* In case we are redirecting fallthru edge to the branch edge


@@ -2385,7 +2452,7 @@ cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
   /* We don't want simplejumps in the insn stream during cfglayout.  */
   gcc_assert (!simplejump_p (BB_END (src)));
 
   /* We don't want simplejumps in the insn stream during cfglayout.  */
   gcc_assert (!simplejump_p (BB_END (src)));
 

-  src->flags |= BB_DIRTY;
+  df_set_bb_dirty (src);

   return ret;
 }
 
   return ret;
 }
 


@@ -2483,6 +2550,7 @@ cfg_layout_delete_block (basic_block bb)
 }
 
 /* Return true when blocks A and B can be safely merged.  */
 }
 
 /* Return true when blocks A and B can be safely merged.  */

+

 static bool
 cfg_layout_can_merge_blocks_p (basic_block a, basic_block b)
 {
 static bool
 cfg_layout_can_merge_blocks_p (basic_block a, basic_block b)
 {


@@ -2507,10 +2575,11 @@ cfg_layout_can_merge_blocks_p (basic_block a, basic_block b)
          /* Must be simple edge.  */
          && !(single_succ_edge (a)->flags & EDGE_COMPLEX)
          && a != ENTRY_BLOCK_PTR && b != EXIT_BLOCK_PTR
          /* Must be simple edge.  */
          && !(single_succ_edge (a)->flags & EDGE_COMPLEX)
          && a != ENTRY_BLOCK_PTR && b != EXIT_BLOCK_PTR

-         /* If the jump insn has side effects,
-            we can't kill the edge.  */
+         /* If the jump insn has side effects, we can't kill the edge.
+            When not optimizing, try_redirect_by_replacing_jump will
+            not allow us to redirect an edge by replacing a table jump.  */

          && (!JUMP_P (BB_END (a))
          && (!JUMP_P (BB_END (a))

-             || (reload_completed
+             || ((!optimize || reload_completed)

                  ? simplejump_p (BB_END (a)) : onlyjump_p (BB_END (a)))));
 }
 
                  ? simplejump_p (BB_END (a)) : onlyjump_p (BB_END (a)))));
 }
 


@@ -2523,6 +2592,9 @@ cfg_layout_merge_blocks (basic_block a, basic_block b)
   gcc_assert (cfg_layout_can_merge_blocks_p (a, b));
 #endif
 
   gcc_assert (cfg_layout_can_merge_blocks_p (a, b));
 #endif
 

+  if (dump_file)
+    fprintf (dump_file, "merging block %d into block %d\n", b->index, a->index);
+

   /* If there was a CODE_LABEL beginning B, delete it.  */
   if (LABEL_P (BB_HEAD (b)))
     {
   /* If there was a CODE_LABEL beginning B, delete it.  */
   if (LABEL_P (BB_HEAD (b)))
     {


@@ -2544,8 +2616,8 @@ cfg_layout_merge_blocks (basic_block a, basic_block b)
     {
       rtx first = BB_END (a), last;
 
     {
       rtx first = BB_END (a), last;
 

-      last = emit_insn_after_noloc (b->il.rtl->header, BB_END (a));
-      delete_insn_chain (NEXT_INSN (first), last);
+      last = emit_insn_after_noloc (b->il.rtl->header, BB_END (a), a);
+      delete_insn_chain (NEXT_INSN (first), last, false);

       b->il.rtl->header = NULL;
     }
 
       b->il.rtl->header = NULL;
     }
 


@@ -2554,12 +2626,19 @@ cfg_layout_merge_blocks (basic_block a, basic_block b)
     {
       rtx first = unlink_insn_chain (BB_HEAD (b), BB_END (b));
 
     {
       rtx first = unlink_insn_chain (BB_HEAD (b), BB_END (b));
 

-      emit_insn_after_noloc (first, BB_END (a));
+      emit_insn_after_noloc (first, BB_END (a), a);

       /* Skip possible DELETED_LABEL insn.  */
       if (!NOTE_INSN_BASIC_BLOCK_P (first))
        first = NEXT_INSN (first);
       gcc_assert (NOTE_INSN_BASIC_BLOCK_P (first));
       BB_HEAD (b) = NULL;
       /* Skip possible DELETED_LABEL insn.  */
       if (!NOTE_INSN_BASIC_BLOCK_P (first))
        first = NEXT_INSN (first);
       gcc_assert (NOTE_INSN_BASIC_BLOCK_P (first));
       BB_HEAD (b) = NULL;

+
+      /* emit_insn_after_noloc doesn't call df_insn_change_bb.
+         We need to explicitly call. */
+      update_bb_for_insn_chain (NEXT_INSN (first),
+                               BB_END (b),
+                               a);
+

       delete_insn (first);
     }
   /* Otherwise just re-associate the instructions.  */
       delete_insn (first);
     }
   /* Otherwise just re-associate the instructions.  */


@@ -2567,10 +2646,8 @@ cfg_layout_merge_blocks (basic_block a, basic_block b)
     {
       rtx insn;
 
     {
       rtx insn;
 

-      for (insn = BB_HEAD (b);
-          insn != NEXT_INSN (BB_END (b));
-          insn = NEXT_INSN (insn))
-       set_block_for_insn (insn, a);
+      update_bb_for_insn_chain (BB_HEAD (b), BB_END (b), a);
+

       insn = BB_HEAD (b);
       /* Skip possible DELETED_LABEL insn.  */
       if (!NOTE_INSN_BASIC_BLOCK_P (insn))
       insn = BB_HEAD (b);
       /* Skip possible DELETED_LABEL insn.  */
       if (!NOTE_INSN_BASIC_BLOCK_P (insn))


@@ -2581,6 +2658,8 @@ cfg_layout_merge_blocks (basic_block a, basic_block b)
       delete_insn (insn);
     }
 
       delete_insn (insn);
     }
 

+  df_bb_delete (b->index);
+

   /* Possible tablejumps and barriers should appear after the block.  */
   if (b->il.rtl->footer)
     {
   /* Possible tablejumps and barriers should appear after the block.  */
   if (b->il.rtl->footer)
     {


@@ -2597,7 +2676,6 @@ cfg_layout_merge_blocks (basic_block a, basic_block b)
        }
       b->il.rtl->footer = NULL;
     }
        }
       b->il.rtl->footer = NULL;
     }

-  a->il.rtl->global_live_at_end = b->il.rtl->global_live_at_end;

 
   if (dump_file)
     fprintf (dump_file, "Merged blocks %d and %d.\n",
 
   if (dump_file)
     fprintf (dump_file, "Merged blocks %d and %d.\n",


@@ -2614,18 +2692,10 @@ cfg_layout_split_edge (edge e)
                        ? NEXT_INSN (BB_END (e->src)) : get_insns (),
                        NULL_RTX, e->src);
 
                        ? NEXT_INSN (BB_END (e->src)) : get_insns (),
                        NULL_RTX, e->src);
 

-  /* ??? This info is likely going to be out of date very soon, but we must
-     create it to avoid getting an ICE later.  */
-  if (e->dest->il.rtl->global_live_at_start)
-    {
-      new_bb->il.rtl->global_live_at_start = ALLOC_REG_SET (&reg_obstack);
-      new_bb->il.rtl->global_live_at_end = ALLOC_REG_SET (&reg_obstack);
-      COPY_REG_SET (new_bb->il.rtl->global_live_at_start,
-                   e->dest->il.rtl->global_live_at_start);
-      COPY_REG_SET (new_bb->il.rtl->global_live_at_end,
-                   e->dest->il.rtl->global_live_at_start);
-    }
-
+  if (e->dest == EXIT_BLOCK_PTR)
+    BB_COPY_PARTITION (new_bb, e->src);
+  else
+    BB_COPY_PARTITION (new_bb, e->dest);

   make_edge (new_bb, e->dest, EDGE_FALLTHRU);
   redirect_edge_and_branch_force (e, new_bb);
 
   make_edge (new_bb, e->dest, EDGE_FALLTHRU);
   redirect_edge_and_branch_force (e, new_bb);
 


@@ -2649,7 +2719,8 @@ rtl_block_ends_with_call_p (basic_block bb)
 
   while (!CALL_P (insn)
         && insn != BB_HEAD (bb)
 
   while (!CALL_P (insn)
         && insn != BB_HEAD (bb)

-        && keep_with_call_p (insn))
+        && (keep_with_call_p (insn)
+            || NOTE_P (insn)))

     insn = PREV_INSN (insn);
   return (CALL_P (insn));
 }
     insn = PREV_INSN (insn);
   return (CALL_P (insn));
 }


@@ -2657,7 +2728,7 @@ rtl_block_ends_with_call_p (basic_block bb)
 /* Return 1 if BB ends with a conditional branch, 0 otherwise.  */
 
 static bool
 /* Return 1 if BB ends with a conditional branch, 0 otherwise.  */
 
 static bool

-rtl_block_ends_with_condjump_p (basic_block bb)
+rtl_block_ends_with_condjump_p (const_basic_block bb)

 {
   return any_condjump_p (BB_END (bb));
 }
 {
   return any_condjump_p (BB_END (bb));
 }


@@ -2666,7 +2737,7 @@ rtl_block_ends_with_condjump_p (basic_block bb)
    Helper function for rtl_flow_call_edges_add.  */
 
 static bool
    Helper function for rtl_flow_call_edges_add.  */
 
 static bool

-need_fake_edge_p (rtx insn)
+need_fake_edge_p (const_rtx insn)

 {
   if (!INSN_P (insn))
     return false;
 {
   if (!INSN_P (insn))
     return false;


@@ -2674,7 +2745,7 @@ need_fake_edge_p (rtx insn)
   if ((CALL_P (insn)
        && !SIBLING_CALL_P (insn)
        && !find_reg_note (insn, REG_NORETURN, NULL)
   if ((CALL_P (insn)
        && !SIBLING_CALL_P (insn)
        && !find_reg_note (insn, REG_NORETURN, NULL)

-       && !CONST_OR_PURE_CALL_P (insn)))
+       && !(RTL_CONST_OR_PURE_CALL_P (insn))))

     return true;
 
   return ((GET_CODE (PATTERN (insn)) == ASM_OPERANDS
     return true;
 
   return ((GET_CODE (PATTERN (insn)) == ASM_OPERANDS


@@ -2874,7 +2945,7 @@ void
 init_rtl_bb_info (basic_block bb)
 {
   gcc_assert (!bb->il.rtl);
 init_rtl_bb_info (basic_block bb)
 {
   gcc_assert (!bb->il.rtl);

-  bb->il.rtl = ggc_alloc_cleared (sizeof (struct rtl_bb_info));
+  bb->il.rtl = GGC_CNEW (struct rtl_bb_info);

 }
 
 
 }
 
 


@@ -2926,7 +2997,7 @@ insert_insn_end_bb_new (rtx pat, basic_block bb)
 #endif
       /* FIXME: What if something in cc0/jump uses value set in new
          insn?  */
 #endif
       /* FIXME: What if something in cc0/jump uses value set in new
          insn?  */

-      new_insn = emit_insn_before_noloc (pat, insn);
+      new_insn = emit_insn_before_noloc (pat, insn, bb);

     }
 
   /* Likewise if the last insn is a call, as will happen in the presence
     }
 
   /* Likewise if the last insn is a call, as will happen in the presence


@@ -2957,14 +3028,46 @@ insert_insn_end_bb_new (rtx pat, basic_block bb)
              || NOTE_INSN_BASIC_BLOCK_P (insn))
         insn = NEXT_INSN (insn);
 
              || NOTE_INSN_BASIC_BLOCK_P (insn))
         insn = NEXT_INSN (insn);
 

-      new_insn = emit_insn_before_noloc (pat, insn);
+      new_insn = emit_insn_before_noloc (pat, insn, bb);

     }
   else
     }
   else

-    new_insn = emit_insn_after_noloc (pat, insn);
+    new_insn = emit_insn_after_noloc (pat, insn, bb);

 
   return new_insn;
 }
 
 
   return new_insn;
 }
 

+/* Returns true if it is possible to remove edge E by redirecting
+   it to the destination of the other edge from E->src.  */
+
+static bool
+rtl_can_remove_branch_p (const_edge e)
+{
+  const_basic_block src = e->src;
+  const_basic_block target = EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)->dest;
+  const_rtx insn = BB_END (src), set;
+
+  /* The conditions are taken from try_redirect_by_replacing_jump.  */
+  if (target == EXIT_BLOCK_PTR)
+    return false;
+
+  if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
+    return false;
+
+  if (find_reg_note (insn, REG_CROSSING_JUMP, NULL_RTX)
+      || BB_PARTITION (src) != BB_PARTITION (target))
+    return false;
+
+  if (!onlyjump_p (insn)
+      || tablejump_p (insn, NULL, NULL))
+    return false;
+
+  set = single_set (insn);
+  if (!set || side_effects_p (set))
+    return false;
+
+  return true;
+}
+

 /* Implementation of CFG manipulation for linearized RTL.  */
 struct cfg_hooks rtl_cfg_hooks = {
   "rtl",
 /* Implementation of CFG manipulation for linearized RTL.  */
 struct cfg_hooks rtl_cfg_hooks = {
   "rtl",


@@ -2973,6 +3076,7 @@ struct cfg_hooks rtl_cfg_hooks = {
   rtl_create_basic_block,
   rtl_redirect_edge_and_branch,
   rtl_redirect_edge_and_branch_force,
   rtl_create_basic_block,
   rtl_redirect_edge_and_branch,
   rtl_redirect_edge_and_branch_force,

+  rtl_can_remove_branch_p,

   rtl_delete_block,
   rtl_split_block,
   rtl_move_block_after,
   rtl_delete_block,
   rtl_split_block,
   rtl_move_block_after,


@@ -3005,8 +3109,8 @@ struct cfg_hooks rtl_cfg_hooks = {
 /* We do not want to declare these functions in a header file, since they
    should only be used through the cfghooks interface, and we do not want to
    move them here since it would require also moving quite a lot of related
 /* We do not want to declare these functions in a header file, since they
    should only be used through the cfghooks interface, and we do not want to
    move them here since it would require also moving quite a lot of related

-   code.  */
-extern bool cfg_layout_can_duplicate_bb_p (basic_block);
+   code.  They are in cfglayout.c.  */
+extern bool cfg_layout_can_duplicate_bb_p (const_basic_block);

 extern basic_block cfg_layout_duplicate_bb (basic_block);
 
 struct cfg_hooks cfg_layout_rtl_cfg_hooks = {
 extern basic_block cfg_layout_duplicate_bb (basic_block);
 
 struct cfg_hooks cfg_layout_rtl_cfg_hooks = {


@@ -3016,6 +3120,7 @@ struct cfg_hooks cfg_layout_rtl_cfg_hooks = {
   cfg_layout_create_basic_block,
   cfg_layout_redirect_edge_and_branch,
   cfg_layout_redirect_edge_and_branch_force,
   cfg_layout_create_basic_block,
   cfg_layout_redirect_edge_and_branch,
   cfg_layout_redirect_edge_and_branch_force,

+  rtl_can_remove_branch_p,

   cfg_layout_delete_block,
   cfg_layout_split_block,
   rtl_move_block_after,
   cfg_layout_delete_block,
   cfg_layout_split_block,
   rtl_move_block_after,