diff mbox

[middle-end] Add machine_mode to address_cost target hook

Message ID 1346287598.2407.90.camel@yam-132-YW-E178-FTW
State New
Headers show

Commit Message

Oleg Endo Aug. 30, 2012, 12:46 a.m. UTC 
Hello,

While experimenting a little bit with an idea for an address mode
selection RTL pass for SH, I realized that SH's sh_address_cost function
is quite broken.  When trying to fix it, I ran against a wall, since the
mode of the MEM is not passed to the target hook function, as it is e.g.
in legitimate_address.  This circumstance makes it a bit difficult to
return useful answers in the address_cost hook.  Like on SH,
displacement address modes for anything < SImode are considered slightly
more expensive due to increased pressure on R0.

Since everything in the middle-end already seems to pass the mode to the
'address_cost' function in rtlanal.c, I'd like to propose to forward the
mode arg to the target hook.  The change is quite obvious, as it only
adds one new (mostly) unused argument to the various address_cost
functions in the targets.

I went through all the targets' code and fixed the hook function.  It
seems some other targets than SH could also benefit from the mode wisdom
in their address_cost estimation.

There are a few peculiarities I ran across (respective target
maintainers CC'ed):

mn10300
  The function mn10300_address_cost calls itself recursively, so I added
  a GET_MODE (x).  However, it never looks at the mode, so there should 
  be no problem.

iq2000:
  Similar to mn10300.  Mode arg is passed to itself, but effectively 
  never used.  Should be no problem.

rs6000:
  I've added the mode to the logging message.  I hope this is OK.

epiphany:
  There's probably no need for the offset alignment workaround anymore.

arm:
  In the function 'thumb1_size_rtx_costs' the 'case MEM' looks wrong.
  I guess it is meant to look at XEXP (x, 0) when checking for 
  SYMBOL_REF?  As it stands now, it seems that GET_CODE (x) == 
  SYMBOL_REF will never be true, because GET_CODE (x) == MEM.

microblaze:
  The microblaze_address_cost takes the mode of the address rtx.
  Maybe it is meant to take the mode of the MEM?


I've checked the patch only on my SH xgcc config with 'make all-gcc',
but others should build fine since there are no functional changes.  I
hope I didn't miss anything.

Feedback appreciated!

Cheers,
Oleg


ChangeLog:

	* hooks.c (hook_int_rtx_mode_bool_0): New function.
	* hooks.h (hook_int_rtx_mode_bool_0): Declare it.
	* output.h (default_address_cost): Add machine_mode 
	argument.
	* target.def (address_cost): Likewise.
	* rtlanal.c (address_cost): Pass mode to target hook.
	(default_address_cost): Add machine_mode argument.
	* doc/tm.texi: Regenerate.
	* config/alpha/alpha.c (TARGET_ADDRESS_COST): Use 
	hook_int_rtx_mode_bool_0 instead of hook_int_rtx_bool_0.
	* config/arm/arm.c (arm_address_cost): Add machine_mode 
	argument.
	* config/avr/avr.c (avr_address_cost): Likewise.
	* config/bfin/bfin.c (bfin_address_cost): Likewise.
	* config/cr16/cr16.c (cr16_address_cost): Likewise.
	* config/cris/cris.c (cris_address_cost): Likewise.
	* config/epiphany/epiphany.c (epiphany_address_cost): Likewise.
	* config/i386/i386.c (ix86_address_cost): Likewise.
	* config/ia64/ia64.c (TARGET_ADDRESS_COST): Use 
	hook_int_rtx_mode_bool_0 instead of hook_int_rtx_bool_0.
	* config/iq2000/iq2000.c (iq2000_address_cost): Add 
	machine_mode argument.  Pass it on in recursive invocation.
	* config/lm32/lm32.c (TARGET_ADDRESS_COST): Use 
	hook_int_rtx_mode_bool_0 instead of hook_int_rtx_bool_0.
	* config/m32c/m32c.c (m32c_address_cost): Add machine_mode 
	argument.
	* config/m32r/m32r.c (TARGET_ADDRESS_COST): Use 
	hook_int_rtx_mode_bool_0 instead of hook_int_rtx_bool_0.
	* config/mcore/mcore.c (TARGET_ADDRESS_COST): Likewise.
	* config/mep/mep.c (mep_address_cost): Add machine_mode 
	argument.
	* config/microblaze/microblaze.c (microblaze_address_cost): 
	Likewise.
	* config/mips/mips.c (mips_address_cost): Likewise.
	* config/mmix/mmix.c (TARGET_ADDRESS_COST): Use 
	hook_int_rtx_mode_bool_0 instead of hook_int_rtx_bool_0.
	* config/mn10300/mn10300.c (mn10300_address_cost): Add
	machine_mode argument.  Use GET_MODE (x) in recursive 
	invocation.
	* config/pa/pa.c (hppa_address_cost): Add machine_mode argument.
	* config/rs6000/rs6000.c (rs6000_debug_address_cost): Add
	machine_mode argument and print it.
	(TARGET_ADDRESS_COST): Use hook_int_rtx_mode_bool_0 instead of
	hook_int_rtx_bool_0.
	* config/rx/rx.c (rx_address_cost): Add machine_mode argument.
	* config/s390/s390.c (s390_address_cost): Likewise.
	* config/score/score-protos.h (score_address_cost): Likewise.
	* config/score/score.c (score_address_cost): Likewise.
	* config/sh/sh.c (sh_address_cost): Likewise.
	* config/sparc/sparc.c (TARGET_ADDRESS_COST): Use 
	hook_int_rtx_mode_bool_0 instead of hook_int_rtx_bool_0.
	* config/spu/spu.c (TARGET_ADDRESS_COST): Likewise.
	* config/stormy16/stormy16.c (xstormy16_address_cost): Add 
	machine_mode argument.
	* config/v850/v850.c (TARGET_ADDRESS_COST): Use 
	hook_int_rtx_mode_bool_0 instead of hook_int_rtx_bool_0.
	* config/vax/vax.c (vax_address_cost): Add machine_mode 
	argument.
	* config/xtensa/xtensa (TARGET_ADDRESS_COST): Use 
	hook_int_rtx_mode_bool_0 instead of hook_int_rtx_bool_0.

Comments

Michael Eager Aug. 30, 2012, 4:25 p.m. UTC | #1 
On 08/29/2012 05:46 PM, Oleg Endo wrote:
> Hello,
>
> While experimenting a little bit with an idea for an address mode
> selection RTL pass for SH, I realized that SH's sh_address_cost function
> is quite broken.  When trying to fix it, I ran against a wall, since the
> mode of the MEM is not passed to the target hook function, as it is e.g.
> in legitimate_address.  This circumstance makes it a bit difficult to
> return useful answers in the address_cost hook.  Like on SH,
> displacement address modes for anything < SImode are considered slightly
> more expensive due to increased pressure on R0.
>
> Since everything in the middle-end already seems to pass the mode to the
> 'address_cost' function in rtlanal.c, I'd like to propose to forward the
> mode arg to the target hook.  The change is quite obvious, as it only
> adds one new (mostly) unused argument to the various address_cost
> functions in the targets.
>
> I went through all the targets' code and fixed the hook function.  It
> seems some other targets than SH could also benefit from the mode wisdom
> in their address_cost estimation.
>
> There are a few peculiarities I ran across (respective target
> maintainers CC'ed):


> microblaze:
>    The microblaze_address_cost takes the mode of the address rtx.
>    Maybe it is meant to take the mode of the MEM?

The address cost calculation looks OK.  I'm not sure why the mode of
MEM is relevant to this computation.

No objections to the patch.
Alexandre Oliva Aug. 31, 2012, 9:52 p.m. UTC | #2 
On Aug 29, 2012, Oleg Endo <oleg.endo@t-online.de> wrote:

> 	* config/mn10300/mn10300.c (mn10300_address_cost): Add
> 	machine_mode argument.  Use GET_MODE (x) in recursive 
> 	invocation.
> 	* config/sh/sh.c (sh_address_cost): Likewise.

These are ok, thanks.
Richard Sandiford Sept. 1, 2012, 9:10 a.m. UTC | #3 
Oleg Endo <oleg.endo@t-online.de> writes:
> While experimenting a little bit with an idea for an address mode
> selection RTL pass for SH, I realized that SH's sh_address_cost function
> is quite broken.  When trying to fix it, I ran against a wall, since the
> mode of the MEM is not passed to the target hook function, as it is e.g.
> in legitimate_address.  This circumstance makes it a bit difficult to
> return useful answers in the address_cost hook.  Like on SH,
> displacement address modes for anything < SImode are considered slightly
> more expensive due to increased pressure on R0.
>
> Since everything in the middle-end already seems to pass the mode to the
> 'address_cost' function in rtlanal.c, I'd like to propose to forward the
> mode arg to the target hook.  The change is quite obvious, as it only
> adds one new (mostly) unused argument to the various address_cost
> functions in the targets.

Thanks for doing this.  We should perhaps add the address space too,
but if you don't feel like redoing the whole patch, that can wait until
someone wants it.

>  /* If the target doesn't override, compute the cost as with arithmetic.  */
>  
>  int
> -default_address_cost (rtx x, bool speed)
> +default_address_cost (rtx x, enum machine_mode mode, bool speed)
>  {
>    return rtx_cost (x, MEM, 0, speed);
>  }

Remove the "mode" parameter name because it's unused.  I think this
would trigger a warning otherwise.

OK for the target-independent bits otherwise.  For MIPS:

> Index: gcc/config/mips/mips.c
> ===================================================================
> --- gcc/config/mips/mips.c	(revision 190780)
> +++ gcc/config/mips/mips.c	(working copy)
> @@ -3943,7 +3943,8 @@
>  /* Implement TARGET_ADDRESS_COST.  */
>  
>  static int
> -mips_address_cost (rtx addr, bool speed ATTRIBUTE_UNUSED)
> +mips_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
> +		   bool speed ATTRIBUTE_UNUSED)
>  {
>    return mips_address_insns (addr, SImode, false);

Please change this to:

static int
mips_address_cost (rtx addr, enum machine_mode mode,
		   bool speed ATTRIBUTE_UNUSED)
{
  return mips_address_insns (addr, mode, false);
}

MIPS is one of those targets that wanted to know the mode all along.

Richard
diff mbox

Patch

Index: gcc/output.h
===================================================================
--- gcc/output.h	(revision 190780)
+++ gcc/output.h	(working copy)
@@ -606,7 +606,7 @@ 
 extern void default_elf_fini_array_asm_out_destructor (rtx, int);
 extern int maybe_assemble_visibility (tree);
 
-extern int default_address_cost (rtx, bool);
+extern int default_address_cost (rtx, enum machine_mode, bool);
 
 /* Output stack usage information.  */
 extern void output_stack_usage (void);
Index: gcc/hooks.c
===================================================================
--- gcc/hooks.c	(revision 190780)
+++ gcc/hooks.c	(working copy)
@@ -200,6 +200,14 @@ 
   return 0;
 }
 
+int
+hook_int_rtx_mode_bool_0 (rtx a ATTRIBUTE_UNUSED,
+			  enum machine_mode b ATTRIBUTE_UNUSED,
+			  bool c ATTRIBUTE_UNUSED)
+{
+  return 0;
+}
+
 unsigned int
 hook_uint_void_0 (void)
 {
Index: gcc/hooks.h
===================================================================
--- gcc/hooks.h	(revision 190780)
+++ gcc/hooks.h	(working copy)
@@ -74,6 +74,7 @@ 
 extern int hook_int_const_tree_const_tree_1 (const_tree, const_tree);
 extern int hook_int_rtx_0 (rtx);
 extern int hook_int_rtx_bool_0 (rtx, bool);
+extern int hook_int_rtx_mode_bool_0 (rtx, enum machine_mode, bool);
 
 extern tree hook_tree_const_tree_null (const_tree);
 
Index: gcc/doc/tm.texi
===================================================================
--- gcc/doc/tm.texi	(revision 190780)
+++ gcc/doc/tm.texi	(working copy)
@@ -6440,7 +6440,7 @@ 
 processed, and false when @code{rtx_cost} should recurse.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_ADDRESS_COST (rtx @var{address}, bool @var{speed})
+@deftypefn {Target Hook} int TARGET_ADDRESS_COST (rtx @var{address}, enum machine_mode @var{mode}, bool @var{speed})
 This hook computes the cost of an addressing mode that contains
 @var{address}.  If not defined, the cost is computed from
 the @var{address} expression and the @code{TARGET_RTX_COST} hook.
Index: gcc/rtlanal.c
===================================================================
--- gcc/rtlanal.c	(revision 190780)
+++ gcc/rtlanal.c	(working copy)
@@ -3820,13 +3820,13 @@ 
   if (!memory_address_addr_space_p (mode, x, as))
     return 1000;
 
-  return targetm.address_cost (x, speed);
+  return targetm.address_cost (x, mode, speed);
 }
 
 /* If the target doesn't override, compute the cost as with arithmetic.  */
 
 int
-default_address_cost (rtx x, bool speed)
+default_address_cost (rtx x, enum machine_mode mode, bool speed)
 {
   return rtx_cost (x, MEM, 0, speed);
 }
Index: gcc/config/alpha/alpha.c
===================================================================
--- gcc/config/alpha/alpha.c	(revision 190780)
+++ gcc/config/alpha/alpha.c	(working copy)
@@ -9795,7 +9795,7 @@ 
 #undef TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS alpha_rtx_costs
 #undef TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_bool_0
 
 #undef TARGET_MACHINE_DEPENDENT_REORG
 #define TARGET_MACHINE_DEPENDENT_REORG alpha_reorg
Index: gcc/config/avr/avr.c
===================================================================
--- gcc/config/avr/avr.c	(revision 190780)
+++ gcc/config/avr/avr.c	(working copy)
@@ -8886,7 +8886,8 @@ 
 /* Implement `TARGET_ADDRESS_COST'.  */
 
 static int
-avr_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
+avr_address_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
+		  bool speed ATTRIBUTE_UNUSED)
 {
   int cost = 4;
   
Index: gcc/config/sparc/sparc.c
===================================================================
--- gcc/config/sparc/sparc.c	(revision 190780)
+++ gcc/config/sparc/sparc.c	(working copy)
@@ -689,7 +689,7 @@ 
 #undef TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS sparc_rtx_costs
 #undef TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_bool_0
 #undef TARGET_REGISTER_MOVE_COST
 #define TARGET_REGISTER_MOVE_COST sparc_register_move_cost
 
Index: gcc/config/iq2000/iq2000.c
===================================================================
--- gcc/config/iq2000/iq2000.c	(revision 190780)
+++ gcc/config/iq2000/iq2000.c	(working copy)
@@ -152,7 +152,7 @@ 
 					   enum machine_mode, tree, int *,
 					   int);
 static bool iq2000_rtx_costs          (rtx, int, int, int, int *, bool);
