bfin-protos.h (bfin_dsp_memref_p): Declare.

	* config/bfin/bfin-protos.h (bfin_dsp_memref_p): Declare.
	* config/bfin/bfin.c (bfin_dsp_memref_p): New function.
	(bfin_valid_reg_p): Test for pseudos explicitly and use only
	REGNO_MODE_CODE_OK_FOR_BASE_P.  New args MODE and OUTER_CODE; all
	callers changed.
	* config/bfin/bfin.h (PREG_P): Use P_REGNO_P.
	(IREG_P, P_REGNO_P, I_REGNO_P): New macros.
	(enum reg_class, REG_CLASS_CONTENTS): Add IPREGS.
	(BASE_REG_CLASS, REG_OK_FOR_BASE_P, REG_OK_FOR_INDEX_P,
	REGNO_OK_FOR_BASE_STRICT_P, REGNO_OK_FOR_BASE_NONSTRICT_P): Delete
	macros.
	(IREG_POSSIBLE_P, MODE_CODE_BASE_REG_CLASS,
	REGNO_MODE_CODE_OK_FOR_BASE_P): New macros.
	(REGNO_REG_CLASS): ARGP is in PREGS.
	* config/bfin/bfin.md (movhi_insn): Allow for addresses containing
	IREGS.
	(zero_extendhisi2, extendhisi2): Likewise; changed to define_and_split
	to deal with those addresses.
	* addresses.h: New file.
	* caller-save.c: Include "addresses.h".
	(init_caller_save): Use new base_reg_class function.
	* rtl-factoring.c: Include "addresses.h".
	(recompute_gain_for_pattern_seq): Use new function ok_for_base_p_1.
	* recog.c: Include "addresses.h".
	(preprocess_constraints): Use new base_reg_class function.
	* regrename.c: Include "addresses.h".
	(scan_rtx_address): Use new regno_ok_for_base_p and base_reg_class
	functions.  Keep track of a new var INDEX_CODE to compute valid
	classes.
	(replace_oldest_value_addr): Likewise.
	(replace_oldest_value_mem): Use base_reg_class.
	* reload.c: Include "addresses.h".
	(REGNO_MODE_OK_FOR_BASE_P, REG_MODE_OK_FOR_BASE_P): Delete macros.
	(find_reloads): Use new base_reg_class function.
	(find_reloads_address): Likewise; also use regno_ok_for_base_p.
	(find_reloads_address_1): Likewise. New args OUTER_CODE and INDEX_CODE;
	all callers and prototype changed.
	* reload1.c: Include "addresses.h".
	(maybe_fix_stack_asms): Use base_reg_class.
	* regclass.c: Include "addresses.h".
	(ok_for_index_p_nonstrict, ok_for_base_p_nonstrict): New functions.
	(init_reg_autoinc): Use new base_reg_class function.
	(record_reg_classes): Likewise.
	(record_address_regs): Delete arg CLASS; add args CONTEXT, MODE,
	OUTER_CODE and INDEX_CODE.  All callers and prototype changed.
	Use new args to compute necessary class.

	* Makefile.in (regclass.o, reload.o, reload1.o, caller-save.o, recog.o,
	regrename.o, rtl-factoring.o): Update dependencies.
	* doc/tm.texi (MODE_CODE_BASE_REG_CLASS): Document.
	(REGNO_MODE_CODE_OK_FOR_BASE_P): Likewise.
	(REG_OK_FOR_BASE_P, REG_MODE_OK_FOR_BASE_P, REG_MODE_OK_FOR_REG_BASE_P,
	REG_OK_FOR_INDEX_P): Delete documentation.

From-SVN: r112248

1 files changed, 134 insertions, 95 deletions

diff --git a/gcc/reload.c b/gcc/reload.c
index 31d79ae..9bfb748 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -100,6 +100,7 @@ a register with any other reload.  */
 #include "recog.h"
 #include "reload.h"
 #include "regs.h"
+#include "addresses.h"
 #include "hard-reg-set.h"
 #include "flags.h"
 #include "real.h"
