loop.c (struct movables): New.

	* loop.c (struct movables): New.
	(num_movables): Move into struct movables.
	(the_movables): Change type to struct movables.
	(ignore_some_movables): Change struct movable arg to struct movables.
 	(force_movables, combine_movables, regs_match_p): Likewise.
	(rtx_equal_for_loop_p, move_movables): Likewise.
	(scan_loop): Change movables to be of type struct movables.
	Replace last_movable with field in movables structure.

From-SVN: r36278

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d2f6b61241b1c1b60dfb026df7038532f31a6244..1441c2f2c82d7a201be697ca05fd336fc143c89e 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,14 @@
+2000-09-10  Michael Hayes  <mhayes@cygnus.com>
+
+       * loop.c (struct movables): New.
+       (num_movables): Move into struct movables.
+       (the_movables): Change type to struct movables.
+       (ignore_some_movables): Change struct movable arg to struct movables.
+       (force_movables, combine_movables, regs_match_p): Likewise.
+       (rtx_equal_for_loop_p, move_movables): Likewise.
+       (scan_loop): Change movables to be of type struct movables.
+       Replace last_movable with field in movables structure.
+
 2000-09-08  Zack Weinberg  <zack@wolery.cumb.org>
 
        * c-pragma.c: Don't elide entire file if !HANDLE_GENERIC_PRAGMAS.

diff --git a/gcc/loop.c b/gcc/loop.c
index a7bba71cbe60ace62e55269f6b7e675e24f86b8d..0ec79ebbd4e8558ef00a4be775dfdc2042d4ec76 100644 (file)
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -153,9 +153,6 @@ static int unknown_address_altered;
 
 static int unknown_constant_address_altered;
 
-/* Count of movable (i.e. invariant) instructions discovered in the loop.  */
-static int num_movables;
-
 /* Count of memory write instructions discovered in the loop.  */
 static int num_mem_sets;
 
@@ -224,7 +221,17 @@ struct movable
   struct movable *next;
 };
 
-static struct movable *the_movables;
+struct movables
+{
+  /* Head of movable chain.  */
+  struct movable *head;
+  /* Last movable in chain.  */
+  struct movable *last;
+  /* Number of movables in the loop.  */
+  int num;
+};
+
+static struct movables the_movables;
 
 FILE *loop_dump_stream;
 
@@ -252,13 +259,13 @@ static void replace_call_address PARAMS ((rtx, rtx, rtx));
 #endif
 static rtx skip_consec_insns PARAMS ((rtx, int));
 static int libcall_benefit PARAMS ((rtx));
-static void ignore_some_movables PARAMS ((struct movable *));
-static void force_movables PARAMS ((struct movable *));
-static void combine_movables PARAMS ((struct movable *, int));
-static int regs_match_p PARAMS ((rtx, rtx, struct movable *));
-static int rtx_equal_for_loop_p PARAMS ((rtx, rtx, struct movable *));
+static void ignore_some_movables PARAMS ((struct movables *));
+static void force_movables PARAMS ((struct movables *));
+static void combine_movables PARAMS ((struct movables *, int));
+static int regs_match_p PARAMS ((rtx, rtx, struct movables *));
+static int rtx_equal_for_loop_p PARAMS ((rtx, rtx, struct movables *));
 static void add_label_notes PARAMS ((rtx, rtx));
