loop.c (combine_givs_used_by_other): Delete.

        * loop.c (combine_givs_used_by_other): Delete.
        (combine_givs_benefit_from): Delete.
        (combine_givs): Deny combination of givs only used once.  Simplify
        code with the death of combine_givs_benefit_from.

From-SVN: r25183

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index b495dfcdff1f346186d570a5b5e4cd7fbba7465a..a1a463051a6179f223e861d4967c835d5633201f 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+Sat Feb 13 23:29:42 1999  Richard Henderson  <rth@cygnus.com>
+
+       * loop.c (combine_givs_used_by_other): Delete.
+       (combine_givs_benefit_from): Delete.
+       (combine_givs): Deny combination of givs only used once.  Simplify
+       code with the death of combine_givs_benefit_from.
+
 Sun Feb 14 11:24:05 1999  Michael Hayes  <m.hayes@elec.canterbury.ac.nz>
 
        * loop.c (scan_loop): Call reg_in_basic_block_p before

diff --git a/gcc/loop.c b/gcc/loop.c
index 9e230a63ade843aaefccb646b87069da8e1eb039..080f39386f6b4737c1d666531a676f4eed0a27f2 100644 (file)
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -6768,42 +6768,6 @@ cmp_combine_givs_stats (x, y)
   return d;
 }
 
-/* If one of these givs is a DEST_REG that was used once by the other giv,
-   this is actually a single use.  Return 0 if this is not the case,
-   -1 if g1 is the DEST_REG involved, and 1 if it was g2.  */
-
-static int
-combine_givs_used_by_other (g1, g2)
-     struct induction *g1, *g2;
-{
-  if (g1->giv_type == DEST_REG
-      && VARRAY_RTX (reg_single_usage, REGNO (g1->dest_reg)) != 0
-      && VARRAY_RTX (reg_single_usage, REGNO (g1->dest_reg)) != const0_rtx
-      && reg_mentioned_p (g1->dest_reg, PATTERN (g2->insn)))
-    return -1;
-
-  if (g2->giv_type == DEST_REG
-      && VARRAY_RTX (reg_single_usage, REGNO (g2->dest_reg)) != 0
-      && VARRAY_RTX (reg_single_usage, REGNO (g2->dest_reg)) != const0_rtx
-      && reg_mentioned_p (g2->dest_reg, PATTERN (g1->insn)))
-    return 1;
-
-  return 0;
-}
- 
-static int
-combine_givs_benefit_from (g1, g2)
-     struct induction *g1, *g2;
-{
-  int tmp = combine_givs_used_by_other (g1, g2);
-  if (tmp < 0)
-    return 0;
-  else if (tmp > 0)
-    return g2->benefit - g1->benefit;
-  else
-    return g2->benefit;
-}
-
 /* Check all pairs of givs for iv_class BL and see if any can be combined with
    any other.  If so, point SAME to the giv combined with and set NEW_REG to
    be an expression (in terms of the other giv's DEST_REG) equivalent to the
@@ -6813,6 +6777,9 @@ static void
 combine_givs (bl)
      struct iv_class *bl;
 {
+  /* Additional benefit to add for being combined multiple times.  */
+  const int extra_benefit = 3;
+
   struct induction *g1, *g2, **giv_array;
   int i, j, k, giv_count;
   struct combine_givs_stats *stats;
@@ -6840,13 +6807,27 @@ combine_givs (bl)
   for (i = 0; i < giv_count; i++)
     {
       int this_benefit;
+      rtx single_use;
 
       g1 = giv_array[i];
+      stats[i].giv_number = i;
+
+      /* If a DEST_REG GIV is used only once, do not allow it to combine
+        with anything, for in doing so we will gain nothing that cannot
+        be had by simply letting the GIV with which we would have combined
+        to be reduced on its own.  The losage shows up in particular with 
+        DEST_ADDR targets on hosts with reg+reg addressing, though it can
+        be seen elsewhere as well.  */
+      if (g1->giv_type == DEST_REG
+         && (single_use = VARRAY_RTX (reg_single_usage, REGNO (g1->dest_reg)))
+         && single_use != const0_rtx)
+       continue;
 
       this_benefit = g1->benefit;
       /* Add an additional weight for zero addends.  */
       if (g1->no_const_addval)
        this_benefit += 1;
+
       for (j = 0; j < giv_count; j++)
        {
          rtx this_combine;
@@ -6856,12 +6837,9 @@ combine_givs (bl)
              && (this_combine = combine_givs_p (g1, g2)) != NULL_RTX)
            {
              can_combine[i*giv_count + j] = this_combine;
-             this_benefit += combine_givs_benefit_from (g1, g2);
-             /* Add an additional weight for being reused more times.  */
-             this_benefit += 3;
+             this_benefit += g2->benefit + extra_benefit;
            }
        }
-      stats[i].giv_number = i;
       stats[i].total_benefit = this_benefit;
     }
 
@@ -6908,7 +6886,7 @@ restart:
              g1->combined_with++;
              g1->lifetime += g2->lifetime;
 
-             g1_add_benefit += combine_givs_benefit_from (g1, g2);
+             g1_add_benefit += g2->benefit;
 
              /* ??? The new final_[bg]iv_value code does a much better job
                 of finding replaceable giv's, and hence this code may no
@@ -6922,11 +6900,7 @@ restart:
                {
                  int m = stats[l].giv_number;
                  if (can_combine[m*giv_count + j])
-                   {
-                     /* Remove additional weight for being reused.  */
-                     stats[l].total_benefit -= 3 + 
-                       combine_givs_benefit_from (giv_array[m], g2);
-                   }
+                   stats[l].total_benefit -= g2->benefit + extra_benefit;
                }
 
              if (loop_dump_stream)
@@ -6944,11 +6918,7 @@ restart:
            {
              int m = stats[j].giv_number;
              if (can_combine[m*giv_count + j])
-               {
-                 /* Remove additional weight for being reused.  */
-                 stats[j].total_benefit -= 3 + 
-                   combine_givs_benefit_from (giv_array[m], g1);
-               }
+               stats[j].total_benefit -= g1->benefit + extra_benefit;
            }
 
          g1->benefit += g1_add_benefit;