PR target/50566

	* config/avr/avr-protos.h (avr_legitimize_reload_address): New
	prototype.
	* config/avr/avr.h (LEGITIMIZE_RELOAD_ADDRESS): Copy worker code
	from here...
	* config/avr/avr.c (avr_legitimize_reload_address) ...to this new
	function.  Log if avr_log.legitimize_reload_address.

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 886d227..eddcd1c 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,13 @@
+2011-10-04  Georg-Johann Lay  <avr@gjlay.de>
+
+       PR target/50566
+       * config/avr/avr-protos.h (avr_legitimize_reload_address): New
+       prototype.
+       * config/avr/avr.h (LEGITIMIZE_RELOAD_ADDRESS): Copy worker code
+       from here...
+       * config/avr/avr.c (avr_legitimize_reload_address) ...to this new
+       function.  Log if avr_log.legitimize_reload_address.
+
 2011-10-04  Eric Botcazou  <ebotcazou@adacore.com>
 
        * config/sparc/sparc.c (sparc_fold_builtin): Use a sequence of tests.

diff --git a/gcc/config/avr/avr-protos.h b/gcc/config/avr/avr-protos.h
index 91e5108..7ad0f1c 100644 (file)
--- a/gcc/config/avr/avr-protos.h
+++ b/gcc/config/avr/avr-protos.h
@@ -106,6 +106,7 @@ extern RTX_CODE avr_normalize_condition (RTX_CODE condition);
 extern void out_shift_with_cnt (const char *templ, rtx insn,
                                rtx operands[], int *len, int t_len);
 extern rtx avr_incoming_return_addr_rtx (void);
+extern rtx avr_legitimize_reload_address (rtx, enum machine_mode, int, int, int, int, rtx (*)(rtx,int));
 #endif /* RTX_CODE */
 
 #ifdef REAL_VALUE_TYPE

diff --git a/gcc/config/avr/avr.c b/gcc/config/avr/avr.c
index 55fbae4..e6cb214 100644 (file)
--- a/gcc/config/avr/avr.c
+++ b/gcc/config/avr/avr.c
@@ -1290,6 +1290,87 @@ avr_legitimize_address (rtx x, rtx oldx, enum machine_mode mode)
 }
 
 