-static void move_movables PARAMS ((struct loop *loop, struct movable *,
+static void move_movables PARAMS ((struct loop *loop, struct movables *,
                                   int, int, int));
 static int count_nonfixed_reads PARAMS ((const struct loop *, rtx));
 static void strength_reduce PARAMS ((struct loop *, int, int));
@@ -599,9 +606,7 @@ scan_loop (loop, flags)
   /* The SET from an insn, if it is the only SET in the insn.  */
   rtx set, set1;
   /* Chain describing insns movable in current loop.  */
-  struct movable *movables = 0;
-  /* Last element in `movables' -- so we can add elements at the end.  */
-  struct movable *last_movable = 0;
+  struct movables *movables = &the_movables;
   /* Ratio of extra register life span we can justify
      for saving an instruction.  More if loop doesn't call subroutines
      since in that case saving an insn makes more difference
@@ -611,6 +616,10 @@ scan_loop (loop, flags)
   int loop_depth = 0;
   int nregs;
 
+  movables->head = 0;
+  movables->last = 0;
+  movables->num = 0;
+
   loop->top = 0;
 
   /* Determine whether this loop starts with a jump down to a test at
@@ -916,11 +925,11 @@ scan_loop (loop, flags)
                m->savings += libcall_benefit (p);
              VARRAY_INT (set_in_loop, regno) = move_insn ? -2 : -1;
              /* Add M to the end of the chain MOVABLES.  */
-             if (movables == 0)
-               movables = m;
+             if (movables->head == 0)
+               movables->head = m;
              else
-               last_movable->next = m;
-             last_movable = m;
+               movables->last->next = m;
+             movables->last = m;
 
              if (m->consec > 0)
                {
@@ -1025,11 +1034,11 @@ scan_loop (loop, flags)
                  m->savings = 1;
                  VARRAY_INT (set_in_loop, regno) = -1;
                  /* Add M to the end of the chain MOVABLES.  */
-                 if (movables == 0)
-                   movables = m;
+                 if (movables->head == 0)
+                   movables->head = m;
                  else
-                   last_movable->next = m;
-                 last_movable = m;
+                   movables->last->next = m;
+                 movables->last = m;
                }
            }
        }
@@ -1121,7 +1130,6 @@ scan_loop (loop, flags)
        /* Ensure our label doesn't go away.  */
        LABEL_NUSES (update_end)++;
 
-      the_movables = movables;
       strength_reduce (loop, insn_count, flags);
 
       reg_scan_update (update_start, update_end, loop_max_reg);
@@ -1331,11 +1339,11 @@ skip_consec_insns (insn, count)
 
 static void
 ignore_some_movables (movables)
