* config/m32c/m32c.h (LIBGCC2_UNITS_PER_WORD): Define if not

[pf3gnuchains/gcc-fork.git] / gcc / ira-color.c

diff --git a/gcc/ira-color.c b/gcc/ira-color.c
index a3dfddb..d61d39e 100644 (file)
--- a/gcc/ira-color.c
+++ b/gcc/ira-color.c
@@ -683,7 +683,7 @@ static int
 allocno_spill_priority (ira_allocno_t a)
 {
   return (ALLOCNO_TEMP (a)
-         / (ALLOCNO_LEFT_CONFLICTS_NUM (a)
+         / (ALLOCNO_LEFT_CONFLICTS_SIZE (a)
             * ira_reg_class_nregs[ALLOCNO_COVER_CLASS (a)][ALLOCNO_MODE (a)]
             + 1));
 }
@@ -861,7 +861,7 @@ static splay_tree uncolorable_allocnos_splay_tree[N_REG_CLASSES];
 static void
 push_allocno_to_stack (ira_allocno_t allocno)
 {
-  int conflicts_num, conflict_size, size;
+  int left_conflicts_size, conflict_size, size;
   ira_allocno_t a, conflict_allocno;
   enum reg_class cover_class;
   ira_allocno_conflict_iterator aci;
@@ -896,20 +896,21 @@ push_allocno_to_stack (ira_allocno_t allocno)
              if (ALLOCNO_IN_GRAPH_P (conflict_allocno)
                  && ! ALLOCNO_ASSIGNED_P (conflict_allocno))
                {
-                 conflicts_num = ALLOCNO_LEFT_CONFLICTS_NUM (conflict_allocno);
+                 left_conflicts_size
+                   = ALLOCNO_LEFT_CONFLICTS_SIZE (conflict_allocno);
                  conflict_size
                    = (ira_reg_class_nregs
                       [cover_class][ALLOCNO_MODE (conflict_allocno)]);
                  ira_assert
-                   (ALLOCNO_LEFT_CONFLICTS_NUM (conflict_allocno) >= size);
-                 if (conflicts_num + conflict_size
+                   (ALLOCNO_LEFT_CONFLICTS_SIZE (conflict_allocno) >= size);
+                 if (left_conflicts_size + conflict_size
                      <= ALLOCNO_AVAILABLE_REGS_NUM (conflict_allocno))
                    {
-                     ALLOCNO_LEFT_CONFLICTS_NUM (conflict_allocno) -= size;
+                     ALLOCNO_LEFT_CONFLICTS_SIZE (conflict_allocno) -= size;
                      continue;
                    }
-                 conflicts_num
-                   = ALLOCNO_LEFT_CONFLICTS_NUM (conflict_allocno) - size;
+                 left_conflicts_size
+                   = ALLOCNO_LEFT_CONFLICTS_SIZE (conflict_allocno) - size;
                  if (uncolorable_allocnos_splay_tree[cover_class] != NULL
                      && !ALLOCNO_SPLAY_REMOVED_P (conflict_allocno)
                      && USE_SPLAY_P (cover_class))
@@ -926,8 +927,9 @@ push_allocno_to_stack (ira_allocno_t allocno)
                                     removed_splay_allocno_vec,
                                     conflict_allocno);
                    }
-                 ALLOCNO_LEFT_CONFLICTS_NUM (conflict_allocno) = conflicts_num;
-                 if (conflicts_num + conflict_size
+                 ALLOCNO_LEFT_CONFLICTS_SIZE (conflict_allocno)
+                   = left_conflicts_size;
+                 if (left_conflicts_size + conflict_size
                      <= ALLOCNO_AVAILABLE_REGS_NUM (conflict_allocno))
                    {
                      delete_allocno_from_bucket
@@ -967,11 +969,11 @@ remove_allocno_from_bucket_and_push (ira_allocno_t allocno, bool colorable_p)
     }
   cover_class = ALLOCNO_COVER_CLASS (allocno);
   ira_assert ((colorable_p
-              && (ALLOCNO_LEFT_CONFLICTS_NUM (allocno)
+              && (ALLOCNO_LEFT_CONFLICTS_SIZE (allocno)
                   + ira_reg_class_nregs[cover_class][ALLOCNO_MODE (allocno)]
                   <= ALLOCNO_AVAILABLE_REGS_NUM (allocno)))
              || (! colorable_p
-                 && (ALLOCNO_LEFT_CONFLICTS_NUM (allocno)
+                 && (ALLOCNO_LEFT_CONFLICTS_SIZE (allocno)
                      + ira_reg_class_nregs[cover_class][ALLOCNO_MODE
                                                         (allocno)]
                      > ALLOCNO_AVAILABLE_REGS_NUM (allocno))));
@@ -1020,8 +1022,8 @@ ira_loop_edge_freq (ira_loop_tree_node_t loop_node, int regno, bool exit_p)
       FOR_EACH_EDGE (e, ei, loop_node->loop->header->preds)
        if (e->src != loop_node->loop->latch
            && (regno < 0
-               || (bitmap_bit_p (DF_LR_OUT (e->src), regno)
-                   && bitmap_bit_p (DF_LR_IN (e->dest), regno))))
+               || (bitmap_bit_p (df_get_live_out (e->src), regno)
+                   && bitmap_bit_p (df_get_live_in (e->dest), regno))))
          freq += EDGE_FREQUENCY (e);
     }
   else
@@ -1029,8 +1031,8 @@ ira_loop_edge_freq (ira_loop_tree_node_t loop_node, int regno, bool exit_p)
       edges = get_loop_exit_edges (loop_node->loop);
       for (i = 0; VEC_iterate (edge, edges, i, e); i++)
        if (regno < 0
-           || (bitmap_bit_p (DF_LR_OUT (e->src), regno)
-               && bitmap_bit_p (DF_LR_IN (e->dest), regno)))
+           || (bitmap_bit_p (df_get_live_out (e->src), regno)
+               && bitmap_bit_p (df_get_live_in (e->dest), regno)))
          freq += EDGE_FREQUENCY (e);
       VEC_free (edge, heap, edges);
     }