+/* Implement `LEGITIMIZE_RELOAD_ADDRESS'.  */
+/* This will allow register R26/27 to be used where it is no worse than normal
+   base pointers R28/29 or R30/31.  For example, if base offset is greater
+   than 63 bytes or for R++ or --R addressing.  */
+
+rtx
+avr_legitimize_reload_address (rtx x, enum machine_mode mode,
+                               int opnum, int type, int addr_type,
+                               int ind_levels ATTRIBUTE_UNUSED,
+                               rtx (*mk_memloc)(rtx,int))
+{
+  if (avr_log.legitimize_reload_address)
+    avr_edump ("\n%?:%m %r\n", mode, x);
+  
+  if (1 && (GET_CODE (x) == POST_INC
+            || GET_CODE (x) == PRE_DEC))
+    {
+      push_reload (XEXP (x, 0), XEXP (x, 0), &XEXP (x, 0), &XEXP (x, 0),
+                   POINTER_REGS, GET_MODE (x), GET_MODE (x), 0, 0,
+                   opnum, RELOAD_OTHER);
+      
+      if (avr_log.legitimize_reload_address)
+        avr_edump (" RCLASS = %R\n IN = %r\n OUT = %r\n",
+                   POINTER_REGS, XEXP (x, 0), XEXP (x, 0));
+      
+      return x;
+    }
+  
+  if (GET_CODE (x) == PLUS
+      && REG_P (XEXP (x, 0))
+      && 0 == reg_equiv_constant (REGNO (XEXP (x, 0)))
+      && CONST_INT_P (XEXP (x, 1))
+      && INTVAL (XEXP (x, 1)) >= 1)
+    {
+      bool fit = INTVAL (XEXP (x, 1)) <= MAX_LD_OFFSET (mode);
+      
+      if (fit)
+        {
+          if (reg_equiv_address (REGNO (XEXP (x, 0))) != 0)
+            {
+              int regno = REGNO (XEXP (x, 0));
+              rtx mem = mk_memloc (x, regno);
+              
+              push_reload (XEXP (mem, 0), NULL_RTX, &XEXP (mem, 0), NULL,
+                           POINTER_REGS, Pmode, VOIDmode, 0, 0,
+                           1, addr_type);
+              
+              if (avr_log.legitimize_reload_address)
+                avr_edump (" RCLASS = %R\n IN = %r\n OUT = %r\n",
+                           POINTER_REGS, XEXP (mem, 0), NULL_RTX);
+              
+              push_reload (mem, NULL_RTX, &XEXP (x, 0), NULL,
+                           BASE_POINTER_REGS, GET_MODE (x), VOIDmode, 0, 0,
+                           opnum, type);
+              
+              if (avr_log.legitimize_reload_address)
+                avr_edump (" RCLASS = %R\n IN = %r\n OUT = %r\n",
+                           BASE_POINTER_REGS, mem, NULL_RTX);
+              
+              return x;
+            }
+        }
+      else if (! (frame_pointer_needed
+                  && XEXP (x, 0) == frame_pointer_rtx))
+        {
+          push_reload (x, NULL_RTX, &x, NULL,
+                       POINTER_REGS, GET_MODE (x), VOIDmode, 0, 0,
+                       opnum, type);
+          
+          if (avr_log.legitimize_reload_address)
+            avr_edump (" RCLASS = %R\n IN = %r\n OUT = %r\n",
+                       POINTER_REGS, x, NULL_RTX);
+          
+          return x;
+        }
+    }
+  
+  return NULL_RTX;
+}
+
+
 /* Helper function to print assembler resp. track instruction
    sequence lengths.
    

diff --git a/gcc/config/avr/avr.h b/gcc/config/avr/avr.h
index dbb0b4c..51bd942 100644 (file)
--- a/gcc/config/avr/avr.h
+++ b/gcc/config/avr/avr.h
@@ -385,51 +385,17 @@ typedef struct avr_args {
   (REGNO (X) >= FIRST_PSEUDO_REGISTER || REG_OK_FOR_BASE_STRICT_P(X))
 
 #define REG_OK_FOR_BASE_STRICT_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
-
-/* LEGITIMIZE_RELOAD_ADDRESS will allow register R26/27 to be used, where it
-   is no worse than normal base pointers R28/29 and R30/31. For example:
-   If base offset is greater than 63 bytes or for R++ or --R addressing.  */
-   
-#define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)    \
-do {                                                                       \
-  if (1&&(GET_CODE (X) == POST_INC || GET_CODE (X) == PRE_DEC))            \
-    {                                                                      \
-      push_reload (XEXP (X,0), XEXP (X,0), &XEXP (X,0), &XEXP (X,0),       \
-                  POINTER_REGS, GET_MODE (X),GET_MODE (X) , 0, 0,          \
-                  OPNUM, RELOAD_OTHER);                                    \
-      goto WIN;                                                                    \
-    }                                                                      \
-  if (GET_CODE (X) == PLUS                                                 \
-      && REG_P (XEXP (X, 0))                                               \
-      && (reg_equiv_constant (REGNO (XEXP (X, 0))) == 0)                   \
-      && GET_CODE (XEXP (X, 1)) == CONST_INT                               \
-      && INTVAL (XEXP (X, 1)) >= 1)                                        \
-    {                                                                      \
-      int fit = INTVAL (XEXP (X, 1)) <= (64 - GET_MODE_SIZE (MODE));       \
-      if (fit)                                                             \
-       {                                                                   \
-          if (reg_equiv_address (REGNO (XEXP (X, 0))) != 0)                \
-           {                                                               \
-             int regno = REGNO (XEXP (X, 0));                              \
-             rtx mem = make_memloc (X, regno);                             \
-             push_reload (XEXP (mem,0), NULL, &XEXP (mem,0), NULL,         \
-                          POINTER_REGS, Pmode, VOIDmode, 0, 0,             \
-                          1, ADDR_TYPE (TYPE));                            \
-             push_reload (mem, NULL_RTX, &XEXP (X, 0), NULL,               \
-                          BASE_POINTER_REGS, GET_MODE (X), VOIDmode, 0, 0, \
-                          OPNUM, TYPE);                                    \
-             goto WIN;                                                     \
-           }                                                               \
-       }                                                                   \
-      else if (! (frame_pointer_needed && XEXP (X,0) == frame_pointer_rtx)) \
-       {                                                                   \
-         push_reload (X, NULL_RTX, &X, NULL,                               \
-                      POINTER_REGS, GET_MODE (X), VOIDmode, 0, 0,          \
-                      OPNUM, TYPE);                                        \
-          goto WIN;                                                        \
-       }                                                                   \
-    }                                                                      \
-} while(0)
+#define LEGITIMIZE_RELOAD_ADDRESS(X,MODE,OPNUM,TYPE,IND_L,WIN)          \
+  do {                                                                  \
+    rtx new_x = avr_legitimize_reload_address (X, MODE, OPNUM, TYPE,    \
+                                               ADDR_TYPE (TYPE),        \
+                                               IND_L, make_memloc);     \
+    if (new_x)                                                          \
+      {                                                                 \
+        X = new_x;                                                      \
+        goto WIN;                                                       \
+      }                                                                 \
+  } while (0)
 
 #define BRANCH_COST(speed_p, predictable_p) 0