2004-09-17 Jeffrey D. Oldham <oldham@codesourcery.com>

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

diff --git a/gcc/lcm.c b/gcc/lcm.c
index 68b49ef..3432332 100644 (file)
--- a/gcc/lcm.c
+++ b/gcc/lcm.c
@@ -1,5 +1,5 @@
 /* Generic partial redundancy elimination with lazy code motion support.
-   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
+   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004
    Free Software Foundation, Inc.
 
 This file is part of GCC.
@@ -290,10 +290,11 @@ compute_laterin (struct edge_list *edge_list, sbitmap *earliest,
       *qin++ = bb;
       bb->aux = bb;
     }
-  qin = worklist;
+
   /* Note that we do not use the last allocated element for our queue,
      as EXIT_BLOCK is never inserted into it. In fact the above allocation
      of n_basic_blocks + 1 elements is not necessary.  */
+  qin = worklist;
   qend = &worklist[n_basic_blocks];
   qlen = n_basic_blocks;
 
@@ -310,7 +311,8 @@ compute_laterin (struct edge_list *edge_list, sbitmap *earliest,
       /* Compute the intersection of LATERIN for each incoming edge to B.  */
       sbitmap_ones (laterin[bb->index]);
       for (e = bb->pred; e != NULL; e = e->pred_next)
-       sbitmap_a_and_b (laterin[bb->index], laterin[bb->index], later[(size_t)e->aux]);
+       sbitmap_a_and_b (laterin[bb->index], laterin[bb->index],
+                        later[(size_t)e->aux]);
 
       /* Calculate LATER for all outgoing edges.  */
       for (e = bb->succ; e != NULL; e = e->succ_next)
@@ -354,7 +356,8 @@ compute_insert_delete (struct edge_list *edge_list, sbitmap *antloc,
   basic_block bb;
 
   FOR_EACH_BB (bb)
-    sbitmap_difference (delete[bb->index], antloc[bb->index], laterin[bb->index]);
+    sbitmap_difference (delete[bb->index], antloc[bb->index],
+                       laterin[bb->index]);
 
   for (x = 0; x < NUM_EDGES (edge_list); x++)
     {
@@ -526,7 +529,8 @@ compute_available (sbitmap *avloc, sbitmap *kill, sbitmap *avout,
          sbitmap_intersection_of_preds (avin[bb->index], avout, bb->index);
        }
 
-      if (sbitmap_union_of_diff_cg (avout[bb->index], avloc[bb->index], avin[bb->index], kill[bb->index]))
+      if (sbitmap_union_of_diff_cg (avout[bb->index], avloc[bb->index],
+                                   avin[bb->index], kill[bb->index]))
        /* If the out state of this block changed, then we need
           to add the successors of this block to the worklist
           if they are not already on the worklist.  */
@@ -683,7 +687,8 @@ compute_rev_insert_delete (struct edge_list *edge_list, sbitmap *st_avloc,
   basic_block bb;
 
   FOR_EACH_BB (bb)
-    sbitmap_difference (delete[bb->index], st_avloc[bb->index], nearerout[bb->index]);
+    sbitmap_difference (delete[bb->index], st_avloc[bb->index],
+                       nearerout[bb->index]);
 
   for (x = 0; x < NUM_EDGES (edge_list); x++)
     {
@@ -927,12 +932,12 @@ reg_dies (rtx reg, HARD_REG_SET live)
 {
   int regno, nregs;
 
-  if (GET_CODE (reg) != REG)
+  if (!REG_P (reg))
     return;
 
   regno = REGNO (reg);
   if (regno < FIRST_PSEUDO_REGISTER)
-    for (nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1; nregs >= 0;
+    for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
         nregs--)
       CLEAR_HARD_REG_BIT (live, regno + nregs);
 }
@@ -948,12 +953,12 @@ reg_becomes_live (rtx reg, rtx setter ATTRIBUTE_UNUSED, void *live)
   if (GET_CODE (reg) == SUBREG)
     reg = SUBREG_REG (reg);
 
-  if (GET_CODE (reg) != REG)
+  if (!REG_P (reg))
     return;
 
   regno = REGNO (reg);
   if (regno < FIRST_PSEUDO_REGISTER)
-    for (nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1; nregs >= 0;
+    for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
         nregs--)
       SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs);
 }
@@ -1058,8 +1063,8 @@ optimize_mode_switching (FILE *file)
 
          REG_SET_TO_HARD_REG_SET (live_now,
                                   bb->global_live_at_start);
-         for (insn = bb->head;
-              insn != NULL && insn != NEXT_INSN (bb->end);
+         for (insn = BB_HEAD (bb);
+              insn != NULL && insn != NEXT_INSN (BB_END (bb));
               insn = NEXT_INSN (insn))
            {
              if (INSN_P (insn))
@@ -1093,7 +1098,7 @@ optimize_mode_switching (FILE *file)
          /* Check for blocks without ANY mode requirements.  */
          if (last_mode == no_mode)
            {
-             ptr = new_seginfo (no_mode, bb->end, bb->index, live_now);
+             ptr = new_seginfo (no_mode, BB_END (bb), bb->index, live_now);
              add_seginfo (info + bb->index, ptr);
            }
        }
@@ -1201,8 +1206,8 @@ optimize_mode_switching (FILE *file)
              if (eg->flags & EDGE_ABNORMAL)
                {
                  emited = true;
-                 if (GET_CODE (src_bb->end) == JUMP_INSN)
-                   emit_insn_before (mode_set, src_bb->end);
+                 if (JUMP_P (BB_END (src_bb)))
+                   emit_insn_before (mode_set, BB_END (src_bb));
                  /* It doesn't make sense to switch to normal mode
                     after a CALL_INSN, so we're going to abort if we
                     find one.  The cases in which a CALL_INSN may
@@ -1214,8 +1219,8 @@ optimize_mode_switching (FILE *file)
                     the call (it wouldn't make sense, anyway).  In
                     the case of EH edges, EH entry points also start
                     in normal mode, so a similar reasoning applies.  */
-                 else if (GET_CODE (src_bb->end) == INSN)
-                   emit_insn_after (mode_set, src_bb->end);
+                 else if (NONJUMP_INSN_P (BB_END (src_bb)))
+                   emit_insn_after (mode_set, BB_END (src_bb));
                  else
                    abort ();
                  bb_info[j][src_bb->index].computing = mode;
@@ -1266,7 +1271,7 @@ optimize_mode_switching (FILE *file)
                    continue;
 
                  emited = true;
-                 if (GET_CODE (ptr->insn_ptr) == NOTE
+                 if (NOTE_P (ptr->insn_ptr)
                      && (NOTE_LINE_NUMBER (ptr->insn_ptr)
                          == NOTE_INSN_BASIC_BLOCK))
                    emit_insn_after (mode_set, ptr->insn_ptr);