Treat QImode addresses the same way GO_IF_LEGITIMATE_INDEX does.

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 3cb4bb7..faf8e24 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,8 @@
+Fri Nov 12 13:31:54 1999  Bernd Schmidt  <bernds@cygnus.co.uk>
+
+       * config/arm/arm.h (LEGITIMIZE_RELOAD_ADDRESS): Treat QImode
+       addresses the same way GO_IF_LEGITIMATE_INDEX does. 
+
 Fri Nov 12 12:36:04 1999  Bernd Schmidt  <bernds@cygnus.co.uk>
 
        * cse.c (hash_arg_in_struct): Delete.

diff --git a/gcc/config/arm/arm.h b/gcc/config/arm/arm.h
index a7ecbb5..14e5293 100644 (file)
--- a/gcc/config/arm/arm.h
+++ b/gcc/config/arm/arm.h
@@ -1015,52 +1015,52 @@ enum reg_class
    For the ARM, we wish to handle large displacements off a base
    register by splitting the addend across a MOV and the mem insn.
    This can cut the number of reloads needed. */
-#define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)               \
-  do                                                                                   \
-    {                                                                                  \
-      if (GET_CODE (X) == PLUS                                                         \
-         && GET_CODE (XEXP (X, 0)) == REG                                              \
-         && REGNO (XEXP (X, 0)) < FIRST_PSEUDO_REGISTER                                \
-         && REG_MODE_OK_FOR_BASE_P (XEXP (X, 0), MODE)                                 \
-         && GET_CODE (XEXP (X, 1)) == CONST_INT)                                       \
-       {                                                                               \
-         HOST_WIDE_INT val = INTVAL (XEXP (X, 1));                                     \
-         HOST_WIDE_INT low, high;                                                      \
-                                                                                       \
-         if (MODE == DImode || (TARGET_SOFT_FLOAT && MODE == DFmode))                  \
-           low = ((val & 0xf) ^ 0x8) - 0x8;                                            \
-         else if (MODE == SImode || MODE == QImode                                     \
-                  || (MODE == SFmode && TARGET_SOFT_FLOAT)                             \
-                  || (MODE == HImode && ! arm_arch4))                                  \
-           /* Need to be careful, -4096 is not a valid offset */                       \
-           low = val >= 0 ? (val & 0xfff) : -((-val) & 0xfff);                         \
-         else if (MODE == HImode && arm_arch4)                                         \
-           /* Need to be careful, -256 is not a valid offset */                        \
-           low = val >= 0 ? (val & 0xff) : -((-val) & 0xff);                           \
-         else if (GET_MODE_CLASS (MODE) == MODE_FLOAT                                  \
-                  && TARGET_HARD_FLOAT)                                                \
-           /* Need to be careful, -1024 is not a valid offset */                       \
-           low = val >= 0 ? (val & 0x3ff) : -((-val) & 0x3ff);                         \
-         else                                                                          \
-           break;                                                                      \
-                                                                                       \
-         high = ((((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000);              \
-         /* Check for overflow or zero */                                              \
-         if (low == 0 || high == 0 || (high + low != val))                             \
-           break;                                                                      \
-                                                                                       \
-         /* Reload the high part into a base reg; leave the low part                   \
-            in the mem.  */                                                            \
-         X = gen_rtx_PLUS (GET_MODE (X),                                               \
-                           gen_rtx_PLUS (GET_MODE (X), XEXP (X, 0),                    \
-                                         GEN_INT (high)),                              \
-                           GEN_INT (low));                                             \
-         push_reload (XEXP (X, 0), NULL_RTX, &XEXP (X, 0), NULL_PTR,                   \
-                      BASE_REG_CLASS, GET_MODE (X), VOIDmode, 0, 0,                    \
-                      OPNUM, TYPE);                                                    \
-         goto WIN;                                                                     \
-       }                                                                               \
-    }                                                                                  \
+#define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)       \
+  do                                                                           \
+    {                                                                          \
+      if (GET_CODE (X) == PLUS                                                 \
+         && GET_CODE (XEXP (X, 0)) == REG                                      \
+         && REGNO (XEXP (X, 0)) < FIRST_PSEUDO_REGISTER                        \
+         && REG_MODE_OK_FOR_BASE_P (XEXP (X, 0), MODE)                         \
+         && GET_CODE (XEXP (X, 1)) == CONST_INT)                               \
+       {                                                                       \
+         HOST_WIDE_INT val = INTVAL (XEXP (X, 1));                             \
+         HOST_WIDE_INT low, high;                                              \
+                                                                               \
+         if (MODE == DImode || (TARGET_SOFT_FLOAT && MODE == DFmode))          \
+           low = ((val & 0xf) ^ 0x8) - 0x8;                                    \
+         else if (MODE == SImode                                               \
+                  || (MODE == SFmode && TARGET_SOFT_FLOAT)                     \
+                  || ((MODE == HImode || MODE == QImode) && ! arm_arch4))      \
+           /* Need to be careful, -4096 is not a valid offset */               \
+           low = val >= 0 ? (val & 0xfff) : -((-val) & 0xfff);                 \
+         else if ((MODE == HImode || MODE == QImode) && arm_arch4)             \
+           /* Need to be careful, -256 is not a valid offset */                \
+           low = val >= 0 ? (val & 0xff) : -((-val) & 0xff);                   \
+         else if (GET_MODE_CLASS (MODE) == MODE_FLOAT                          \
+                  && TARGET_HARD_FLOAT)                                        \
+           /* Need to be careful, -1024 is not a valid offset */               \
+           low = val >= 0 ? (val & 0x3ff) : -((-val) & 0x3ff);                 \
+         else                                                                  \
+           break;                                                              \
+                                                                               \
+         high = ((((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000);      \
+         /* Check for overflow or zero */                                      \
+         if (low == 0 || high == 0 || (high + low != val))                     \
+           break;                                                              \
+                                                                               \
+         /* Reload the high part into a base reg; leave the low part           \
+            in the mem.  */                                                    \
+         X = gen_rtx_PLUS (GET_MODE (X),                                       \
+                           gen_rtx_PLUS (GET_MODE (X), XEXP (X, 0),            \
+                                         GEN_INT (high)),                      \
+                           GEN_INT (low));                                     \
+         push_reload (XEXP (X, 0), NULL_RTX, &XEXP (X, 0), NULL_PTR,           \
+                      BASE_REG_CLASS, GET_MODE (X), VOIDmode, 0, 0,            \
+                      OPNUM, TYPE);                                            \
+         goto WIN;                                                             \
+       }                                                                       \
+    }                                                                          \
   while (0)
 
 /* Return the maximum number of consecutive registers