* alias.c (nonlocal_reference_p): Minor reformatting.

	* reload.c (find_equiv_reg): Simplify logic for
	CALL_INSN_FUNCTION_USAGE since can't have SUBREG or pseudos and
	some some reformatting.
	* reload1.c (reload_combine): Don't assume everything in
	CALL_INSN_FUNCTION_USAGE is a REG and clean up code a bit.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@33797 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 95ee457..45e9446 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+Tue May  9 06:30:20 2000  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+
+       * alias.c (nonlocal_reference_p): Minor reformatting.
+       * reload.c (find_equiv_reg): Simplify logic for
+       CALL_INSN_FUNCTION_USAGE since can't have SUBREG or pseudos and
+       some some reformatting.
+       * reload1.c (reload_combine): Don't assume everything in
+       CALL_INSN_FUNCTION_USAGE is a REG and clean up code a bit.
+
 2000-05-08  Richard Henderson  <rth@cygnus.com>
 
        * final.c (current_insn_predicate): New.

diff --git a/gcc/alias.c b/gcc/alias.c
index e29c57e..0aab362 100644 (file)
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -1427,7 +1427,8 @@ nonlocal_reference_p (x)
       if (code == CALL_INSN && CONST_CALL_P (x))
         {
          x = CALL_INSN_FUNCTION_USAGE (x);
-         if (!x) return 0;
+         if (x == 0)
+           return 0;
         }
       else
         x = PATTERN (x);

diff --git a/gcc/reload.c b/gcc/reload.c
index 4a35602..e1f5838 100644 (file)
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -6300,30 +6300,25 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
                  if (GET_CODE (pat) == CLOBBER)
                    {
                      register rtx dest = SET_DEST (pat);
-                     while (GET_CODE (dest) == SUBREG
-                            || GET_CODE (dest) == ZERO_EXTRACT
-                            || GET_CODE (dest) == SIGN_EXTRACT
-                            || GET_CODE (dest) == STRICT_LOW_PART)
-                       dest = XEXP (dest, 0);
+
                      if (GET_CODE (dest) == REG)
                        {
                          register int xregno = REGNO (dest);
-                         int xnregs;
-                         if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
-                           xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
-                         else
-                           xnregs = 1;
+                         int xnregs
+                           = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
+
                          if (xregno < regno + nregs
                              && xregno + xnregs > regno)
                            return 0;
-                         if (xregno < valueno + valuenregs
+                         else if (xregno < valueno + valuenregs
                              && xregno + xnregs > valueno)
                            return 0;
-                         if (goal_mem_addr_varies
-                             && reg_overlap_mentioned_for_reload_p (dest,
+                         else if (goal_mem_addr_varies
+                                  && reg_overlap_mentioned_for_reload_p (dest,
                                                                     goal))
                            return 0;
                        }
+
                      else if (goal_mem && GET_CODE (dest) == MEM
                               && ! push_operand (dest, GET_MODE (dest)))
                        return 0;

diff --git a/gcc/reload1.c b/gcc/reload1.c
index a543297..4d657be 100644 (file)
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -8377,6 +8377,7 @@ reload_combine ()
   rtx insn, set;
   int first_index_reg = 1, last_index_reg = 0;
   int i;
+  unsigned int r;
   int last_label_ruid;
   int min_labelno, n_labels;
   HARD_REG_SET ever_live_at_start, *label_live;
@@ -8389,15 +8390,14 @@ reload_combine ()
 
   /* To avoid wasting too much time later searching for an index register,
      determine the minimum and maximum index register numbers.  */
-  for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; --i)
-    {
-      if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS], i))
-       {
-         if (! last_index_reg)
-           last_index_reg = i;
-         first_index_reg = i;
-       }
-    }
+  for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
+    if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS], r))
+      {
+       if (! last_index_reg)
+         last_index_reg = r;
+       first_index_reg = i;
+      }
+
   /* If no index register is available, we can quit now.  */
   if (first_index_reg > last_index_reg)
     return;
@@ -8410,6 +8410,7 @@ reload_combine ()
   n_labels = max_label_num () - min_labelno;
   label_live = (HARD_REG_SET *) xmalloc (n_labels * sizeof (HARD_REG_SET));
   CLEAR_HARD_REG_SET (ever_live_at_start);