-static int  iq2000_address_cost       (rtx, bool);
+static int  iq2000_address_cost       (rtx, enum machine_mode, bool);
 static section *iq2000_select_section (tree, int, unsigned HOST_WIDE_INT);
 static rtx  iq2000_legitimize_address (rtx, rtx, enum machine_mode);
 static bool iq2000_pass_by_reference  (cumulative_args_t, enum machine_mode,
@@ -779,7 +779,7 @@ 
 /* Provide the costs of an addressing mode that contains ADDR.  */
 
 static int
-iq2000_address_cost (rtx addr, bool speed)
+iq2000_address_cost (rtx addr, enum machine_mode mode, bool speed)
 {
   switch (GET_CODE (addr))
     {
@@ -830,7 +830,7 @@ 
 	  case LABEL_REF:
 	  case HIGH:
 	  case LO_SUM:
-	    return iq2000_address_cost (plus1, speed) + 1;
+	    return iq2000_address_cost (plus1, mode, speed) + 1;
 
 	  default:
 	    break;
Index: gcc/config/stormy16/stormy16.c
===================================================================
--- gcc/config/stormy16/stormy16.c	(revision 190780)
+++ gcc/config/stormy16/stormy16.c	(working copy)
@@ -58,7 +58,7 @@ 
 static void xstormy16_init_builtins (void);
 static rtx xstormy16_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
 static bool xstormy16_rtx_costs (rtx, int, int, int, int *, bool);
-static int xstormy16_address_cost (rtx, bool);
+static int xstormy16_address_cost (rtx, enum machine_mode, bool);
 static bool xstormy16_return_in_memory (const_tree, const_tree);
 
 static GTY(()) section *bss100_section;
@@ -103,7 +103,8 @@ 
 }
 
 static int
-xstormy16_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
+xstormy16_address_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
+			bool speed ATTRIBUTE_UNUSED)
 {
   return (CONST_INT_P (x) ? 2
 	  : GET_CODE (x) == PLUS ? 7
Index: gcc/config/mips/mips.c
===================================================================
--- gcc/config/mips/mips.c	(revision 190780)
+++ gcc/config/mips/mips.c	(working copy)
@@ -3943,7 +3943,8 @@ 
 /* Implement TARGET_ADDRESS_COST.  */
 
 static int
-mips_address_cost (rtx addr, bool speed ATTRIBUTE_UNUSED)
+mips_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
+		   bool speed ATTRIBUTE_UNUSED)
 {
   return mips_address_insns (addr, SImode, false);
 }
Index: gcc/config/epiphany/epiphany.c
===================================================================
--- gcc/config/epiphany/epiphany.c	(revision 190780)
+++ gcc/config/epiphany/epiphany.c	(working copy)
@@ -729,7 +729,8 @@ 
    If ADDR is not a valid address, its cost is irrelevant.  */
 
 static int
-epiphany_address_cost (rtx addr, bool speed)
+epiphany_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
+		       bool speed)
 {
   rtx reg;
   rtx off = const0_rtx;
Index: gcc/config/rx/rx.c
===================================================================
--- gcc/config/rx/rx.c	(revision 190780)
+++ gcc/config/rx/rx.c	(working copy)
@@ -2724,7 +2724,7 @@ 
 }
 
 static int
-rx_address_cost (rtx addr, bool speed)
+rx_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED, bool speed)
 {
   rtx a, b;
 
Index: gcc/config/rs6000/rs6000.c
===================================================================
--- gcc/config/rs6000/rs6000.c	(revision 190780)
+++ gcc/config/rs6000/rs6000.c	(working copy)
@@ -928,7 +928,7 @@ 
 static rtx rs6000_emit_set_long_const (rtx, HOST_WIDE_INT, HOST_WIDE_INT);
 static int rs6000_memory_move_cost (enum machine_mode, reg_class_t, bool);
 static bool rs6000_debug_rtx_costs (rtx, int, int, int, int *, bool);
-static int rs6000_debug_address_cost (rtx, bool);
+static int rs6000_debug_address_cost (rtx, enum machine_mode, bool);
 static int rs6000_debug_adjust_cost (rtx, rtx, rtx, int);
 static bool is_microcoded_insn (rtx);
 static bool is_nonpipeline_insn (rtx);
@@ -1294,7 +1294,7 @@ 
 #undef TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS rs6000_rtx_costs
 #undef TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_bool_0
 
 #undef TARGET_DWARF_REGISTER_SPAN
 #define TARGET_DWARF_REGISTER_SPAN rs6000_dwarf_register_span
@@ -26070,12 +26070,13 @@ 
 /* Debug form of ADDRESS_COST that is selected if -mdebug=cost.  */
 
 static int
-rs6000_debug_address_cost (rtx x, bool speed)
+rs6000_debug_address_cost (rtx x, enum machine_mode mode, bool speed)
 {
   int ret = TARGET_ADDRESS_COST (x, speed);
 
-  fprintf (stderr, "\nrs6000_address_cost, return = %d, speed = %s, x:\n",
-	   ret, speed ? "true" : "false");
+  fprintf (stderr,
+	   "\nrs6000_address_cost, return = %d, mode = %s, speed = %s, x:\n",
+	   ret, GET_MODE_NAME (mode), speed ? "true" : "false");
   debug_rtx (x);
 
   return ret;
Index: gcc/config/v850/v850.c
===================================================================
--- gcc/config/v850/v850.c	(revision 190780)
+++ gcc/config/v850/v850.c	(working copy)
@@ -3130,7 +3130,7 @@ 
 #define TARGET_RTX_COSTS v850_rtx_costs
 
 #undef  TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_bool_0
 
 #undef  TARGET_MACHINE_DEPENDENT_REORG
 #define TARGET_MACHINE_DEPENDENT_REORG v850_reorg
Index: gcc/config/mmix/mmix.c
===================================================================
--- gcc/config/mmix/mmix.c	(revision 190780)
+++ gcc/config/mmix/mmix.c	(working copy)
@@ -223,7 +223,7 @@ 
 #undef TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS mmix_rtx_costs
 #undef TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_bool_0
 
 #undef TARGET_REGISTER_MOVE_COST
 #define TARGET_REGISTER_MOVE_COST mmix_register_move_cost
Index: gcc/config/sh/sh.c
===================================================================
--- gcc/config/sh/sh.c	(revision 190780)
+++ gcc/config/sh/sh.c	(working copy)
@@ -248,7 +248,7 @@ 
 static bool unspec_caller_rtx_p (rtx);
 static bool sh_cannot_copy_insn_p (rtx);
 static bool sh_rtx_costs (rtx, int, int, int, int *, bool);
-static int sh_address_cost (rtx, bool);
+static int sh_address_cost (rtx, enum machine_mode, bool);
 static int sh_pr_n_sets (void);
 static rtx sh_allocate_initial_value (rtx);
 static reg_class_t sh_preferred_reload_class (rtx, reg_class_t);
@@ -3368,7 +3368,8 @@ 
 /* Compute the cost of an address.  */
 
 static int
-sh_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
+sh_address_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
+		 bool speed ATTRIBUTE_UNUSED)
 {
   /* 'reg + disp' addressing.  */
   if (satisfies_constraint_Sdd (x))
Index: gcc/config/cr16/cr16.c
===================================================================
--- gcc/config/cr16/cr16.c	(revision 190780)
+++ gcc/config/cr16/cr16.c	(working copy)
@@ -1286,7 +1286,8 @@ 
 
 /* Return cost of the memory address x.  */
 static int
-cr16_address_cost (rtx addr, bool speed ATTRIBUTE_UNUSED)
+cr16_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
+		   bool speed ATTRIBUTE_UNUSED)
 {
   enum cr16_addrtype addrtype;
   struct cr16_address address;
Index: gcc/config/bfin/bfin.c
===================================================================
--- gcc/config/bfin/bfin.c	(revision 190780)
+++ gcc/config/bfin/bfin.c	(working copy)
@@ -1288,7 +1288,9 @@ 
    All addressing modes are equally cheap on the Blackfin.  */
 
 static int
-bfin_address_cost (rtx addr ATTRIBUTE_UNUSED, bool speed ATTRIBUTE_UNUSED)
+bfin_address_cost (rtx addr ATTRIBUTE_UNUSED,
+		   enum machine_mode mode ATTRIBUTE_UNUSED,
+		   bool speed ATTRIBUTE_UNUSED)
 {
   return 1;
 }
Index: gcc/config/microblaze/microblaze.c
===================================================================
--- gcc/config/microblaze/microblaze.c	(revision 190780)
+++ gcc/config/microblaze/microblaze.c	(working copy)
@@ -1043,7 +1043,8 @@ 
 /* Provide the costs of an addressing mode that contains ADDR.
    If ADDR is not a valid address, its cost is irrelevant.  */
 static int
-microblaze_address_cost (rtx addr, bool speed ATTRIBUTE_UNUSED)
+microblaze_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
+			 bool speed ATTRIBUTE_UNUSED)
 {
   return COSTS_N_INSNS (microblaze_address_insns (addr, GET_MODE (addr)));
 }
Index: gcc/config/s390/s390.c
===================================================================
--- gcc/config/s390/s390.c	(revision 190780)
+++ gcc/config/s390/s390.c	(working copy)
@@ -2597,7 +2597,8 @@ 
 /* Return the cost of an address rtx ADDR.  */
 
 static int
-s390_address_cost (rtx addr, bool speed ATTRIBUTE_UNUSED)
+s390_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
+		   bool speed ATTRIBUTE_UNUSED)
 {
   struct s390_address ad;
   if (!s390_decompose_address (addr, &ad))
Index: gcc/config/m32c/m32c.c
===================================================================
--- gcc/config/m32c/m32c.c	(revision 190780)
+++ gcc/config/m32c/m32c.c	(working copy)
@@ -2278,7 +2278,8 @@ 
 #undef TARGET_ADDRESS_COST
 #define TARGET_ADDRESS_COST m32c_address_cost
 static int
-m32c_address_cost (rtx addr, bool speed ATTRIBUTE_UNUSED)
+m32c_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
+		   bool speed ATTRIBUTE_UNUSED)
 {
   int i;
   /*  fprintf(stderr, "\naddress_cost\n");
Index: gcc/config/arm/arm.c
===================================================================
--- gcc/config/arm/arm.c	(revision 190780)
+++ gcc/config/arm/arm.c	(working copy)
@@ -162,7 +162,7 @@ 
 static bool arm_xscale_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
 static bool arm_9e_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
 static bool arm_rtx_costs (rtx, int, int, int, int *, bool);
-static int arm_address_cost (rtx, bool);
+static int arm_address_cost (rtx, enum machine_mode, bool);
 static int arm_register_move_cost (enum machine_mode, reg_class_t, reg_class_t);
 static int arm_memory_move_cost (enum machine_mode, reg_class_t, bool);
 static void arm_init_builtins (void);
@@ -8411,7 +8411,8 @@ 
 }
 
 static int
-arm_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
+arm_address_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
+		  bool speed ATTRIBUTE_UNUSED)
 {
   return TARGET_32BIT ? arm_arm_address_cost (x) : arm_thumb_address_cost (x);
 }
Index: gcc/config/m32r/m32r.c
===================================================================
--- gcc/config/m32r/m32r.c	(revision 190780)
+++ gcc/config/m32r/m32r.c	(working copy)
@@ -161,7 +161,7 @@ 
 #undef  TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS m32r_rtx_costs
 #undef  TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_bool_0
 
 #undef  TARGET_PROMOTE_PROTOTYPES
 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
Index: gcc/config/i386/i386.c
===================================================================
--- gcc/config/i386/i386.c	(revision 190780)
+++ gcc/config/i386/i386.c	(working copy)
@@ -11955,7 +11955,8 @@ 
    requires to two regs - that would mean more pseudos with longer
    lifetimes.  */
 static int
-ix86_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
+ix86_address_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
+		   bool speed ATTRIBUTE_UNUSED)
 {
   struct ix86_address parts;
   int cost = 1;
Index: gcc/config/vax/vax.c
===================================================================
--- gcc/config/vax/vax.c	(revision 190780)
+++ gcc/config/vax/vax.c	(working copy)
@@ -53,7 +53,7 @@ 
 static void vax_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
 				 HOST_WIDE_INT, tree);
 static int vax_address_cost_1 (rtx);