-     struct movable *movables;
+     struct movables *movables;
 {
   register struct movable *m, *m1;
 
-  for (m = movables; m; m = m->next)
+  for (m = movables->head; m; m = m->next)
     {
       /* Is this a movable for the value of a libcall?  */
       rtx note = find_reg_note (m->insn, REG_RETVAL, NULL_RTX);
@@ -1349,7 +1357,7 @@ ignore_some_movables (movables)
             explicitly check each insn in the libcall (since invariant
             libcalls aren't that common).  */
          for (insn = XEXP (note, 0); insn != m->insn; insn = NEXT_INSN (insn))
-           for (m1 = movables; m1 != m; m1 = m1->next)
+           for (m1 = movables->head; m1 != m; m1 = m1->next)
              if (m1->insn == insn)
                m1->done = 1;
        }
@@ -1363,10 +1371,10 @@ ignore_some_movables (movables)
 
 static void
 force_movables (movables)
-     struct movable *movables;
+     struct movables *movables;
 {
   register struct movable *m, *m1;
-  for (m1 = movables; m1; m1 = m1->next)
+  for (m1 = movables->head; m1; m1 = m1->next)
     /* Omit this if moving just the (SET (REG) 0) of a zero-extend.  */
     if (!m1->partial && !m1->done)
       {
@@ -1402,7 +1410,7 @@ force_movables (movables)
 
 static void
 combine_movables (movables, nregs)
-     struct movable *movables;
+     struct movables *movables;
      int nregs;
 {
   register struct movable *m;
@@ -1413,7 +1421,7 @@ combine_movables (movables, nregs)
      or be matched.  I'm no longer sure why not.  */
   /* Perhaps testing m->consec_sets would be more appropriate here?  */
 
-  for (m = movables; m; m = m->next)
+  for (m = movables->head; m; m = m->next)
     if (m->match == 0 && VARRAY_INT (n_times_set, m->regno) == 1
        && !m->partial)
       {
@@ -1473,7 +1481,7 @@ combine_movables (movables, nregs)
 
       /* Combine all the registers for extension from mode MODE.
         Don't combine any that are used outside this loop.  */
-      for (m = movables; m; m = m->next)
+      for (m = movables->head; m; m = m->next)
        if (m->partial && ! m->global
            && mode == GET_MODE (SET_SRC (PATTERN (NEXT_INSN (m->insn)))))
          {
@@ -1495,7 +1503,7 @@ combine_movables (movables, nregs)
 
            /* We already have one: check for overlap with those
               already combined together.  */
-           for (m1 = movables; m1 != m; m1 = m1->next)
+           for (m1 = movables->head; m1 != m; m1 = m1->next)
              if (m1 == m0 || (m1->partial && m1->match == m0))
                if (! (uid_luid[REGNO_FIRST_UID (m1->regno)] > last
                       || uid_luid[REGNO_LAST_UID (m1->regno)] < first))
@@ -1521,17 +1529,17 @@ combine_movables (movables, nregs)
 static int
 regs_match_p (x, y, movables)
      rtx x, y;
-     struct movable *movables;
+     struct movables *movables;
 {
   unsigned int xn = REGNO (x);
   unsigned int yn = REGNO (y);
   struct movable *mx, *my;
 
-  for (mx = movables; mx; mx = mx->next)
+  for (mx = movables->head; mx; mx = mx->next)
     if (mx->regno == xn)
       break;
 
-  for (my = movables; my; my = my->next)
+  for (my = movables->head; my; my = my->next)
     if (my->regno == yn)
       break;
 
@@ -1550,7 +1558,7 @@ regs_match_p (x, y, movables)
 static int
 rtx_equal_for_loop_p (x, y, movables)
      rtx x, y;
-     struct movable *movables;
+     struct movables *movables;
 {
   register int i;
   register int j;
@@ -1570,7 +1578,7 @@ rtx_equal_for_loop_p (x, y, movables)
   if (GET_CODE (x) == REG && VARRAY_INT (set_in_loop, REGNO (x)) == -2
       && CONSTANT_P (y))
     {
-      for (m = movables; m; m = m->next)
+      for (m = movables->head; m; m = m->next)
        if (m->move_insn && m->regno == REGNO (x)
            && rtx_equal_p (m->set_src, y))
          return 1;
@@ -1578,7 +1586,7 @@ rtx_equal_for_loop_p (x, y, movables)
   else if (GET_CODE (y) == REG && VARRAY_INT (set_in_loop, REGNO (y)) == -2
           && CONSTANT_P (x))
     {
-      for (m = movables; m; m = m->next)
+      for (m = movables->head; m; m = m->next)
        if (m->move_insn && m->regno == REGNO (y)
            && rtx_equal_p (m->set_src, x))
          return 1;
@@ -1703,7 +1711,7 @@ add_label_notes (x, insns)
 static void
 move_movables (loop, movables, threshold, insn_count, nregs)
      struct loop *loop;
-     struct movable *movables;
+     struct movables *movables;
      int threshold;
      int insn_count;
      int nregs;
@@ -1719,9 +1727,9 @@ move_movables (loop, movables, threshold, insn_count, nregs)
   rtx *reg_map = (rtx *) xcalloc (nregs, sizeof (rtx));
   char *already_moved = (char *) xcalloc (nregs, sizeof (char));
 
-  num_movables = 0;
+  movables->num = 0;
 
-  for (m = movables; m; m = m->next)
+  for (m = movables->head; m; m = m->next)
     {
       /* Describe this movable insn.  */
 
@@ -1750,7 +1758,7 @@ move_movables (loop, movables, threshold, insn_count, nregs)
        }
 
       /* Count movables.  Value used in heuristics in strength_reduce.  */
-      num_movables++;
+      movables->num++;
 
       /* Ignore the insn if it's already done (it matched something else).
         Otherwise, see if it is now safe to move.  */
@@ -2129,7 +2137,7 @@ move_movables (loop, movables, threshold, insn_count, nregs)
              /* Combine with this moved insn any other matching movables.  */
 
              if (! m->partial)
-               for (m1 = movables; m1; m1 = m1->next)
+               for (m1 = movables->head; m1; m1 = m1->next)
                  if (m1->match == m)
                    {
                      rtx temp;
@@ -6542,7 +6550,7 @@ simplify_giv_expr (loop, x, ext_val, benefit)
            {
              struct movable *m;
 
-             for (m = the_movables; m; m = m->next)
+             for (m = the_movables.head; m; m = m->next)
                if (rtx_equal_p (x, m->set_dest))
                  {
                    /* Ok, we found a match.  Substitute and simplify.  */
@@ -8264,7 +8272,7 @@ check_dbra_loop (loop, insn_count)
           && ! loop_info->has_volatile
           && reversible_mem_store
           && (bl->giv_count + bl->biv_count + num_mem_sets
-             + num_movables + compare_and_branch == insn_count)
+             + the_movables.num + compare_and_branch == insn_count)
           && (bl == loop_iv_list && bl->next == 0))
          || no_use_except_counting)
        {