@@ -269,7 +270,8 @@ static int find_reloads_address (enum machine_mode, rtx *, rtx, rtx *,
 static rtx subst_reg_equivs (rtx, rtx);
 static rtx subst_indexed_address (rtx);
 static void update_auto_inc_notes (rtx, int, int);
-static int find_reloads_address_1 (enum machine_mode, rtx, int, rtx *,
+static int find_reloads_address_1 (enum machine_mode, rtx, int,
+				   enum rtx_code, enum rtx_code, rtx *,
 				   int, enum reload_type,int, rtx);
 static void find_reloads_address_part (rtx, rtx *, enum reg_class,
 				       enum machine_mode, int,
@@ -3119,7 +3121,8 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
 	      case 'p':
 		/* All necessary reloads for an address_operand
 		   were handled in find_reloads_address.  */
-		this_alternative[i] = (int) MODE_BASE_REG_CLASS (VOIDmode);
+		this_alternative[i]
+		  = (int) base_reg_class (VOIDmode, ADDRESS, SCRATCH);
 		win = 1;
 		badop = 0;
 		break;
@@ -3323,7 +3326,8 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
 
 			/* If we didn't already win, we can reload
 			   the address into a base register.  */
-			this_alternative[i] = (int) MODE_BASE_REG_CLASS (VOIDmode);
+			this_alternative[i]
+			  = (int) base_reg_class (VOIDmode, ADDRESS, SCRATCH);
 			badop = 0;
 			break;
 		      }
@@ -3826,7 +3830,7 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
 	    operand_reloadnum[i]
 	      = push_reload (XEXP (recog_data.operand[i], 0), NULL_RTX,
 			     &XEXP (recog_data.operand[i], 0), (rtx*) 0,
-			     MODE_BASE_REG_CLASS (VOIDmode),
+			     base_reg_class (VOIDmode, MEM, SCRATCH),
 			     GET_MODE (XEXP (recog_data.operand[i], 0)),
 			     VOIDmode, 0, 0, i, RELOAD_FOR_INPUT);
 	    rld[operand_reloadnum[i]].inc
@@ -4745,12 +4749,12 @@ find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
 	 subject of a CLOBBER in this insn.  */
 
       else if (regno < FIRST_PSEUDO_REGISTER
-	       && REGNO_MODE_OK_FOR_BASE_P (regno, mode)
+	       && regno_ok_for_base_p (regno, mode, MEM, SCRATCH)
 	       && ! regno_clobbered_p (regno, this_insn, mode, 0))
 	return 0;
 
       /* If we do not have one of the cases above, we must do the reload.  */
-      push_reload (ad, NULL_RTX, loc, (rtx*) 0, MODE_BASE_REG_CLASS (mode),
+      push_reload (ad, NULL_RTX, loc, (rtx*) 0, base_reg_class (mode, MEM, SCRATCH),
 		   GET_MODE (ad), VOIDmode, 0, 0, opnum, type);
       return 1;
     }
@@ -4851,7 +4855,7 @@ find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
 	  /* Must use TEM here, not AD, since it is the one that will
 	     have any subexpressions reloaded, if needed.  */
 	  push_reload (tem, NULL_RTX, loc, (rtx*) 0,
-		       MODE_BASE_REG_CLASS (mode), GET_MODE (tem),
+		       base_reg_class (mode, MEM, SCRATCH), GET_MODE (tem),
 		       VOIDmode, 0,
 		       0, opnum, type);
 	  return ! removed_and;
@@ -4868,8 +4872,10 @@ find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
   else if (GET_CODE (ad) == PLUS
 	   && REG_P (XEXP (ad, 0))
 	   && REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER
-	   && REG_MODE_OK_FOR_BASE_P (XEXP (ad, 0), mode)
-	   && GET_CODE (XEXP (ad, 1)) == CONST_INT)
+	   && GET_CODE (XEXP (ad, 1)) == CONST_INT
+	   && regno_ok_for_base_p (REGNO (XEXP (ad, 0)), mode, PLUS,
+				   CONST_INT))
+
     {
       /* Unshare the MEM rtx so we can safely alter it.  */
       if (memrefloc)
@@ -4897,7 +4903,8 @@ find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
 	  /* If the sum of two regs is not necessarily valid,
 	     reload the sum into a base reg.
 	     That will at least work.  */
-	  find_reloads_address_part (ad, loc, MODE_BASE_REG_CLASS (mode),
+	  find_reloads_address_part (ad, loc,
+				     base_reg_class (mode, MEM, SCRATCH),
 				     Pmode, opnum, type, ind_levels);
 	}
       return ! removed_and;
@@ -4931,19 +4938,26 @@ find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
 
   for (op_index = 0; op_index < 2; ++op_index)
     {
-      rtx operand;
+      rtx operand, addend;
+      enum rtx_code inner_code;
+
+      if (GET_CODE (ad) != PLUS)
+	  continue;
 
+      inner_code = GET_CODE (XEXP (ad, 0));
       if (!(GET_CODE (ad) == PLUS 
 	    && GET_CODE (XEXP (ad, 1)) == CONST_INT
-	    && (GET_CODE (XEXP (ad, 0)) == PLUS
-		|| GET_CODE (XEXP (ad, 0)) == LO_SUM)))
+	    && (inner_code == PLUS || inner_code == LO_SUM)))
 	continue;
 
       operand = XEXP (XEXP (ad, 0), op_index);
       if (!REG_P (operand) || REGNO (operand) >= FIRST_PSEUDO_REGISTER)
 	continue;
 
-      if ((REG_MODE_OK_FOR_BASE_P (operand, mode)
+      addend = XEXP (XEXP (ad, 0), 1 - op_index);
+
+      if ((regno_ok_for_base_p (REGNO (operand), mode, inner_code,
+				GET_CODE (addend))
 	   || operand == frame_pointer_rtx
 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 	   || operand == hard_frame_pointer_rtx
@@ -4956,11 +4970,10 @@ find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
 				       &XEXP (XEXP (ad, 0), 1 - op_index)))
 	{
 	  rtx offset_reg;
-	  rtx addend;
+	  enum reg_class cls;
 
 	  offset_reg = plus_constant (operand, INTVAL (XEXP (ad, 1)));
-	  addend = XEXP (XEXP (ad, 0), 1 - op_index);
-	  
+
 	  /* Form the adjusted address.  */
 	  if (GET_CODE (XEXP (ad, 0)) == PLUS)
 	    ad = gen_rtx_PLUS (GET_MODE (ad), 
@@ -4972,12 +4985,13 @@ find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
 				 op_index == 0 ? addend : offset_reg);
 	  *loc = ad;
 
+	  cls = base_reg_class (mode, MEM, GET_CODE (addend));
 	  find_reloads_address_part (XEXP (ad, op_index), 
-				     &XEXP (ad, op_index),
-				     MODE_BASE_REG_CLASS (mode),
+				     &XEXP (ad, op_index), cls,
 				     GET_MODE (ad), opnum, type, ind_levels);
-	  find_reloads_address_1 (mode, 
-				  XEXP (ad, 1 - op_index), 1, 
+	  find_reloads_address_1 (mode,
+				  XEXP (ad, 1 - op_index), 1, GET_CODE (ad),
+				  GET_CODE (XEXP (ad, op_index)),
 				  &XEXP (ad, 1 - op_index), opnum,
 				  type, 0, insn);
 
@@ -5023,13 +5037,13 @@ find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
 	    loc = &XEXP (*loc, 0);
 	}
 
-      find_reloads_address_part (ad, loc, MODE_BASE_REG_CLASS (mode),
+      find_reloads_address_part (ad, loc, base_reg_class (mode, MEM, SCRATCH),
 				 Pmode, opnum, type, ind_levels);
       return ! removed_and;
     }
 
-  return find_reloads_address_1 (mode, ad, 0, loc, opnum, type, ind_levels,
-				 insn);
+  return find_reloads_address_1 (mode, ad, 0, MEM, SCRATCH, loc, opnum, type,
+				 ind_levels, insn);
 }
 
 /* Find all pseudo regs appearing in AD
@@ -5240,9 +5254,12 @@ update_auto_inc_notes (rtx insn ATTRIBUTE_UNUSED, int regno ATTRIBUTE_UNUSED,
    is strictly valid.)
 
    CONTEXT = 1 means we are considering regs as index regs,
-   = 0 means we are considering them as base regs, = 2 means we
-   are considering them as base regs for REG + REG.
-
+   = 0 means we are considering them as base regs.
+   OUTER_CODE is the code of the enclosing RTX, typically a MEM, a PLUS,
+   or an autoinc code.
+   If CONTEXT == 0 and OUTER_CODE is a PLUS or LO_SUM, then INDEX_CODE
+   is the code of the index part of the address.  Otherwise, pass SCRATCH
+   for this argument.
    OPNUM and TYPE specify the purpose of any reloads made.
 
    IND_LEVELS says how many levels of indirect addressing are
@@ -5263,25 +5280,22 @@ update_auto_inc_notes (rtx insn ATTRIBUTE_UNUSED, int regno ATTRIBUTE_UNUSED,
 
 static int
 find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
+			enum rtx_code outer_code, enum rtx_code index_code,
 			rtx *loc, int opnum, enum reload_type type,
 			int ind_levels, rtx insn)
 {
-#define REG_OK_FOR_CONTEXT(CONTEXT, REGNO, MODE)		\
-  ((CONTEXT) == 2					\
-   ? REGNO_MODE_OK_FOR_REG_BASE_P (REGNO, MODE)		\
-   : (CONTEXT) == 1					\
-   ? REGNO_OK_FOR_INDEX_P (REGNO)			\
-   : REGNO_MODE_OK_FOR_BASE_P (REGNO, MODE))
+#define REG_OK_FOR_CONTEXT(CONTEXT, REGNO, MODE, OUTER, INDEX)		\
+  ((CONTEXT) == 0							\
+   ? regno_ok_for_base_p (REGNO, MODE, OUTER, INDEX)			\
+   : REGNO_OK_FOR_INDEX_P (REGNO))					
 
   enum reg_class context_reg_class;
   RTX_CODE code = GET_CODE (x);
 
-  if (context == 2)
-    context_reg_class = MODE_BASE_REG_REG_CLASS (mode);
-  else if (context == 1)
+  if (context == 1)
     context_reg_class = INDEX_REG_CLASS;
   else
-    context_reg_class = MODE_BASE_REG_CLASS (mode);
+    context_reg_class = base_reg_class (mode, outer_code, index_code);
 
   switch (code)
     {
@@ -5338,74 +5352,90 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
 	if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
 	    || code0 == ZERO_EXTEND || code1 == MEM)
 	  {
-	    find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
-				    type, ind_levels, insn);
-	    find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
-				    type, ind_levels, insn);
+	    find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
+				    &XEXP (x, 0), opnum, type, ind_levels,
+				    insn);
+	    find_reloads_address_1 (mode, orig_op1, 0, PLUS, code0,
+				    &XEXP (x, 1), opnum, type, ind_levels,
+				    insn);
 	  }
 
 	else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
 		 || code1 == ZERO_EXTEND || code0 == MEM)
 	  {
-	    find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
-				    type, ind_levels, insn);
-	    find_reloads_address_1 (mode, orig_op1, 1, &XEXP (x, 1), opnum,
-				    type, ind_levels, insn);
+	    find_reloads_address_1 (mode, orig_op0, 0, PLUS, code1,
+				    &XEXP (x, 0), opnum, type, ind_levels,
+				    insn);
+	    find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
+				    &XEXP (x, 1), opnum, type, ind_levels,
+				    insn);
 	  }
 
 	else if (code0 == CONST_INT || code0 == CONST
 		 || code0 == SYMBOL_REF || code0 == LABEL_REF)
-	  find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
-				  type, ind_levels, insn);
+	  find_reloads_address_1 (mode, orig_op1, 0, PLUS, code0,
+				  &XEXP (x, 1), opnum, type, ind_levels,
+				  insn);
 
 	else if (code1 == CONST_INT || code1 == CONST
 		 || code1 == SYMBOL_REF || code1 == LABEL_REF)
-	  find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
-				  type, ind_levels, insn);
+	  find_reloads_address_1 (mode, orig_op0, 0, PLUS, code1,
+				  &XEXP (x, 0), opnum, type, ind_levels,
+				  insn);
 
 	else if (code0 == REG && code1 == REG)
 	  {
-	    if (REG_OK_FOR_INDEX_P (op0)
-		&& REG_MODE_OK_FOR_REG_BASE_P (op1, mode))
+	    if (REGNO_OK_FOR_INDEX_P (REGNO (op0))
+		&& regno_ok_for_base_p (REGNO (op1), mode, PLUS, REG))
 	      return 0;
-	    else if (REG_OK_FOR_INDEX_P (op1)
-		     && REG_MODE_OK_FOR_REG_BASE_P (op0, mode))
+	    else if (REGNO_OK_FOR_INDEX_P (REGNO (op1))
+		     && regno_ok_for_base_p (REGNO (op0), mode, PLUS, REG))
 	      return 0;
-	    else if (REG_MODE_OK_FOR_REG_BASE_P (op1, mode))
-	      find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
-				      type, ind_levels, insn);
-	    else if (REG_MODE_OK_FOR_REG_BASE_P (op0, mode))
-	      find_reloads_address_1 (mode, orig_op1, 1, &XEXP (x, 1), opnum,
-				      type, ind_levels, insn);
-	    else if (REG_OK_FOR_INDEX_P (op1))
-	      find_reloads_address_1 (mode, orig_op0, 2, &XEXP (x, 0), opnum,
-				      type, ind_levels, insn);
-	    else if (REG_OK_FOR_INDEX_P (op0))
-	      find_reloads_address_1 (mode, orig_op1, 2, &XEXP (x, 1), opnum,
-				      type, ind_levels, insn);
+	    else if (regno_ok_for_base_p (REGNO (op1), mode, PLUS, REG))
+	      find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
+				      &XEXP (x, 0), opnum, type, ind_levels,
+				      insn);
+	    else if (regno_ok_for_base_p (REGNO (op0), mode, PLUS, REG))
+	      find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
+				      &XEXP (x, 1), opnum, type, ind_levels,
+				      insn);
+	    else if (REGNO_OK_FOR_INDEX_P (REGNO (op1)))
+	      find_reloads_address_1 (mode, orig_op0, 0, PLUS, REG,
+				      &XEXP (x, 0), opnum, type, ind_levels,
+				      insn);
+	    else if (REGNO_OK_FOR_INDEX_P (REGNO (op0)))
+	      find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
+				      &XEXP (x, 1), opnum, type, ind_levels,
+				      insn);
 	    else
 	      {
-		find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
-					type, ind_levels, insn);
-		find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
-					type, ind_levels, insn);
+		find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
+					&XEXP (x, 0), opnum, type, ind_levels,
+					insn);
+		find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
+					&XEXP (x, 1), opnum, type, ind_levels,
+					insn);
 	      }
 	  }
 
 	else if (code0 == REG)
 	  {
-	    find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
-				    type, ind_levels, insn);
-	    find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
-				    type, ind_levels, insn);
+	    find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
+				    &XEXP (x, 0), opnum, type, ind_levels,
+				    insn);
+	    find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
+				    &XEXP (x, 1), opnum, type, ind_levels,
+				    insn);
 	  }
 
 	else if (code1 == REG)
 	  {
-	    find_reloads_address_1 (mode, orig_op1, 1, &XEXP (x, 1), opnum,
-				    type, ind_levels, insn);
-	    find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
-				    type, ind_levels, insn);
+	    find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
+				    &XEXP (x, 1), opnum, type, ind_levels,
+				    insn);
+	    find_reloads_address_1 (mode, orig_op0, 0, PLUS, REG,
+				    &XEXP (x, 0), opnum, type, ind_levels,
+				    insn);
 	  }
       }
 
@@ -5416,6 +5446,7 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
       {
 	rtx op0 = XEXP (x, 0);
 	rtx op1 = XEXP (x, 1);
+	enum rtx_code index_code;
 	int regno;
 	int reloadnum;
 
@@ -5434,12 +5465,14 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
 	   register with its equivalent constant where applicable.  */
 	if (REG_P (XEXP (op1, 1)))
 	  if (!REGNO_OK_FOR_INDEX_P (REGNO (XEXP (op1, 1))))
-	    find_reloads_address_1 (mode, XEXP (op1, 1), 1, &XEXP (op1, 1),
-				    opnum, type, ind_levels, insn);
+	    find_reloads_address_1 (mode, XEXP (op1, 1), 1, code, SCRATCH,
+				    &XEXP (op1, 1), opnum, type, ind_levels,
+				    insn);
 
 	gcc_assert (REG_P (XEXP (op1, 0)));
 
 	regno = REGNO (XEXP (op1, 0));
+	index_code = GET_CODE (XEXP (op1, 1));
 
 	/* A register that is incremented cannot be constant!  */
 	gcc_assert (regno < FIRST_PSEUDO_REGISTER
@@ -5466,12 +5499,13 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
 				      ind_levels, insn);
 
 		/* Then reload the memory location into a base
-		    register.  */
+		   register.  */
 		reloadnum = push_reload (tem, tem, &XEXP (x, 0),
-					  &XEXP (op1, 0),
-					  MODE_BASE_REG_CLASS (mode),
-					  GET_MODE (x), GET_MODE (x), 0,
-					  0, opnum, RELOAD_OTHER);
+					 &XEXP (op1, 0),
+					 base_reg_class (mode, code,
+							 index_code),
+					 GET_MODE (x), GET_MODE (x), 0,
+					 0, opnum, RELOAD_OTHER);
 
 		update_auto_inc_notes (this_insn, regno, reloadnum);
 		return 0;
@@ -5482,13 +5516,13 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
 	  regno = reg_renumber[regno];
 
 	/* We require a base register here...  */
-	if (!REGNO_MODE_OK_FOR_BASE_P (regno, GET_MODE (x)))
+	if (!regno_ok_for_base_p (regno, GET_MODE (x), code, index_code))
 	  {
 	    reloadnum = push_reload (XEXP (op1, 0), XEXP (x, 0),
-				      &XEXP (op1, 0), &XEXP (x, 0),
-				      MODE_BASE_REG_CLASS (mode),
-				      GET_MODE (x), GET_MODE (x), 0, 0,
-				      opnum, RELOAD_OTHER);
+				     &XEXP (op1, 0), &XEXP (x, 0),
+				     base_reg_class (mode, code, index_code),
+				     GET_MODE (x), GET_MODE (x), 0, 0,
+				     opnum, RELOAD_OTHER);
 
 	    update_auto_inc_notes (this_insn, regno, reloadnum);
 	    return 0;
@@ -5546,7 +5580,8 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
 	  if (reg_renumber[regno] >= 0)
 	    regno = reg_renumber[regno];
 	  if (regno >= FIRST_PSEUDO_REGISTER
-	      || !REG_OK_FOR_CONTEXT (context, regno, mode))
+	      || !REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
+				      index_code))
 	    {
 	      int reloadnum;
 
@@ -5654,7 +5689,7 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
 	 (or perhaps even a different part of an outer expression), should
 	 define LEGITIMIZE_RELOAD_ADDRESS.  */
       find_reloads_address_1 (GET_MODE (XEXP (x, 0)), XEXP (x, 0),
-			      context, &XEXP (x, 0), opnum,
+			      context, code, SCRATCH, &XEXP (x, 0), opnum,
 			      type, ind_levels, insn);
       push_reload (x, NULL_RTX, loc, (rtx*) 0,
 		   context_reg_class,
@@ -5722,7 +5757,8 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
 	  regno = reg_renumber[regno];
 
 	if (regno >= FIRST_PSEUDO_REGISTER
-	    || !REG_OK_FOR_CONTEXT (context, regno, mode))
+	    || !REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
+				    index_code))
 	  {
 	    push_reload (x, NULL_RTX, loc, (rtx*) 0,
 			 context_reg_class,
@@ -5754,7 +5790,8 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
 	    {
 	      int regno ATTRIBUTE_UNUSED = subreg_regno (x);
 
-	      if (! REG_OK_FOR_CONTEXT (context, regno, mode))
+	      if (!REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
+				       index_code))
 		{
 		  push_reload (x, NULL_RTX, loc, (rtx*) 0,
 			       context_reg_class,
@@ -5792,8 +5829,10 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
       {
 	if (fmt[i] == 'e')
-	  find_reloads_address_1 (mode, XEXP (x, i), context, &XEXP (x, i),
-				  opnum, type, ind_levels, insn);
+	  /* Pass SCRATCH for INDEX_CODE, since CODE can never be a PLUS once
+	     we get here.  */
+	  find_reloads_address_1 (mode, XEXP (x, i), context, code, SCRATCH,
+				  &XEXP (x, i), opnum, type, ind_levels, insn);
       }
   }