-static int vax_address_cost (rtx, bool);
+static int vax_address_cost (rtx, enum machine_mode, bool);
 static bool vax_rtx_costs (rtx, int, int, int, int *, bool);
 static rtx vax_function_arg (cumulative_args_t, enum machine_mode,
 			     const_tree, bool);
@@ -738,7 +738,8 @@ 
 }
 
 static int
-vax_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
+vax_address_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
+		  bool speed ATTRIBUTE_UNUSED)
 {
   return (1 + (REG_P (x) ? 0 : vax_address_cost_1 (x)));
 }
Index: gcc/config/mcore/mcore.c
===================================================================
--- gcc/config/mcore/mcore.c	(revision 190780)
+++ gcc/config/mcore/mcore.c	(working copy)
@@ -191,7 +191,7 @@ 
 #undef  TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS 		mcore_rtx_costs
 #undef  TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST 		hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST 		hook_int_rtx_mode_bool_0
 #undef  TARGET_MACHINE_DEPENDENT_REORG
 #define TARGET_MACHINE_DEPENDENT_REORG	mcore_reorg
 
Index: gcc/config/score/score.c
===================================================================
--- gcc/config/score/score.c	(revision 190780)
+++ gcc/config/score/score.c	(working copy)
@@ -1232,7 +1232,7 @@ 
 
 /* Implement TARGET_ADDRESS_COST macro.  */
 int
