reload1.c (emit_reload_insns): Also find equivalent mems for subregs of pseudos.

        * reload1.c (emit_reload_insns): Also find equivalent mems
        for subregs of pseudos.

From-SVN: r26444

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index a701e94219724b3dc8f5809a50ae5de9297e70be..3990cc140b18f087efb76b9437d18bf4ea6e596b 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,8 @@
+Wed Apr 14 09:59:38 1999  Richard Henderson  <rth@cygnus.com>
+
+       * reload1.c (emit_reload_insns): Also find equivalent mems
+       for subregs of pseudos.
+
 Wed Apr 14 09:39:20 1999  Richard Henderson  <rth@cygnus.com>
 
        * i386.md (neghi): Use the whole register when widening the op.

diff --git a/gcc/reload1.c b/gcc/reload1.c
index e97e98e8e08c0335b50cc579da6d483de0ebb6e7..c566d3819d017d95bb01e937b9781f558945af41 100644 (file)
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -6865,6 +6865,7 @@ emit_reload_insns (chain)
                  int secondary_reload = reload_secondary_in_reload[j];
                  rtx real_oldequiv = oldequiv;
                  rtx real_old = old;
+                 rtx tmp;
 
                  /* If OLDEQUIV is a pseudo with a MEM, get the real MEM
                     and similarly for OLD.
@@ -6873,30 +6874,42 @@ emit_reload_insns (chain)
                     equivalent MEM, we must fall back to reload_in, which
                     will have all the necessary substitutions registered.
                     Likewise for a pseudo that can't be replaced with its
-                    equivalent constant.  */
+                    equivalent constant. 
+
+                    Take extra care for subregs of such pseudos.  Note that
+                    we cannot use reg_equiv_mem in this case because it is
+                    not in the right mode.  */
                                
-                 if (GET_CODE (oldequiv) == REG
-                     && REGNO (oldequiv) >= FIRST_PSEUDO_REGISTER
-                     && (reg_equiv_memory_loc[REGNO (oldequiv)] != 0
-                         || reg_equiv_constant[REGNO (oldequiv)] != 0))
+                 tmp = oldequiv;
+                 if (GET_CODE (tmp) == SUBREG)
+                   tmp = SUBREG_REG (tmp);
+                 if (GET_CODE (tmp) == REG
+                     && REGNO (tmp) >= FIRST_PSEUDO_REGISTER
+                     && (reg_equiv_memory_loc[REGNO (tmp)] != 0
+                         || reg_equiv_constant[REGNO (tmp)] != 0))
                    {
-                     if (! reg_equiv_mem[REGNO (oldequiv)]
-                         || num_not_at_initial_offset)
+                     if (! reg_equiv_mem[REGNO (tmp)]
+                         || num_not_at_initial_offset
+                         || GET_CODE (oldequiv) == SUBREG)
                        real_oldequiv = reload_in[j];
                      else
-                       real_oldequiv = reg_equiv_mem[REGNO (oldequiv)];
+                       real_oldequiv = reg_equiv_mem[REGNO (tmp)];
                    }
 
-                 if (GET_CODE (old) == REG
-                     && REGNO (old) >= FIRST_PSEUDO_REGISTER
-                     && (reg_equiv_memory_loc[REGNO (old)] != 0
-                         || reg_equiv_constant[REGNO (old)] != 0))
+                 tmp = old;
+                 if (GET_CODE (tmp) == SUBREG)
+                   tmp = SUBREG_REG (tmp);
+                 if (GET_CODE (tmp) == REG
+                     && REGNO (tmp) >= FIRST_PSEUDO_REGISTER
+                     && (reg_equiv_memory_loc[REGNO (tmp)] != 0
+                         || reg_equiv_constant[REGNO (tmp)] != 0))
                    {
-                     if (! reg_equiv_mem[REGNO (old)]
-                         || num_not_at_initial_offset)
+                     if (! reg_equiv_mem[REGNO (tmp)]
+                         || num_not_at_initial_offset
+                         || GET_CODE (old) == SUBREG)
                        real_old = reload_in[j];
                      else
-                       real_old = reg_equiv_mem[REGNO (old)];
+                       real_old = reg_equiv_mem[REGNO (tmp)];
                    }
 
                  second_reload_reg = reload_reg_rtx[secondary_reload];