+
   for (i = n_basic_blocks - 1; i >= 0; i--)
     {
       insn = BLOCK_HEAD (i);
@@ -8417,8 +8418,10 @@ reload_combine ()
        {
          HARD_REG_SET live;
 
-         REG_SET_TO_HARD_REG_SET (live, BASIC_BLOCK (i)->global_live_at_start);
-         compute_use_by_pseudos (&live, BASIC_BLOCK (i)->global_live_at_start);
+         REG_SET_TO_HARD_REG_SET (live,
+                                  BASIC_BLOCK (i)->global_live_at_start);
+         compute_use_by_pseudos (&live,
+                                 BASIC_BLOCK (i)->global_live_at_start);
          COPY_HARD_REG_SET (LABEL_LIVE (insn), live);
          IOR_HARD_REG_SET (ever_live_at_start, live);
        }
@@ -8426,13 +8429,13 @@ reload_combine ()
 
   /* Initialize last_label_ruid, reload_combine_ruid and reg_state.  */
   last_label_ruid = reload_combine_ruid = 0;
-  for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; --i)
+  for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
     {
-      reg_state[i].store_ruid = reload_combine_ruid;
-      if (fixed_regs[i])
-       reg_state[i].use_index = -1;
+      reg_state[r].store_ruid = reload_combine_ruid;
+      if (fixed_regs[r])
+       reg_state[r].use_index = -1;
       else
-       reg_state[i].use_index = RELOAD_COMBINE_MAX_USES;
+       reg_state[r].use_index = RELOAD_COMBINE_MAX_USES;
     }
 
   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
@@ -8444,14 +8447,14 @@ reload_combine ()
         is and then later disable any optimization that would cross it.  */
       if (GET_CODE (insn) == CODE_LABEL)
        last_label_ruid = reload_combine_ruid;
-      if (GET_CODE (insn) == BARRIER)
-       {
-         for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; --i)
-           if (! fixed_regs[i])
-             reg_state[i].use_index = RELOAD_COMBINE_MAX_USES;
-       }
+      else if (GET_CODE (insn) == BARRIER)
+       for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
+         if (! fixed_regs[r])
+             reg_state[r].use_index = RELOAD_COMBINE_MAX_USES;
+
       if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
        continue;
+
       reload_combine_ruid++;
 
       /* Look for (set (REGX) (CONST_INT))
@@ -8481,7 +8484,7 @@ reload_combine ()
          rtx base = XEXP (plus, 1);
          rtx prev = prev_nonnote_insn (insn);
          rtx prev_set = prev ? single_set (prev) : NULL_RTX;
-         int regno = REGNO (reg);
+         unsigned int regno = REGNO (reg);
          rtx const_reg = NULL_RTX;
          rtx reg_sum = NULL_RTX;
 
@@ -8508,31 +8511,35 @@ reload_combine ()
                 two registers.  */
              for (i = first_index_reg; i <= last_index_reg; i++)
                {
-                 if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS], i)
+                 if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS],
+                                        i)
                      && reg_state[i].use_index == RELOAD_COMBINE_MAX_USES
                      && reg_state[i].store_ruid <= reg_state[regno].use_ruid
                      && HARD_REGNO_NREGS (i, GET_MODE (reg)) == 1)
                    {
                      rtx index_reg = gen_rtx_REG (GET_MODE (reg), i);
+
                      const_reg = index_reg;
                      reg_sum = gen_rtx_PLUS (GET_MODE (reg), index_reg, base);
                      break;
                    }
                }
            }
+
          /* Check that PREV_SET is indeed (set (REGX) (CONST_INT)) and that
             (REGY), i.e. BASE, is not clobbered before the last use we'll
             create.  */
-         if (prev_set
+         if (prev_set != 0
              && GET_CODE (SET_SRC (prev_set)) == CONST_INT
              && rtx_equal_p (SET_DEST (prev_set), reg)
              && reg_state[regno].use_index >= 0
-             && reg_state[REGNO (base)].store_ruid <= reg_state[regno].use_ruid
-             && reg_sum)
+             && (reg_state[REGNO (base)].store_ruid
+                 <= reg_state[regno].use_ruid)
+             && reg_sum != 0)
            {
              int i;
 
-             /* Change destination register and - if necessary - the
+             /* Change destination register and, if necessary, the
                 constant value in PREV, the constant loading instruction.  */
              validate_change (prev, &SET_DEST (prev_set), const_reg, 1);
              if (reg_state[regno].offset != const0_rtx)
@@ -8541,6 +8548,7 @@ reload_combine ()
                                 GEN_INT (INTVAL (SET_SRC (prev_set))
                                          + INTVAL (reg_state[regno].offset)),
                                 1);