-score_address_cost (rtx addr,
+score_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
 		    bool speed ATTRIBUTE_UNUSED)
 {
   return score_address_insns (addr, SImode);
Index: gcc/config/score/score-protos.h
===================================================================
--- gcc/config/score/score-protos.h	(revision 190780)
+++ gcc/config/score/score-protos.h	(working copy)
@@ -39,7 +39,7 @@ 
 extern bool score_unaligned_load (rtx* ops);
 extern bool score_unaligned_store (rtx* ops);
 extern bool score_block_move (rtx* ops);
-extern int score_address_cost (rtx addr, bool speed);
+extern int score_address_cost (rtx addr, enum machine_mode, bool speed);
 extern int score_address_p (enum machine_mode mode, rtx x, int strict);
 extern int score_reg_class (int regno);
 extern int score_hard_regno_mode_ok (unsigned int, enum machine_mode);
Index: gcc/config/lm32/lm32.c
===================================================================
--- gcc/config/lm32/lm32.c	(revision 190780)
+++ gcc/config/lm32/lm32.c	(working copy)
@@ -86,7 +86,7 @@ 
 #undef TARGET_OPTION_OVERRIDE
 #define TARGET_OPTION_OVERRIDE lm32_option_override
 #undef TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_bool_0
 #undef TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS lm32_rtx_costs
 #undef TARGET_IN_SMALL_DATA_P
Index: gcc/config/mn10300/mn10300.c
===================================================================
--- gcc/config/mn10300/mn10300.c	(revision 190780)
+++ gcc/config/mn10300/mn10300.c	(working copy)
@@ -2142,7 +2142,8 @@ 
    with an address register.  */
 
 static int
-mn10300_address_cost (rtx x, bool speed)
+mn10300_address_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
+		      bool speed)
 {
   HOST_WIDE_INT i;
   rtx base, index;
@@ -2457,7 +2458,7 @@ 
       break;
 
     case MEM:
-      total = mn10300_address_cost (XEXP (x, 0), speed);
+      total = mn10300_address_cost (XEXP (x, 0), GET_MODE (x), speed);
       if (speed)
 	total = COSTS_N_INSNS (2 + total);
       goto alldone;
Index: gcc/config/cris/cris.c
===================================================================
--- gcc/config/cris/cris.c	(revision 190780)
+++ gcc/config/cris/cris.c	(working copy)
@@ -130,7 +130,7 @@ 
 static int cris_register_move_cost (enum machine_mode, reg_class_t, reg_class_t);
 static int cris_memory_move_cost (enum machine_mode, reg_class_t, bool);
 static bool cris_rtx_costs (rtx, int, int, int, int *, bool);
-static int cris_address_cost (rtx, bool);
+static int cris_address_cost (rtx, enum machine_mode, bool);
 static bool cris_pass_by_reference (cumulative_args_t, enum machine_mode,
 				    const_tree, bool);
 static int cris_arg_partial_bytes (cumulative_args_t, enum machine_mode,
@@ -2149,7 +2149,8 @@ 
 /* The ADDRESS_COST worker.  */
 
 static int
-cris_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
+cris_address_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
+		   bool speed ATTRIBUTE_UNUSED)
 {
   /* The metric to use for the cost-macros is unclear.
      The metric used here is (the number of cycles needed) / 2,
Index: gcc/config/spu/spu.c
===================================================================
--- gcc/config/spu/spu.c	(revision 190780)
+++ gcc/config/spu/spu.c	(working copy)
@@ -7161,7 +7161,7 @@ 
 #define TARGET_RTX_COSTS spu_rtx_costs
 
 #undef TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_bool_0
 
 #undef TARGET_SCHED_ISSUE_RATE
 #define TARGET_SCHED_ISSUE_RATE spu_sched_issue_rate
Index: gcc/config/mep/mep.c
===================================================================
--- gcc/config/mep/mep.c	(revision 190780)
+++ gcc/config/mep/mep.c	(working copy)
@@ -212,7 +212,7 @@ 
 static rtx mep_make_bundle (rtx, rtx);
 static void mep_bundle_insns (rtx);
 static bool mep_rtx_cost (rtx, int, int, int, int *, bool);
-static int mep_address_cost (rtx, bool);
+static int mep_address_cost (rtx, enum machine_mode, bool);
 static void mep_setup_incoming_varargs (cumulative_args_t, enum machine_mode,
 					tree, int *, int);
 static bool mep_pass_by_reference (cumulative_args_t cum, enum machine_mode,
@@ -7152,7 +7152,9 @@ 
 }
 
 static int
-mep_address_cost (rtx addr ATTRIBUTE_UNUSED, bool ATTRIBUTE_UNUSED speed_p)
+mep_address_cost (rtx addr ATTRIBUTE_UNUSED,
+		  enum machine_mode mode ATTRIBUTE_UNUSED,
+		  bool ATTRIBUTE_UNUSED speed_p)
 {
   return 1;
 }
Index: gcc/config/pa/pa.c
===================================================================
--- gcc/config/pa/pa.c	(revision 190780)
+++ gcc/config/pa/pa.c	(working copy)
@@ -91,7 +91,7 @@ 
 static void fix_range (const char *);
 static int hppa_register_move_cost (enum machine_mode mode, reg_class_t,
 				    reg_class_t);
-static int hppa_address_cost (rtx, bool);
+static int hppa_address_cost (rtx, enum machine_mode mode, bool);
 static bool hppa_rtx_costs (rtx, int, int, int, int *, bool);
 static inline rtx force_mode (enum machine_mode, rtx);
 static void pa_reorg (void);
@@ -1397,7 +1397,7 @@ 
    as GO_IF_LEGITIMATE_ADDRESS.  */
 
 static int
-hppa_address_cost (rtx X,
+hppa_address_cost (rtx X, enum machine_mode mode ATTRIBUTE_UNUSED,
 		   bool speed ATTRIBUTE_UNUSED)
 {
   switch (GET_CODE (X))
Index: gcc/config/xtensa/xtensa.c
===================================================================
--- gcc/config/xtensa/xtensa.c	(revision 190780)
+++ gcc/config/xtensa/xtensa.c	(working copy)
@@ -211,7 +211,7 @@ 
 #undef TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS xtensa_rtx_costs
 #undef TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_bool_0
 
 #undef TARGET_MEMBER_TYPE_FORCES_BLK
 #define TARGET_MEMBER_TYPE_FORCES_BLK xtensa_member_type_forces_blk
Index: gcc/config/ia64/ia64.c
===================================================================
--- gcc/config/ia64/ia64.c	(revision 190780)
+++ gcc/config/ia64/ia64.c	(working copy)
@@ -524,7 +524,7 @@ 
 #undef TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS ia64_rtx_costs
 #undef TARGET_ADDRESS_COST
-#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_bool_0
 
 #undef TARGET_UNSPEC_MAY_TRAP_P
 #define TARGET_UNSPEC_MAY_TRAP_P ia64_unspec_may_trap_p
Index: gcc/target.def
===================================================================
--- gcc/target.def	(revision 190780)
+++ gcc/target.def	(working copy)
@@ -1758,7 +1758,7 @@ 
 DEFHOOK
 (address_cost,
  "",
- int, (rtx address, bool speed),
+ int, (rtx address, enum machine_mode mode, bool speed),
  default_address_cost)
 
 /* Return where to allocate pseudo for a given hard register initial value.  */