2005-12-11 Andrew Pinski <pinskia@physics.uc.edu>

[pf3gnuchains/gcc-fork.git] / gcc / sched-ebb.c

diff --git a/gcc/sched-ebb.c b/gcc/sched-ebb.c
index 2d4f125..58f5d33 100644 (file)
--- a/gcc/sched-ebb.c
+++ b/gcc/sched-ebb.c
@@ -1,6 +1,6 @@
 /* Instruction scheduling pass.
    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
    Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
    and currently maintained by, Jim Wilson (wilson@cygnus.com)
 
@@ -18,8 +18,8 @@ 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.  */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
 \f
 #include "config.h"
 #include "system.h"
@@ -29,7 +29,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "rtl.h"
 #include "tm_p.h"
 #include "hard-reg-set.h"
-#include "basic-block.h"
 #include "regs.h"
 #include "function.h"
 #include "flags.h"
@@ -175,18 +174,18 @@ compute_jump_reg_dependencies (rtx insn, regset cond_set, regset used,
 {
   basic_block b = BLOCK_FOR_INSN (insn);
   edge e;
-  for (e = b->succ; e; e = e->succ_next)
+  edge_iterator ei;
+
+  FOR_EACH_EDGE (e, ei, b->succs)
     if (e->flags & EDGE_FALLTHRU)
       /* The jump may be a by-product of a branch that has been merged
         in the main codepath after being conditionalized.  Therefore
         it may guard the fallthrough block from using a value that has
         conditionally overwritten that of the main codepath.  So we
         consider that it restores the value of the main codepath.  */
-      bitmap_operation (set, e->dest->global_live_at_start, cond_set,
-                       BITMAP_AND);
+      bitmap_and (set, e->dest->il.rtl->global_live_at_start, cond_set);
     else
-      bitmap_operation (used, used, e->dest->global_live_at_start,
-                       BITMAP_IOR);
+      bitmap_ior_into (used, e->dest->il.rtl->global_live_at_start);
 }
 
 /* Used in schedule_insns to initialize current_sched_info for scheduling
@@ -240,8 +239,7 @@ fix_basic_block_boundaries (basic_block bb, basic_block last, rtx head,
 
   for (; insn != aftertail; insn = NEXT_INSN (insn))
     {
-      if (GET_CODE (insn) == CODE_LABEL)
-       abort ();
+      gcc_assert (!LABEL_P (insn));
       /* Create new basic blocks just before first insn.  */
       if (inside_basic_block_p (insn))
        {
@@ -250,7 +248,7 @@ fix_basic_block_boundaries (basic_block bb, basic_block last, rtx head,
              rtx note;
 
              /* Re-emit the basic block note for newly found BB header.  */
-             if (GET_CODE (insn) == CODE_LABEL)
+             if (LABEL_P (insn))
                {
                  note = emit_note_after (NOTE_INSN_BASIC_BLOCK, insn);
                  head = insn;
@@ -281,6 +279,7 @@ fix_basic_block_boundaries (basic_block bb, basic_block last, rtx head,
            {
              edge f;
              rtx h;
+             edge_iterator ei;
 
              /* An obscure special case, where we do have partially dead
                 instruction scheduled after last control flow instruction.
@@ -292,9 +291,10 @@ fix_basic_block_boundaries (basic_block bb, basic_block last, rtx head,
                 A safer solution can be to bring the code into sequence,
                 do the split and re-emit it back in case this will ever
                 trigger problem.  */
-             f = bb->prev_bb->succ;
-             while (f && !(f->flags & EDGE_FALLTHRU))
-               f = f->succ_next;
+
+             FOR_EACH_EDGE (f, ei, bb->prev_bb->succs)
+               if (f->flags & EDGE_FALLTHRU)
+                 break;
 
              if (f)
                {
@@ -314,7 +314,7 @@ fix_basic_block_boundaries (basic_block bb, basic_block last, rtx head,
                  delete_insn_chain (head, insn);
                  /* We keep some notes in the way that may split barrier from the
                     jump.  */
-                 if (GET_CODE (next) == BARRIER)
+                 if (BARRIER_P (next))
                     {
                       emit_barrier_after (prev_nonnote_insn (head));
                       delete_insn (next);
@@ -328,7 +328,7 @@ fix_basic_block_boundaries (basic_block bb, basic_block last, rtx head,
              BB_END (curr_bb) = insn;
              add_missing_bbs (BB_HEAD (curr_bb), bb, curr_bb->prev_bb);
            }
-         note = GET_CODE (head) == CODE_LABEL ? NEXT_INSN (head) : head;
+         note = LABEL_P (head) ? NEXT_INSN (head) : head;
          NOTE_BASIC_BLOCK (note) = curr_bb;
          update_bb_for_insn (curr_bb);
          bb = curr_bb->next_bb;
@@ -420,7 +420,7 @@ add_deps_for_risky_insns (rtx head, rtx tail)
   basic_block last_block = NULL, bb;
 
   for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
-    if (GET_CODE (insn) == JUMP_INSN)
+    if (JUMP_P (insn))
       {
        bb = BLOCK_FOR_INSN (insn);
        bb->aux = last_block;
@@ -445,7 +445,7 @@ add_deps_for_risky_insns (rtx head, rtx tail)
                    prev = BB_END (bb);
                  }
              }
-           /* FALLTHRU */
+           /* Fall through.  */
          case TRAP_RISKY:
          case IRISKY:
          case PRISKY_CANDIDATE:
@@ -454,7 +454,8 @@ add_deps_for_risky_insns (rtx head, rtx tail)
            /* We can not change the mode of the backward
               dependency because REG_DEP_ANTI has the lowest
               rank.  */
-           if (add_dependence (insn, prev, REG_DEP_ANTI))
+           if (! sched_insns_conditions_mutex_p (insn, prev)
+               && add_dependence (insn, prev, REG_DEP_ANTI))
              add_forward_dependence (prev, insn, REG_DEP_ANTI);
             break;
 
@@ -525,11 +526,7 @@ schedule_ebb (rtx head, rtx tail)
 
       for (note = REG_NOTES (head); note; note = XEXP (note, 1))
        if (REG_NOTE_KIND (note) == REG_SAVE_NOTE)
-         {
-           remove_note (head, note);
-           note = XEXP (note, 1);
-           remove_note (head, note);
-         }
+         remove_note (head, note);
     }
 
   /* Remove remaining note insns from the block, save them in
@@ -542,8 +539,7 @@ schedule_ebb (rtx head, rtx tail)
   schedule_block (-1, n_insns);
 
   /* Sanity check: verify that all region insns were scheduled.  */
-  if (sched_n_insns != n_insns)
-    abort ();
+  gcc_assert (sched_n_insns == n_insns);
   head = current_sched_info->head;
   tail = current_sched_info->tail;
 
@@ -579,7 +575,6 @@ schedule_ebbs (FILE *dump_file)
 
   current_sched_info = &ebb_sched_info;
 
-  allocate_reg_life_data ();
   compute_bb_for_insn ();
 
   /* Schedule every region in the subroutine.  */
@@ -591,11 +586,12 @@ schedule_ebbs (FILE *dump_file)
       for (;;)
        {
          edge e;
+         edge_iterator ei;
          tail = BB_END (bb);
          if (bb->next_bb == EXIT_BLOCK_PTR
-             || GET_CODE (BB_HEAD (bb->next_bb)) == CODE_LABEL)
+             || LABEL_P (BB_HEAD (bb->next_bb)))
            break;
-         for (e = bb->succ; e; e = e->succ_next)
+         FOR_EACH_EDGE (e, ei, bb->succs)
            if ((e->flags & EDGE_FALLTHRU) != 0)
              break;
          if (! e)
@@ -609,11 +605,11 @@ schedule_ebbs (FILE *dump_file)
         a note or two.  */
       while (head != tail)
        {
-         if (GET_CODE (head) == NOTE)
+         if (NOTE_P (head))
            head = NEXT_INSN (head);
-         else if (GET_CODE (tail) == NOTE)
+         else if (NOTE_P (tail))
            tail = PREV_INSN (tail);
-         else if (GET_CODE (head) == CODE_LABEL)
+         else if (LABEL_P (head))
            head = NEXT_INSN (head);
          else
            break;