+
              /* Now for every use of REG that we have recorded, replace REG
                 with REG_SUM.  */
              for (i = reg_state[regno].use_index;
@@ -8559,67 +8567,72 @@ reload_combine ()
                  NOTE_SOURCE_FILE (insn) = 0;
 
                  if (reg_state[regno].offset != const0_rtx)
-                   {
-                     /* Previous REG_EQUIV / REG_EQUAL notes for PREV
-                        are now invalid.  */
-                     for (np = &REG_NOTES (prev); *np; )
-                       {
-                         if (REG_NOTE_KIND (*np) == REG_EQUAL
-                             || REG_NOTE_KIND (*np) == REG_EQUIV)
-                           *np = XEXP (*np, 1);
-                         else
-                           np = &XEXP (*np, 1);
-                       }
-                   }
+                   /* Previous REG_EQUIV / REG_EQUAL notes for PREV
+                      are now invalid.  */
+                   for (np = &REG_NOTES (prev); *np; )
+                     {
+                       if (REG_NOTE_KIND (*np) == REG_EQUAL
+                           || REG_NOTE_KIND (*np) == REG_EQUIV)
+                         *np = XEXP (*np, 1);
+                       else
+                         np = &XEXP (*np, 1);
+                     }
+
                  reg_state[regno].use_index = RELOAD_COMBINE_MAX_USES;
-                 reg_state[REGNO (const_reg)].store_ruid = reload_combine_ruid;
+                 reg_state[REGNO (const_reg)].store_ruid
+                   = reload_combine_ruid;
                  continue;
                }
            }
        }
-      note_stores (PATTERN (insn), reload_combine_note_store, NULL);
+
+  note_stores (PATTERN (insn), reload_combine_note_store, NULL);
+
       if (GET_CODE (insn) == CALL_INSN)
        {
          rtx link;
 
-         for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; --i)
-           {
-             if (call_used_regs[i])
-               {
-                 reg_state[i].use_index = RELOAD_COMBINE_MAX_USES;
-                 reg_state[i].store_ruid = reload_combine_ruid;
-               }
-           }
+         for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
+           if (call_used_regs[r])
+             {
+               reg_state[r].use_index = RELOAD_COMBINE_MAX_USES;
+               reg_state[r].store_ruid = reload_combine_ruid;
+             }
+
          for (link = CALL_INSN_FUNCTION_USAGE (insn); link;
               link = XEXP (link, 1))
-           {
-             rtx use = XEXP (link, 0);
-             int regno = REGNO (XEXP (use, 0));
-             if (GET_CODE (use) == CLOBBER)
-               {
-                 reg_state[regno].use_index = RELOAD_COMBINE_MAX_USES;
-                 reg_state[regno].store_ruid = reload_combine_ruid;
-               }
-             else
-               reg_state[regno].use_index = -1;
-           }
+           if (GET_CODE (XEXP (XEXP (link, 0), 0)) == REG)
+             {
+               unsigned int regno = REGNO (XEXP (XEXP (link, 0), 0));
+
+               if (GET_CODE (XEXP (link, 0)) == CLOBBER)
+                 {
+                   reg_state[regno].use_index = RELOAD_COMBINE_MAX_USES;
+                   reg_state[regno].store_ruid = reload_combine_ruid;
+                 }
+               else
+                 reg_state[regno].use_index = -1;
+             }
        }
-      if (GET_CODE (insn) == JUMP_INSN && GET_CODE (PATTERN (insn)) != RETURN)
+
+      else if (GET_CODE (insn) == JUMP_INSN
+              && GET_CODE (PATTERN (insn)) != RETURN)
        {
          /* Non-spill registers might be used at the call destination in
             some unknown fashion, so we have to mark the unknown use.  */
          HARD_REG_SET *live;
+
          if ((condjump_p (insn) || condjump_in_parallel_p (insn))
              && JUMP_LABEL (insn))
            live = &LABEL_LIVE (JUMP_LABEL (insn));
          else
            live = &ever_live_at_start;
+
          for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; --i)
-           {
-             if (TEST_HARD_REG_BIT (*live, i))
-               reg_state[i].use_index = -1;
-           }
+           if (TEST_HARD_REG_BIT (*live, i))
+             reg_state[i].use_index = -1;
        }
+
       reload_combine_note_use (&PATTERN (insn), insn);
       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
        {
@@ -8633,12 +8646,14 @@ reload_combine ()
            }
        }
     }
+
   free (label_live);
 }
 
 /* Check if DST is a register or a subreg of a register; if it is,
    update reg_state[regno].store_ruid and reg_state[regno].use_index
    accordingly.  Called via note_stores from reload_combine.  */
+
 static void
 reload_combine_note_store (dst, set, data)
      rtx dst, set;