@@ -1084,11 +1086,11 @@ allocno_spill_priority_compare (splay_tree_key k1, splay_tree_key k2)
   ira_allocno_t a1 = (ira_allocno_t) k1, a2 = (ira_allocno_t) k2;
   
   pri1 = (ALLOCNO_TEMP (a1)
-         / (ALLOCNO_LEFT_CONFLICTS_NUM (a1)
+         / (ALLOCNO_LEFT_CONFLICTS_SIZE (a1)
             * ira_reg_class_nregs[ALLOCNO_COVER_CLASS (a1)][ALLOCNO_MODE (a1)]
             + 1));
   pri2 = (ALLOCNO_TEMP (a2)
-         / (ALLOCNO_LEFT_CONFLICTS_NUM (a2)
+         / (ALLOCNO_LEFT_CONFLICTS_SIZE (a2)
             * ira_reg_class_nregs[ALLOCNO_COVER_CLASS (a2)][ALLOCNO_MODE (a2)]
             + 1));
   if ((diff = pri1 - pri2) != 0)
@@ -1225,7 +1227,7 @@ push_allocnos_to_stack (void)
              allocno = VEC_pop (ira_allocno_t, removed_splay_allocno_vec);
              ALLOCNO_SPLAY_REMOVED_P (allocno) = false;
              rclass = ALLOCNO_COVER_CLASS (allocno);
-             if (ALLOCNO_LEFT_CONFLICTS_NUM (allocno)
+             if (ALLOCNO_LEFT_CONFLICTS_SIZE (allocno)
                  + ira_reg_class_nregs [rclass][ALLOCNO_MODE (allocno)]
                  > ALLOCNO_AVAILABLE_REGS_NUM (allocno))
                splay_tree_insert
@@ -1288,7 +1290,7 @@ push_allocnos_to_stack (void)
        }
       ira_assert (ALLOCNO_IN_GRAPH_P (allocno)
                  && ALLOCNO_COVER_CLASS (allocno) == cover_class
-                 && (ALLOCNO_LEFT_CONFLICTS_NUM (allocno)
+                 && (ALLOCNO_LEFT_CONFLICTS_SIZE (allocno)
                      + ira_reg_class_nregs[cover_class][ALLOCNO_MODE
                                                         (allocno)]
                      > ALLOCNO_AVAILABLE_REGS_NUM (allocno)));
@@ -1380,9 +1382,9 @@ setup_allocno_available_regs_num (ira_allocno_t allocno)
   ALLOCNO_AVAILABLE_REGS_NUM (allocno) -= n;
 }
 
-/* Set up ALLOCNO_LEFT_CONFLICTS_NUM for ALLOCNO.  */
+/* Set up ALLOCNO_LEFT_CONFLICTS_SIZE for ALLOCNO.  */
 static void
-setup_allocno_left_conflicts_num (ira_allocno_t allocno)
+setup_allocno_left_conflicts_size (ira_allocno_t allocno)
 {
   int i, hard_regs_num, hard_regno, conflict_allocnos_size;
   ira_allocno_t a, conflict_allocno;
@@ -1466,7 +1468,7 @@ setup_allocno_left_conflicts_num (ira_allocno_t allocno)
         if (a == allocno)
          break;
       }
-  ALLOCNO_LEFT_CONFLICTS_NUM (allocno) = conflict_allocnos_size;
+  ALLOCNO_LEFT_CONFLICTS_SIZE (allocno) = conflict_allocnos_size;
 }
 
 /* Put ALLOCNO in a bucket corresponding to its number and size of its
@@ -1482,9 +1484,9 @@ put_allocno_into_bucket (ira_allocno_t allocno)
   if (ALLOCNO_FIRST_COALESCED_ALLOCNO (allocno) != allocno)
     return;
   ALLOCNO_IN_GRAPH_P (allocno) = true;
-  setup_allocno_left_conflicts_num (allocno);
+  setup_allocno_left_conflicts_size (allocno);
   setup_allocno_available_regs_num (allocno);
-  if (ALLOCNO_LEFT_CONFLICTS_NUM (allocno)
+  if (ALLOCNO_LEFT_CONFLICTS_SIZE (allocno)
       + ira_reg_class_nregs[cover_class][ALLOCNO_MODE (allocno)]
       <= ALLOCNO_AVAILABLE_REGS_NUM (allocno))
     add_allocno_to_bucket (allocno, &colorable_allocno_bucket);