Patchwork Add a set_src_cost wrapper function

login
register
mail settings
Submitter Richard Sandiford
Date Aug. 15, 2011, 2:56 p.m.
Message ID <m3ippyu3iu.fsf@richards-thinkpad.stglab.manchester.uk.ibm.com>
Download mbox | patch
Permalink /patch/110045/
State New
Headers show

Comments

Richard Sandiford - Aug. 15, 2011, 2:56 p.m.
I'm about to post a patch that adds an extra parameter to rtx_cost.
Since most callers to rtx_cost are for SET_SRCs, it seemed a shame to
have to add an extra boiler-plate parameter to each of them.  The patch
below therefore adds a set_src_cost wrapper for this common case.

Tested on x86_64-linux-gnu.  Also tested by compiling cc1 for:

    avr-rtems bfin-elf mips64-linux-gnu x86_64-linux-gnu

and making sure that there were (a) no new warnings and (b) no differences
in -Os or -O2 output for gcc.c-torture and gcc.dg.  OK to install?

Richard


gcc/
	* rtl.h (set_src_cost, get_full_set_src_cost): New functions.
	* auto-inc-dec.c (attempt_change): Use set_src_cost instead of
	rtx_cost.
	* calls.c (precompute_register_parameters): Likewise.
	* cfgloopanal.c (seq_cost): Likewise.
	* combine.c (expand_compound_operation, make_extraction): Likewise.
	(force_to_mode, distribute_and_simplify_rtx): Likewise.
	* dse.c (find_shift_sequence): Likewise.
	* expmed.c (init_expmed, expand_mult, expand_smod_pow2): Likewise.
	* expr.c (compress_float_constant): Likewise.
	* fwprop.c (should_replace_address, try_fwprop_subst): Likewise.
	* gcse.c (want_to_gcse_p): Likewise.
	* ifcvt.c (noce_try_sign_mask): Likewise.
	* loop-doloop.c (doloop_optimize): Likewise.
	* loop-invariant.c (create_new_invariant): Likewise.
	* optabs.c (avoid_expensive_constant): Likewise.
	* postreload.c (reload_cse_simplify_set, try_replace_in_use): Likewise.
	(move2add_use_add2_insn, move2add_use_add3_insn): Likewise.
	(reload_cse_move2add): Likewise.
	* reload1.c (calculate_elim_costs_all_insns): Likewise.
	(note_reg_elim_costly): Likewise.
	* rtlanal.c (insn_rtx_cost): Likewise.
	* simplify-rtx.c (simplify_binary_operation_1): Likewise.
	* stmt.c (lshift_cheap_p): Likewise.
	* tree-ssa-loop-ivopts.c (seq_cost, computation_cost): Likewise.
	* config/avr/avr.c (final_prescan_insn): Likewise.
	* config/bfin/bfin.c (bfin_rtx_costs): Likewise.
	* config/mips/mips.c (mips_binary_cost, mips_rtx_costs): Likewise.
Richard Guenther - Aug. 15, 2011, 3:20 p.m.
On Mon, Aug 15, 2011 at 4:56 PM, Richard Sandiford
<richard.sandiford@linaro.org> wrote:
> I'm about to post a patch that adds an extra parameter to rtx_cost.
> Since most callers to rtx_cost are for SET_SRCs, it seemed a shame to
> have to add an extra boiler-plate parameter to each of them.  The patch
> below therefore adds a set_src_cost wrapper for this common case.
>
> Tested on x86_64-linux-gnu.  Also tested by compiling cc1 for:
>
>    avr-rtems bfin-elf mips64-linux-gnu x86_64-linux-gnu
>
> and making sure that there were (a) no new warnings and (b) no differences
> in -Os or -O2 output for gcc.c-torture and gcc.dg.  OK to install?

Ok.

Thanks,
Richard.

> Richard
>
>
> gcc/
>        * rtl.h (set_src_cost, get_full_set_src_cost): New functions.
>        * auto-inc-dec.c (attempt_change): Use set_src_cost instead of
>        rtx_cost.
>        * calls.c (precompute_register_parameters): Likewise.
>        * cfgloopanal.c (seq_cost): Likewise.
>        * combine.c (expand_compound_operation, make_extraction): Likewise.
>        (force_to_mode, distribute_and_simplify_rtx): Likewise.
>        * dse.c (find_shift_sequence): Likewise.
>        * expmed.c (init_expmed, expand_mult, expand_smod_pow2): Likewise.
>        * expr.c (compress_float_constant): Likewise.
>        * fwprop.c (should_replace_address, try_fwprop_subst): Likewise.
>        * gcse.c (want_to_gcse_p): Likewise.
>        * ifcvt.c (noce_try_sign_mask): Likewise.
>        * loop-doloop.c (doloop_optimize): Likewise.
>        * loop-invariant.c (create_new_invariant): Likewise.
>        * optabs.c (avoid_expensive_constant): Likewise.
>        * postreload.c (reload_cse_simplify_set, try_replace_in_use): Likewise.
>        (move2add_use_add2_insn, move2add_use_add3_insn): Likewise.
>        (reload_cse_move2add): Likewise.
>        * reload1.c (calculate_elim_costs_all_insns): Likewise.
>        (note_reg_elim_costly): Likewise.
>        * rtlanal.c (insn_rtx_cost): Likewise.
>        * simplify-rtx.c (simplify_binary_operation_1): Likewise.
>        * stmt.c (lshift_cheap_p): Likewise.
>        * tree-ssa-loop-ivopts.c (seq_cost, computation_cost): Likewise.
>        * config/avr/avr.c (final_prescan_insn): Likewise.
>        * config/bfin/bfin.c (bfin_rtx_costs): Likewise.
>        * config/mips/mips.c (mips_binary_cost, mips_rtx_costs): Likewise.
>
> Index: gcc/rtl.h
> ===================================================================
> --- gcc/rtl.h   2011-08-15 11:20:37.819148672 +0100
> +++ gcc/rtl.h   2011-08-15 11:54:58.173568083 +0100
> @@ -1217,6 +1217,25 @@ extern bool constant_pool_constant_p (rt
>  extern bool truncated_to_mode (enum machine_mode, const_rtx);
>  extern int low_bitmask_len (enum machine_mode, unsigned HOST_WIDE_INT);
>
> +#ifndef GENERATOR_FILE
> +/* Return the cost of moving X into a register, relative to the cost
> +   of a register move.  SPEED_P is true if optimizing for speed rather
> +   than size.  */
> +
> +static inline int
> +set_src_cost (rtx x, bool speed_p)
> +{
> +  return rtx_cost (x, SET, speed_p);
> +}
> +
> +/* Like set_src_cost, but return both the speed and size costs in C.  */
> +
> +static inline void
> +get_full_set_src_cost (rtx x, struct full_rtx_costs *c)
> +{
> +  get_full_rtx_cost (x, SET, c);
> +}
> +#endif
>
>  /* 1 if RTX is a subreg containing a reg that is already known to be
>    sign- or zero-extended from the mode of the subreg to the mode of
> Index: gcc/auto-inc-dec.c
> ===================================================================
> --- gcc/auto-inc-dec.c  2011-08-15 11:20:37.849148590 +0100
> +++ gcc/auto-inc-dec.c  2011-08-15 11:53:01.377886222 +0100
> @@ -483,9 +483,9 @@ attempt_change (rtx new_addr, rtx inc_re
>   PUT_MODE (mem_tmp, mode);
>   XEXP (mem_tmp, 0) = new_addr;
>
> -  old_cost = (rtx_cost (mem, SET, speed)
> -             + rtx_cost (PATTERN (inc_insn.insn), SET, speed));
> -  new_cost = rtx_cost (mem_tmp, SET, speed);
> +  old_cost = (set_src_cost (mem, speed)
> +             + set_src_cost (PATTERN (inc_insn.insn), speed));
> +  new_cost = set_src_cost (mem_tmp, speed);
>
>   /* The first item of business is to see if this is profitable.  */
>   if (old_cost < new_cost)
> Index: gcc/calls.c
> ===================================================================
> --- gcc/calls.c 2011-08-15 11:20:37.849148590 +0100
> +++ gcc/calls.c 2011-08-15 11:53:01.379886217 +0100
> @@ -742,7 +742,7 @@ precompute_register_parameters (int num_
>                     || (GET_CODE (args[i].value) == SUBREG
>                         && REG_P (SUBREG_REG (args[i].value)))))
>                 && args[i].mode != BLKmode
> -                && rtx_cost (args[i].value, SET, optimize_insn_for_speed_p ())
> +                && set_src_cost (args[i].value, optimize_insn_for_speed_p ())
>                    > COSTS_N_INSNS (1)
>                 && ((*reg_parm_seen
>                      && targetm.small_register_classes_for_mode_p (args[i].mode))
> Index: gcc/cfgloopanal.c
> ===================================================================
> --- gcc/cfgloopanal.c   2011-08-15 11:20:37.850148588 +0100
> +++ gcc/cfgloopanal.c   2011-08-15 11:53:01.383886206 +0100
> @@ -314,7 +314,7 @@ seq_cost (const_rtx seq, bool speed)
>     {
>       set = single_set (seq);
>       if (set)
> -       cost += rtx_cost (set, SET, speed);
> +       cost += set_src_cost (set, speed);
>       else
>        cost++;
>     }
> Index: gcc/combine.c
> ===================================================================
> --- gcc/combine.c       2011-08-15 11:20:37.849148590 +0100
> +++ gcc/combine.c       2011-08-15 11:53:01.421886102 +0100
> @@ -6827,11 +6827,11 @@ expand_compound_operation (rtx x)
>       rtx temp2 = expand_compound_operation (temp);
>
>       /* Make sure this is a profitable operation.  */
> -      if (rtx_cost (x, SET, optimize_this_for_speed_p)
> -          > rtx_cost (temp2, SET, optimize_this_for_speed_p))
> +      if (set_src_cost (x, optimize_this_for_speed_p)
> +          > set_src_cost (temp2, optimize_this_for_speed_p))
>        return temp2;
> -      else if (rtx_cost (x, SET, optimize_this_for_speed_p)
> -               > rtx_cost (temp, SET, optimize_this_for_speed_p))
> +      else if (set_src_cost (x, optimize_this_for_speed_p)
> +               > set_src_cost (temp, optimize_this_for_speed_p))
>        return temp;
>       else
>        return x;
> @@ -7253,8 +7253,8 @@ make_extraction (enum machine_mode mode,
>
>          /* Prefer ZERO_EXTENSION, since it gives more information to
>             backends.  */
> -         if (rtx_cost (temp, SET, optimize_this_for_speed_p)
> -             <= rtx_cost (temp1, SET, optimize_this_for_speed_p))
> +         if (set_src_cost (temp, optimize_this_for_speed_p)
> +             <= set_src_cost (temp1, optimize_this_for_speed_p))
>            return temp;
>          return temp1;
>        }
> @@ -7455,8 +7455,8 @@ make_extraction (enum machine_mode mode,
>
>          /* Prefer ZERO_EXTENSION, since it gives more information to
>             backends.  */
> -         if (rtx_cost (temp1, SET, optimize_this_for_speed_p)
> -             < rtx_cost (temp, SET, optimize_this_for_speed_p))
> +         if (set_src_cost (temp1, optimize_this_for_speed_p)
> +             < set_src_cost (temp, optimize_this_for_speed_p))
>            temp = temp1;
>        }
>       pos_rtx = temp;
> @@ -8223,8 +8223,8 @@ force_to_mode (rtx x, enum machine_mode
>
>              y = simplify_gen_binary (AND, GET_MODE (x),
>                                       XEXP (x, 0), GEN_INT (cval));
> -             if (rtx_cost (y, SET, optimize_this_for_speed_p)
> -                 < rtx_cost (x, SET, optimize_this_for_speed_p))
> +             if (set_src_cost (y, optimize_this_for_speed_p)
> +                 < set_src_cost (x, optimize_this_for_speed_p))
>                x = y;
>            }
>
> @@ -9377,8 +9377,8 @@ distribute_and_simplify_rtx (rtx x, int
>   tmp = apply_distributive_law (simplify_gen_binary (inner_code, mode,
>                                                     new_op0, new_op1));
>   if (GET_CODE (tmp) != outer_code
> -      && rtx_cost (tmp, SET, optimize_this_for_speed_p)
> -         < rtx_cost (x, SET, optimize_this_for_speed_p))
> +      && (set_src_cost (tmp, optimize_this_for_speed_p)
> +         < set_src_cost (x, optimize_this_for_speed_p)))
>     return tmp;
>
>   return NULL_RTX;
> Index: gcc/dse.c
> ===================================================================
> --- gcc/dse.c   2011-08-15 11:20:37.849148590 +0100
> +++ gcc/dse.c   2011-08-15 11:53:01.487885924 +0100
> @@ -1709,7 +1709,7 @@ find_shift_sequence (int access_size,
>                  byte = subreg_lowpart_offset (read_mode, new_mode);
>                  ret = simplify_subreg (read_mode, ret, new_mode, byte);
>                  if (ret && CONSTANT_P (ret)
> -                     && rtx_cost (ret, SET, speed) <= COSTS_N_INSNS (1))
> +                     && set_src_cost (ret, speed) <= COSTS_N_INSNS (1))
>                    return ret;
>                }
>            }
> Index: gcc/expmed.c
> ===================================================================
> --- gcc/expmed.c        2011-08-15 11:20:37.849148590 +0100
> +++ gcc/expmed.c        2011-08-15 11:53:01.542885774 +0100
> @@ -196,7 +196,7 @@ init_expmed (void)
>   for (speed = 0; speed < 2; speed++)
>     {
>       crtl->maybe_hot_insn_p = speed;
> -      zero_cost[speed] = rtx_cost (const0_rtx, SET, speed);
> +      zero_cost[speed] = set_src_cost (const0_rtx, speed);
>
>       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
>           mode != VOIDmode;
> @@ -217,15 +217,15 @@ init_expmed (void)
>          PUT_MODE (&all.shift_sub0, mode);
>          PUT_MODE (&all.shift_sub1, mode);
>
> -         add_cost[speed][mode] = rtx_cost (&all.plus, SET, speed);
> -         neg_cost[speed][mode] = rtx_cost (&all.neg, SET, speed);
> -         mul_cost[speed][mode] = rtx_cost (&all.mult, SET, speed);
> -         sdiv_cost[speed][mode] = rtx_cost (&all.sdiv, SET, speed);
> -         udiv_cost[speed][mode] = rtx_cost (&all.udiv, SET, speed);
> +         add_cost[speed][mode] = set_src_cost (&all.plus, speed);
> +         neg_cost[speed][mode] = set_src_cost (&all.neg, speed);
> +         mul_cost[speed][mode] = set_src_cost (&all.mult, speed);
> +         sdiv_cost[speed][mode] = set_src_cost (&all.sdiv, speed);
> +         udiv_cost[speed][mode] = set_src_cost (&all.udiv, speed);
>
> -         sdiv_pow2_cheap[speed][mode] = (rtx_cost (&all.sdiv_32, SET, speed)
> +         sdiv_pow2_cheap[speed][mode] = (set_src_cost (&all.sdiv_32, speed)
>                                          <= 2 * add_cost[speed][mode]);
> -         smod_pow2_cheap[speed][mode] = (rtx_cost (&all.smod_32, SET, speed)
> +         smod_pow2_cheap[speed][mode] = (set_src_cost (&all.smod_32, speed)
>                                          <= 4 * add_cost[speed][mode]);
>
>          wider_mode = GET_MODE_WIDER_MODE (mode);
> @@ -237,9 +237,9 @@ init_expmed (void)
>              XEXP (&all.wide_lshr, 1) = GEN_INT (GET_MODE_BITSIZE (mode));
>
>              mul_widen_cost[speed][wider_mode]
> -               = rtx_cost (&all.wide_mult, SET, speed);
> +               = set_src_cost (&all.wide_mult, speed);
>              mul_highpart_cost[speed][mode]
> -               = rtx_cost (&all.wide_trunc, SET, speed);
> +               = set_src_cost (&all.wide_trunc, speed);
>            }
>
>          shift_cost[speed][mode][0] = 0;
> @@ -252,10 +252,13 @@ init_expmed (void)
>              XEXP (&all.shift, 1) = cint[m];
>              XEXP (&all.shift_mult, 1) = pow2[m];
>
> -             shift_cost[speed][mode][m] = rtx_cost (&all.shift, SET, speed);
> -             shiftadd_cost[speed][mode][m] = rtx_cost (&all.shift_add, SET, speed);
> -             shiftsub0_cost[speed][mode][m] = rtx_cost (&all.shift_sub0, SET, speed);
> -             shiftsub1_cost[speed][mode][m] = rtx_cost (&all.shift_sub1, SET, speed);
> +             shift_cost[speed][mode][m] = set_src_cost (&all.shift, speed);
> +             shiftadd_cost[speed][mode][m] = set_src_cost (&all.shift_add,
> +                                                           speed);
> +             shiftsub0_cost[speed][mode][m] = set_src_cost (&all.shift_sub0,
> +                                                            speed);
> +             shiftsub1_cost[speed][mode][m] = set_src_cost (&all.shift_sub1,
> +                                                            speed);
>            }
>        }
>     }
> @@ -3077,8 +3080,9 @@ expand_mult (enum machine_mode mode, rtx
>                 result is interpreted as an unsigned coefficient.
>                 Exclude cost of op0 from max_cost to match the cost
>                 calculation of the synth_mult.  */
> -             max_cost = rtx_cost (gen_rtx_MULT (mode, fake_reg, op1), SET, speed)
> -                        - neg_cost[speed][mode];
> +             max_cost = (set_src_cost (gen_rtx_MULT (mode, fake_reg, op1),
> +                                       speed)
> +                         - neg_cost[speed][mode]);
>              if (max_cost > 0
>                  && choose_mult_variant (mode, -INTVAL (op1), &algorithm,
>                                          &variant, max_cost))
> @@ -3121,7 +3125,7 @@ expand_mult (enum machine_mode mode, rtx
>
>          /* Exclude cost of op0 from max_cost to match the cost
>             calculation of the synth_mult.  */
> -         max_cost = rtx_cost (gen_rtx_MULT (mode, fake_reg, op1), SET, speed);
> +         max_cost = set_src_cost (gen_rtx_MULT (mode, fake_reg, op1), speed);
>          if (choose_mult_variant (mode, coeff, &algorithm, &variant,
>                                   max_cost))
>            return expand_mult_const (mode, op0, coeff, target,
> @@ -3610,7 +3614,8 @@ expand_smod_pow2 (enum machine_mode mode
>
>          temp = gen_rtx_LSHIFTRT (mode, result, shift);
>          if (optab_handler (lshr_optab, mode) == CODE_FOR_nothing
> -             || rtx_cost (temp, SET, optimize_insn_for_speed_p ()) > COSTS_N_INSNS (2))
> +             || (set_src_cost (temp, optimize_insn_for_speed_p ())
> +                 > COSTS_N_INSNS (2)))
>            {
>              temp = expand_binop (mode, xor_optab, op0, signmask,
>                                   NULL_RTX, 1, OPTAB_LIB_WIDEN);
> Index: gcc/expr.c
> ===================================================================
> --- gcc/expr.c  2011-08-15 11:20:37.835148629 +0100
> +++ gcc/expr.c  2011-08-15 11:53:01.553885745 +0100
> @@ -3398,9 +3398,9 @@ compress_float_constant (rtx x, rtx y)
>   REAL_VALUE_FROM_CONST_DOUBLE (r, y);
>
>   if (targetm.legitimate_constant_p (dstmode, y))
> -    oldcost = rtx_cost (y, SET, speed);
> +    oldcost = set_src_cost (y, speed);
>   else
> -    oldcost = rtx_cost (force_const_mem (dstmode, y), SET, speed);
> +    oldcost = set_src_cost (force_const_mem (dstmode, y), speed);
>
>   for (srcmode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_srcmode));
>        srcmode != orig_srcmode;
> @@ -3427,7 +3427,8 @@ compress_float_constant (rtx x, rtx y)
>          if (!insn_operand_matches (ic, 1, trunc_y))
>            continue;
>          /* This is valid, but may not be cheaper than the original. */
> -         newcost = rtx_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y), SET, speed);
> +         newcost = set_src_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y),
> +                                 speed);
>          if (oldcost < newcost)
>            continue;
>        }
> @@ -3435,7 +3436,8 @@ compress_float_constant (rtx x, rtx y)
>        {
>          trunc_y = force_const_mem (srcmode, trunc_y);
>          /* This is valid, but may not be cheaper than the original. */
> -         newcost = rtx_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y), SET, speed);
> +         newcost = set_src_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y),
> +                                 speed);
>          if (oldcost < newcost)
>            continue;
>          trunc_y = validize_mem (trunc_y);
> Index: gcc/fwprop.c
> ===================================================================
> --- gcc/fwprop.c        2011-08-15 11:20:37.850148588 +0100
> +++ gcc/fwprop.c        2011-08-15 11:53:01.557885733 +0100
> @@ -409,11 +409,11 @@ should_replace_address (rtx old_rtx, rtx
>          - address_cost (new_rtx, mode, as, speed));
>
>   /* If the addresses have equivalent cost, prefer the new address
> -     if it has the highest `rtx_cost'.  That has the potential of
> +     if it has the highest `set_src_cost'.  That has the potential of
>      eliminating the most insns without additional costs, and it
>      is the same that cse.c used to do.  */
>   if (gain == 0)
> -    gain = rtx_cost (new_rtx, SET, speed) - rtx_cost (old_rtx, SET, speed);
> +    gain = set_src_cost (new_rtx, speed) - set_src_cost (old_rtx, speed);
>
>   return (gain > 0);
>  }
> @@ -963,7 +963,7 @@ try_fwprop_subst (df_ref use, rtx *loc,
>      multiple sets.  If so, assume the cost of the new instruction is
>      not greater than the old one.  */
>   if (set)
> -    old_cost = rtx_cost (SET_SRC (set), SET, speed);
> +    old_cost = set_src_cost (SET_SRC (set), speed);
>   if (dump_file)
>     {
>       fprintf (dump_file, "\nIn insn %d, replacing\n ", INSN_UID (insn));
> @@ -984,7 +984,7 @@ try_fwprop_subst (df_ref use, rtx *loc,
>
>   else if (DF_REF_TYPE (use) == DF_REF_REG_USE
>           && set
> -          && rtx_cost (SET_SRC (set), SET, speed) > old_cost)
> +          && set_src_cost (SET_SRC (set), speed) > old_cost)
>     {
>       if (dump_file)
>        fprintf (dump_file, "Changes to insn %d not profitable\n",
> Index: gcc/gcse.c
> ===================================================================
> --- gcc/gcse.c  2011-08-15 11:20:37.849148590 +0100
> +++ gcc/gcse.c  2011-08-15 11:53:01.560885726 +0100
> @@ -732,7 +732,7 @@ want_to_gcse_p (rtx x, int *max_distance
>   /* GCSE'ing constants:
>
>      We do not specifically distinguish between constant and non-constant
> -     expressions in PRE and Hoist.  We use rtx_cost below to limit
> +     expressions in PRE and Hoist.  We use set_src_cost below to limit
>      the maximum distance simple expressions can travel.
>
>      Nevertheless, constants are much easier to GCSE, and, hence,
> @@ -773,7 +773,7 @@ want_to_gcse_p (rtx x, int *max_distance
>
>          gcc_assert (!optimize_function_for_speed_p (cfun)
>                      && optimize_function_for_size_p (cfun));
> -         cost = rtx_cost (x, SET, 0);
> +         cost = set_src_cost (x, 0);
>
>          if (cost < COSTS_N_INSNS (GCSE_UNRESTRICTED_COST))
>            {
> Index: gcc/ifcvt.c
> ===================================================================
> --- gcc/ifcvt.c 2011-08-15 11:20:37.850148588 +0100
> +++ gcc/ifcvt.c 2011-08-15 11:53:01.569885701 +0100
> @@ -2126,7 +2126,7 @@ noce_try_sign_mask (struct noce_if_info
>      && (if_info->insn_b == NULL_RTX
>         || BLOCK_FOR_INSN (if_info->insn_b) == if_info->test_bb));
>   if (!(t_unconditional
> -       || (rtx_cost (t, SET, optimize_bb_for_speed_p (if_info->test_bb))
> +       || (set_src_cost (t, optimize_bb_for_speed_p (if_info->test_bb))
>            < COSTS_N_INSNS (2))))
>     return FALSE;
>
> Index: gcc/loop-doloop.c
> ===================================================================
> --- gcc/loop-doloop.c   2011-08-15 11:20:37.849148590 +0100
> +++ gcc/loop-doloop.c   2011-08-15 11:53:01.572885692 +0100
> @@ -655,7 +655,7 @@ doloop_optimize (struct loop *loop)
>
>   max_cost
>     = COSTS_N_INSNS (PARAM_VALUE (PARAM_MAX_ITERATIONS_COMPUTATION_COST));
> -  if (rtx_cost (desc->niter_expr, SET, optimize_loop_for_speed_p (loop))
> +  if (set_src_cost (desc->niter_expr, optimize_loop_for_speed_p (loop))
>       > max_cost)
>     {
>       if (dump_file)
> Index: gcc/loop-invariant.c
> ===================================================================
> --- gcc/loop-invariant.c        2011-08-15 11:20:37.849148590 +0100
> +++ gcc/loop-invariant.c        2011-08-15 11:53:01.573885690 +0100
> @@ -704,7 +704,7 @@ create_new_invariant (struct def *def, r
>      the loop.  Otherwise we save only cost of the computation.  */
>   if (def)
>     {
> -      inv->cost = rtx_cost (set, SET, speed);
> +      inv->cost = set_src_cost (set, speed);
>       /* ??? Try to determine cheapness of address computation.  Unfortunately
>          the address cost is only a relative measure, we can't really compare
>         it with any absolute number, but only with other address costs.
> @@ -719,7 +719,7 @@ create_new_invariant (struct def *def, r
>     }
>   else
>     {
> -      inv->cost = rtx_cost (SET_SRC (set), SET, speed);
> +      inv->cost = set_src_cost (SET_SRC (set), speed);
>       inv->cheap_address = false;
>     }
>
> Index: gcc/optabs.c
> ===================================================================
> --- gcc/optabs.c        2011-08-15 11:20:37.849148590 +0100
> +++ gcc/optabs.c        2011-08-15 11:53:01.576885683 +0100
> @@ -1218,7 +1218,7 @@ avoid_expensive_constant (enum machine_m
>   if (mode != VOIDmode
>       && optimize
>       && CONSTANT_P (x)
> -      && rtx_cost (x, binoptab->code, speed) > rtx_cost (x, SET, speed))
> +      && rtx_cost (x, binoptab->code, speed) > set_src_cost (x, speed))
>     {
>       if (CONST_INT_P (x))
>        {
> Index: gcc/postreload.c
> ===================================================================
> --- gcc/postreload.c    2011-08-15 11:20:37.849148590 +0100
> +++ gcc/postreload.c    2011-08-15 11:53:01.580885671 +0100
> @@ -275,7 +275,7 @@ reload_cse_simplify_set (rtx set, rtx in
>     old_cost = register_move_cost (GET_MODE (src),
>                                   REGNO_REG_CLASS (REGNO (src)), dclass);
>   else
> -    old_cost = rtx_cost (src, SET, speed);
> +    old_cost = set_src_cost (src, speed);
>
>   for (l = val->locs; l; l = l->next)
>     {
> @@ -310,7 +310,7 @@ reload_cse_simplify_set (rtx set, rtx in
>              this_rtx = GEN_INT (this_val);
>            }
>  #endif
> -         this_cost = rtx_cost (this_rtx, SET, speed);
> +         this_cost = set_src_cost (this_rtx, speed);
>        }
>       else if (REG_P (this_rtx))
>        {
> @@ -318,7 +318,7 @@ reload_cse_simplify_set (rtx set, rtx in
>          if (extend_op != UNKNOWN)
>            {
>              this_rtx = gen_rtx_fmt_e (extend_op, word_mode, this_rtx);
> -             this_cost = rtx_cost (this_rtx, SET, speed);
> +             this_cost = set_src_cost (this_rtx, speed);
>            }
>          else
>  #endif
> @@ -579,10 +579,12 @@ reload_cse_simplify_operands (rtx insn,
>                      && recog_data.alternative_enabled_p[j]
>                      && reg_fits_class_p (testreg, rclass, 0, mode)
>                      && (!CONST_INT_P (recog_data.operand[i])
> -                         || (rtx_cost (recog_data.operand[i], SET,
> -                                       optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn)))
> -                             > rtx_cost (testreg, SET,
> -                                       optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn))))))
> +                         || (set_src_cost (recog_data.operand[i],
> +                                           optimize_bb_for_speed_p
> +                                            (BLOCK_FOR_INSN (insn)))
> +                             > set_src_cost (testreg,
> +                                             optimize_bb_for_speed_p
> +                                              (BLOCK_FOR_INSN (insn))))))
>                    {
>                      alternative_nregs[j]++;
>                      op_alt_regno[i][j] = regno;
> @@ -916,12 +918,12 @@ try_replace_in_use (struct reg_use *use,
>          && CONSTANT_P (XEXP (SET_SRC (new_set), 1)))
>        {
>          rtx new_src;
> -         int old_cost = rtx_cost (SET_SRC (new_set), SET, speed);
> +         int old_cost = set_src_cost (SET_SRC (new_set), speed);
>
>          gcc_assert (rtx_equal_p (XEXP (SET_SRC (new_set), 0), reg));
>          new_src = simplify_replace_rtx (SET_SRC (new_set), reg, src);
>
> -         if (rtx_cost (new_src, SET, speed) <= old_cost
> +         if (set_src_cost (new_src, speed) <= old_cost
>              && validate_change (use_insn, &SET_SRC (new_set),
>                                  new_src, 0))
>            return true;
> @@ -1683,9 +1685,9 @@ move2add_use_add2_insn (rtx reg, rtx sym
>       struct full_rtx_costs oldcst, newcst;
>       rtx tem = gen_rtx_PLUS (GET_MODE (reg), reg, new_src);
>
> -      get_full_rtx_cost (pat, SET, &oldcst);
> +      get_full_set_src_cost (pat, &oldcst);
>       SET_SRC (pat) = tem;
> -      get_full_rtx_cost (pat, SET, &newcst);
> +      get_full_set_src_cost (pat, &newcst);
>       SET_SRC (pat) = src;
>
>       if (costs_lt_p (&newcst, &oldcst, speed)
> @@ -1752,7 +1754,7 @@ move2add_use_add3_insn (rtx reg, rtx sym
>   rtx plus_expr;
>
>   init_costs_to_max (&mincst);
> -  get_full_rtx_cost (pat, SET, &oldcst);
> +  get_full_set_src_cost (pat, &oldcst);
>
>   plus_expr = gen_rtx_PLUS (GET_MODE (reg), reg, const0_rtx);
>   SET_SRC (pat) = plus_expr;
> @@ -1781,7 +1783,7 @@ move2add_use_add3_insn (rtx reg, rtx sym
>        else
>          {
>            XEXP (plus_expr, 1) = new_src;
> -           get_full_rtx_cost (pat, SET, &newcst);
> +           get_full_set_src_cost (pat, &newcst);
>
>            if (costs_lt_p (&newcst, &mincst, speed))
>              {
> @@ -1934,9 +1936,9 @@ reload_cse_move2add (rtx first)
>                          struct full_rtx_costs oldcst, newcst;
>                          rtx tem = gen_rtx_PLUS (GET_MODE (reg), reg, new_src);
>
> -                         get_full_rtx_cost (set, SET, &oldcst);
> +                         get_full_set_src_cost (set, &oldcst);
>                          SET_SRC (set) = tem;
> -                         get_full_rtx_cost (tem, SET, &newcst);
> +                         get_full_set_src_cost (tem, &newcst);
>                          SET_SRC (set) = old_src;
>                          costs_add_n_insns (&oldcst, 1);
>
> Index: gcc/reload1.c
> ===================================================================
> --- gcc/reload1.c       2011-08-15 11:20:37.850148588 +0100
> +++ gcc/reload1.c       2011-08-15 11:53:01.583885662 +0100
> @@ -1646,8 +1646,7 @@ calculate_elim_costs_all_insns (void)
>                    {
>                      rtx t = eliminate_regs_1 (SET_SRC (set), VOIDmode, insn,
>                                                false, true);
> -                     int cost = rtx_cost (t, SET,
> -                                          optimize_bb_for_speed_p (bb));
> +                     int cost = set_src_cost (t, optimize_bb_for_speed_p (bb));
>                      int freq = REG_FREQ_FROM_BB (bb);
>
>                      reg_equiv_init_cost[regno] = cost * freq;
> @@ -2505,7 +2504,7 @@ note_reg_elim_costly (rtx *px, void *dat
>     {
>       rtx t = reg_equiv_invariant (REGNO (x));
>       rtx new_rtx = eliminate_regs_1 (t, Pmode, insn, true, true);
> -      int cost = rtx_cost (new_rtx, SET, optimize_bb_for_speed_p (elim_bb));
> +      int cost = set_src_cost (new_rtx, optimize_bb_for_speed_p (elim_bb));
>       int freq = REG_FREQ_FROM_BB (elim_bb);
>
>       if (cost != 0)
> Index: gcc/rtlanal.c
> ===================================================================
> --- gcc/rtlanal.c       2011-08-15 11:20:37.835148629 +0100
> +++ gcc/rtlanal.c       2011-08-15 11:53:01.612885587 +0100
> @@ -4782,7 +4782,7 @@ insn_rtx_cost (rtx pat, bool speed)
>   else
>     return 0;
>
> -  cost = rtx_cost (SET_SRC (set), SET, speed);
> +  cost = set_src_cost (SET_SRC (set), speed);
>   return cost > 0 ? cost : COSTS_N_INSNS (1);
>  }
>
> Index: gcc/simplify-rtx.c
> ===================================================================
> --- gcc/simplify-rtx.c  2011-08-15 11:20:37.835148629 +0100
> +++ gcc/simplify-rtx.c  2011-08-15 11:53:01.625885549 +0100
> @@ -2033,7 +2033,7 @@ simplify_binary_operation_1 (enum rtx_co
>              coeff = immed_double_int_const (val, mode);
>
>              tem = simplify_gen_binary (MULT, mode, lhs, coeff);
> -             return rtx_cost (tem, SET, speed) <= rtx_cost (orig, SET, speed)
> +             return set_src_cost (tem, speed) <= set_src_cost (orig, speed)
>                ? tem : 0;
>            }
>        }
> @@ -2214,7 +2214,7 @@ simplify_binary_operation_1 (enum rtx_co
>              coeff = immed_double_int_const (val, mode);
>
>              tem = simplify_gen_binary (MULT, mode, lhs, coeff);
> -             return rtx_cost (tem, SET, speed) <= rtx_cost (orig, SET, speed)
> +             return set_src_cost (tem, speed) <= set_src_cost (orig, speed)
>                ? tem : 0;
>            }
>        }
> Index: gcc/stmt.c
> ===================================================================
> --- gcc/stmt.c  2011-08-15 11:20:37.850148588 +0100
> +++ gcc/stmt.c  2011-08-15 11:53:01.662885448 +0100
> @@ -2131,8 +2131,8 @@ bool lshift_cheap_p (void)
>   if (!init[speed_p])
>     {
>       rtx reg = gen_rtx_REG (word_mode, 10000);
> -      int cost = rtx_cost (gen_rtx_ASHIFT (word_mode, const1_rtx, reg), SET,
> -                          speed_p);
> +      int cost = set_src_cost (gen_rtx_ASHIFT (word_mode, const1_rtx, reg),
> +                              speed_p);
>       cheap[speed_p] = cost < COSTS_N_INSNS (3);
>       init[speed_p] = true;
>     }
> Index: gcc/tree-ssa-loop-ivopts.c
> ===================================================================
> --- gcc/tree-ssa-loop-ivopts.c  2011-08-15 11:20:37.835148629 +0100
> +++ gcc/tree-ssa-loop-ivopts.c  2011-08-15 11:53:01.674885416 +0100
> @@ -2754,7 +2754,7 @@ seq_cost (rtx seq, bool speed)
>     {
>       set = single_set (seq);
>       if (set)
> -       cost += rtx_cost (SET_SRC (set), SET, speed);
> +       cost += set_src_cost (SET_SRC (set), speed);
>       else
>        cost++;
>     }
> @@ -2876,7 +2876,7 @@ computation_cost (tree expr, bool speed)
>     cost += address_cost (XEXP (rslt, 0), TYPE_MODE (type),
>                          TYPE_ADDR_SPACE (type), speed);
>   else if (!REG_P (rslt))
> -    cost += rtx_cost (rslt, SET, speed);
> +    cost += set_src_cost (rslt, speed);
>
>   return cost;
>  }
> Index: gcc/config/avr/avr.c
> ===================================================================
> --- gcc/config/avr/avr.c        2011-08-15 11:20:37.820148669 +0100
> +++ gcc/config/avr/avr.c        2011-08-15 11:53:01.461885995 +0100
> @@ -1637,7 +1637,7 @@ final_prescan_insn (rtx insn, rtx *opera
>
>       if (set)
>         fprintf (asm_out_file, "/* DEBUG: cost = %d.  */\n",
> -                 rtx_cost (SET_SRC (set), SET, optimize_insn_for_speed_p()));
> +                 set_src_cost (SET_SRC (set), optimize_insn_for_speed_p ()));
>       else
>         fprintf (asm_out_file, "/* DEBUG: pattern-cost = %d.  */\n",
>                  rtx_cost (PATTERN (insn), INSN, optimize_insn_for_speed_p()));
> Index: gcc/config/bfin/bfin.c
> ===================================================================
> --- gcc/config/bfin/bfin.c      2011-08-15 11:20:37.820148669 +0100
> +++ gcc/config/bfin/bfin.c      2011-08-15 11:53:01.470885971 +0100
> @@ -2837,11 +2837,11 @@ bfin_rtx_costs (rtx x, int code_i, int o
>          *total = cost2;
>          if (GET_CODE (op0) != REG
>              && (GET_CODE (op0) != SUBREG || GET_CODE (SUBREG_REG (op0)) != REG))
> -           *total += rtx_cost (op0, SET, speed);
> +           *total += set_src_cost (op0, speed);
>  #if 0 /* We'd like to do this for accuracy, but it biases the loop optimizer
>         towards creating too many induction variables.  */
>          if (!reg_or_7bit_operand (op1, SImode))
> -           *total += rtx_cost (op1, SET, speed);
> +           *total += set_src_cost (op1, speed);
>  #endif
>        }
>       else if (GET_MODE (x) == DImode)
> Index: gcc/config/mips/mips.c
> ===================================================================
> --- gcc/config/mips/mips.c      2011-08-15 11:20:37.819148672 +0100
> +++ gcc/config/mips/mips.c      2011-08-15 11:53:01.478885948 +0100
> @@ -3333,7 +3333,7 @@ mips_binary_cost (rtx x, int single_cost
>   else
>     cost = single_cost;
>   return (cost
> -         + rtx_cost (XEXP (x, 0), SET, speed)
> +         + set_src_cost (XEXP (x, 0), speed)
>          + rtx_cost (XEXP (x, 1), GET_CODE (x), speed));
>  }
>
> @@ -3550,7 +3550,7 @@ mips_rtx_costs (rtx x, int code, int out
>          && UINTVAL (XEXP (x, 1)) == 0xffffffff)
>        {
>          *total = (mips_zero_extend_cost (mode, XEXP (x, 0))
> -                   + rtx_cost (XEXP (x, 0), SET, speed));
> +                   + set_src_cost (XEXP (x, 0), speed));
>          return true;
>        }
>       /* Fall through.  */
> @@ -3585,7 +3585,7 @@ mips_rtx_costs (rtx x, int code, int out
>     case LO_SUM:
>       /* Low-part immediates need an extended MIPS16 instruction.  */
>       *total = (COSTS_N_INSNS (TARGET_MIPS16 ? 2 : 1)
> -               + rtx_cost (XEXP (x, 0), SET, speed));
> +               + set_src_cost (XEXP (x, 0), speed));
>       return true;
>
>     case LT:
> @@ -3626,17 +3626,17 @@ mips_rtx_costs (rtx x, int code, int out
>          if (GET_CODE (op0) == MULT && GET_CODE (XEXP (op0, 0)) == NEG)
>            {
>              *total = (mips_fp_mult_cost (mode)
> -                       + rtx_cost (XEXP (XEXP (op0, 0), 0), SET, speed)
> -                       + rtx_cost (XEXP (op0, 1), SET, speed)
> -                       + rtx_cost (op1, SET, speed));
> +                       + set_src_cost (XEXP (XEXP (op0, 0), 0), speed)
> +                       + set_src_cost (XEXP (op0, 1), speed)
> +                       + set_src_cost (op1, speed));
>              return true;
>            }
>          if (GET_CODE (op1) == MULT)
>            {
>              *total = (mips_fp_mult_cost (mode)
> -                       + rtx_cost (op0, SET, speed)
> -                       + rtx_cost (XEXP (op1, 0), SET, speed)
> -                       + rtx_cost (XEXP (op1, 1), SET, speed));
> +                       + set_src_cost (op0, speed)
> +                       + set_src_cost (XEXP (op1, 0), speed)
> +                       + set_src_cost (XEXP (op1, 1), speed));
>              return true;
>            }
>        }
> @@ -3678,9 +3678,9 @@ mips_rtx_costs (rtx x, int code, int out
>              && GET_CODE (XEXP (op, 0)) == MULT)
>            {
>              *total = (mips_fp_mult_cost (mode)
> -                       + rtx_cost (XEXP (XEXP (op, 0), 0), SET, speed)
> -                       + rtx_cost (XEXP (XEXP (op, 0), 1), SET, speed)
> -                       + rtx_cost (XEXP (op, 1), SET, speed));
> +                       + set_src_cost (XEXP (XEXP (op, 0), 0), speed)
> +                       + set_src_cost (XEXP (XEXP (op, 0), 1), speed)
> +                       + set_src_cost (XEXP (op, 1), speed));
>              return true;
>            }
>        }
> @@ -3718,10 +3718,10 @@ mips_rtx_costs (rtx x, int code, int out
>          if (outer_code == SQRT || GET_CODE (XEXP (x, 1)) == SQRT)
>            /* An rsqrt<mode>a or rsqrt<mode>b pattern.  Count the
>               division as being free.  */
> -           *total = rtx_cost (XEXP (x, 1), SET, speed);
> +           *total = set_src_cost (XEXP (x, 1), speed);
>          else
>            *total = (mips_fp_div_cost (mode)
> -                     + rtx_cost (XEXP (x, 1), SET, speed));
> +                     + set_src_cost (XEXP (x, 1), speed));
>          return true;
>        }
>       /* Fall through.  */
> @@ -3749,7 +3749,7 @@ mips_rtx_costs (rtx x, int code, int out
>              && CONST_INT_P (XEXP (x, 1))
>              && exact_log2 (INTVAL (XEXP (x, 1))) >= 0)
>            {
> -             *total = COSTS_N_INSNS (2) + rtx_cost (XEXP (x, 0), SET, speed);
> +             *total = COSTS_N_INSNS (2) + set_src_cost (XEXP (x, 0), speed);
>              return true;
>            }
>          *total = COSTS_N_INSNS (mips_idiv_insns ());
>

Patch

Index: gcc/rtl.h
===================================================================
--- gcc/rtl.h	2011-08-15 11:20:37.819148672 +0100
+++ gcc/rtl.h	2011-08-15 11:54:58.173568083 +0100
@@ -1217,6 +1217,25 @@  extern bool constant_pool_constant_p (rt
 extern bool truncated_to_mode (enum machine_mode, const_rtx);
 extern int low_bitmask_len (enum machine_mode, unsigned HOST_WIDE_INT);
 
+#ifndef GENERATOR_FILE
+/* Return the cost of moving X into a register, relative to the cost
+   of a register move.  SPEED_P is true if optimizing for speed rather
+   than size.  */
+
+static inline int
+set_src_cost (rtx x, bool speed_p)
+{
+  return rtx_cost (x, SET, speed_p);
+}
+
+/* Like set_src_cost, but return both the speed and size costs in C.  */
+
+static inline void
+get_full_set_src_cost (rtx x, struct full_rtx_costs *c)
+{
+  get_full_rtx_cost (x, SET, c);
+}
+#endif
 
 /* 1 if RTX is a subreg containing a reg that is already known to be
    sign- or zero-extended from the mode of the subreg to the mode of
Index: gcc/auto-inc-dec.c
===================================================================
--- gcc/auto-inc-dec.c	2011-08-15 11:20:37.849148590 +0100
+++ gcc/auto-inc-dec.c	2011-08-15 11:53:01.377886222 +0100
@@ -483,9 +483,9 @@  attempt_change (rtx new_addr, rtx inc_re
   PUT_MODE (mem_tmp, mode);
   XEXP (mem_tmp, 0) = new_addr;
 
-  old_cost = (rtx_cost (mem, SET, speed)
-	      + rtx_cost (PATTERN (inc_insn.insn), SET, speed));
-  new_cost = rtx_cost (mem_tmp, SET, speed);
+  old_cost = (set_src_cost (mem, speed)
+	      + set_src_cost (PATTERN (inc_insn.insn), speed));
+  new_cost = set_src_cost (mem_tmp, speed);
 
   /* The first item of business is to see if this is profitable.  */
   if (old_cost < new_cost)
Index: gcc/calls.c
===================================================================
--- gcc/calls.c	2011-08-15 11:20:37.849148590 +0100
+++ gcc/calls.c	2011-08-15 11:53:01.379886217 +0100
@@ -742,7 +742,7 @@  precompute_register_parameters (int num_
 		     || (GET_CODE (args[i].value) == SUBREG
 			 && REG_P (SUBREG_REG (args[i].value)))))
 		 && args[i].mode != BLKmode
-		 && rtx_cost (args[i].value, SET, optimize_insn_for_speed_p ())
+		 && set_src_cost (args[i].value, optimize_insn_for_speed_p ())
 		    > COSTS_N_INSNS (1)
 		 && ((*reg_parm_seen
 		      && targetm.small_register_classes_for_mode_p (args[i].mode))
Index: gcc/cfgloopanal.c
===================================================================
--- gcc/cfgloopanal.c	2011-08-15 11:20:37.850148588 +0100
+++ gcc/cfgloopanal.c	2011-08-15 11:53:01.383886206 +0100
@@ -314,7 +314,7 @@  seq_cost (const_rtx seq, bool speed)
     {
       set = single_set (seq);
       if (set)
-	cost += rtx_cost (set, SET, speed);
+	cost += set_src_cost (set, speed);
       else
 	cost++;
     }
Index: gcc/combine.c
===================================================================
--- gcc/combine.c	2011-08-15 11:20:37.849148590 +0100
+++ gcc/combine.c	2011-08-15 11:53:01.421886102 +0100
@@ -6827,11 +6827,11 @@  expand_compound_operation (rtx x)
       rtx temp2 = expand_compound_operation (temp);
 
       /* Make sure this is a profitable operation.  */
-      if (rtx_cost (x, SET, optimize_this_for_speed_p)
-          > rtx_cost (temp2, SET, optimize_this_for_speed_p))
+      if (set_src_cost (x, optimize_this_for_speed_p)
+          > set_src_cost (temp2, optimize_this_for_speed_p))
        return temp2;
-      else if (rtx_cost (x, SET, optimize_this_for_speed_p)
-               > rtx_cost (temp, SET, optimize_this_for_speed_p))
+      else if (set_src_cost (x, optimize_this_for_speed_p)
+               > set_src_cost (temp, optimize_this_for_speed_p))
        return temp;
       else
        return x;
@@ -7253,8 +7253,8 @@  make_extraction (enum machine_mode mode,
 
 	  /* Prefer ZERO_EXTENSION, since it gives more information to
 	     backends.  */
-	  if (rtx_cost (temp, SET, optimize_this_for_speed_p)
-	      <= rtx_cost (temp1, SET, optimize_this_for_speed_p))
+	  if (set_src_cost (temp, optimize_this_for_speed_p)
+	      <= set_src_cost (temp1, optimize_this_for_speed_p))
 	    return temp;
 	  return temp1;
 	}
@@ -7455,8 +7455,8 @@  make_extraction (enum machine_mode mode,
 
 	  /* Prefer ZERO_EXTENSION, since it gives more information to
 	     backends.  */
-	  if (rtx_cost (temp1, SET, optimize_this_for_speed_p)
-	      < rtx_cost (temp, SET, optimize_this_for_speed_p))
+	  if (set_src_cost (temp1, optimize_this_for_speed_p)
+	      < set_src_cost (temp, optimize_this_for_speed_p))
 	    temp = temp1;
 	}
       pos_rtx = temp;
@@ -8223,8 +8223,8 @@  force_to_mode (rtx x, enum machine_mode 
 
 	      y = simplify_gen_binary (AND, GET_MODE (x),
 				       XEXP (x, 0), GEN_INT (cval));
-	      if (rtx_cost (y, SET, optimize_this_for_speed_p)
-	          < rtx_cost (x, SET, optimize_this_for_speed_p))
+	      if (set_src_cost (y, optimize_this_for_speed_p)
+	          < set_src_cost (x, optimize_this_for_speed_p))
 		x = y;
 	    }
 
@@ -9377,8 +9377,8 @@  distribute_and_simplify_rtx (rtx x, int 
   tmp = apply_distributive_law (simplify_gen_binary (inner_code, mode,
 						     new_op0, new_op1));
   if (GET_CODE (tmp) != outer_code
-      && rtx_cost (tmp, SET, optimize_this_for_speed_p)
-         < rtx_cost (x, SET, optimize_this_for_speed_p))
+      && (set_src_cost (tmp, optimize_this_for_speed_p)
+	  < set_src_cost (x, optimize_this_for_speed_p)))
     return tmp;
 
   return NULL_RTX;
Index: gcc/dse.c
===================================================================
--- gcc/dse.c	2011-08-15 11:20:37.849148590 +0100
+++ gcc/dse.c	2011-08-15 11:53:01.487885924 +0100
@@ -1709,7 +1709,7 @@  find_shift_sequence (int access_size,
 		  byte = subreg_lowpart_offset (read_mode, new_mode);
 		  ret = simplify_subreg (read_mode, ret, new_mode, byte);
 		  if (ret && CONSTANT_P (ret)
-		      && rtx_cost (ret, SET, speed) <= COSTS_N_INSNS (1))
+		      && set_src_cost (ret, speed) <= COSTS_N_INSNS (1))
 		    return ret;
 		}
 	    }
Index: gcc/expmed.c
===================================================================
--- gcc/expmed.c	2011-08-15 11:20:37.849148590 +0100
+++ gcc/expmed.c	2011-08-15 11:53:01.542885774 +0100
@@ -196,7 +196,7 @@  init_expmed (void)
   for (speed = 0; speed < 2; speed++)
     {
       crtl->maybe_hot_insn_p = speed;
-      zero_cost[speed] = rtx_cost (const0_rtx, SET, speed);
+      zero_cost[speed] = set_src_cost (const0_rtx, speed);
 
       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
 	   mode != VOIDmode;
@@ -217,15 +217,15 @@  init_expmed (void)
 	  PUT_MODE (&all.shift_sub0, mode);
 	  PUT_MODE (&all.shift_sub1, mode);
 
-	  add_cost[speed][mode] = rtx_cost (&all.plus, SET, speed);
-	  neg_cost[speed][mode] = rtx_cost (&all.neg, SET, speed);
-	  mul_cost[speed][mode] = rtx_cost (&all.mult, SET, speed);
-	  sdiv_cost[speed][mode] = rtx_cost (&all.sdiv, SET, speed);
-	  udiv_cost[speed][mode] = rtx_cost (&all.udiv, SET, speed);
+	  add_cost[speed][mode] = set_src_cost (&all.plus, speed);
+	  neg_cost[speed][mode] = set_src_cost (&all.neg, speed);
+	  mul_cost[speed][mode] = set_src_cost (&all.mult, speed);
+	  sdiv_cost[speed][mode] = set_src_cost (&all.sdiv, speed);
+	  udiv_cost[speed][mode] = set_src_cost (&all.udiv, speed);
 
-	  sdiv_pow2_cheap[speed][mode] = (rtx_cost (&all.sdiv_32, SET, speed)
+	  sdiv_pow2_cheap[speed][mode] = (set_src_cost (&all.sdiv_32, speed)
 				          <= 2 * add_cost[speed][mode]);
-	  smod_pow2_cheap[speed][mode] = (rtx_cost (&all.smod_32, SET, speed)
+	  smod_pow2_cheap[speed][mode] = (set_src_cost (&all.smod_32, speed)
 				          <= 4 * add_cost[speed][mode]);
 
 	  wider_mode = GET_MODE_WIDER_MODE (mode);
@@ -237,9 +237,9 @@  init_expmed (void)
 	      XEXP (&all.wide_lshr, 1) = GEN_INT (GET_MODE_BITSIZE (mode));
 
 	      mul_widen_cost[speed][wider_mode]
-	        = rtx_cost (&all.wide_mult, SET, speed);
+	        = set_src_cost (&all.wide_mult, speed);
 	      mul_highpart_cost[speed][mode]
-	        = rtx_cost (&all.wide_trunc, SET, speed);
+	        = set_src_cost (&all.wide_trunc, speed);
 	    }
 
 	  shift_cost[speed][mode][0] = 0;
@@ -252,10 +252,13 @@  init_expmed (void)
 	      XEXP (&all.shift, 1) = cint[m];
 	      XEXP (&all.shift_mult, 1) = pow2[m];
 
-	      shift_cost[speed][mode][m] = rtx_cost (&all.shift, SET, speed);
-	      shiftadd_cost[speed][mode][m] = rtx_cost (&all.shift_add, SET, speed);
-	      shiftsub0_cost[speed][mode][m] = rtx_cost (&all.shift_sub0, SET, speed);
-	      shiftsub1_cost[speed][mode][m] = rtx_cost (&all.shift_sub1, SET, speed);
+	      shift_cost[speed][mode][m] = set_src_cost (&all.shift, speed);
+	      shiftadd_cost[speed][mode][m] = set_src_cost (&all.shift_add,
+							    speed);
+	      shiftsub0_cost[speed][mode][m] = set_src_cost (&all.shift_sub0,
+							     speed);
+	      shiftsub1_cost[speed][mode][m] = set_src_cost (&all.shift_sub1,
+							     speed);
 	    }
 	}
     }
@@ -3077,8 +3080,9 @@  expand_mult (enum machine_mode mode, rtx
 		 result is interpreted as an unsigned coefficient.
 		 Exclude cost of op0 from max_cost to match the cost
 		 calculation of the synth_mult.  */
-	      max_cost = rtx_cost (gen_rtx_MULT (mode, fake_reg, op1), SET, speed)
-			 - neg_cost[speed][mode];
+	      max_cost = (set_src_cost (gen_rtx_MULT (mode, fake_reg, op1),
+					speed)
+			  - neg_cost[speed][mode]);
 	      if (max_cost > 0
 		  && choose_mult_variant (mode, -INTVAL (op1), &algorithm,
 					  &variant, max_cost))
@@ -3121,7 +3125,7 @@  expand_mult (enum machine_mode mode, rtx
 
 	  /* Exclude cost of op0 from max_cost to match the cost
 	     calculation of the synth_mult.  */
-	  max_cost = rtx_cost (gen_rtx_MULT (mode, fake_reg, op1), SET, speed);
+	  max_cost = set_src_cost (gen_rtx_MULT (mode, fake_reg, op1), speed);
 	  if (choose_mult_variant (mode, coeff, &algorithm, &variant,
 				   max_cost))
 	    return expand_mult_const (mode, op0, coeff, target,
@@ -3610,7 +3614,8 @@  expand_smod_pow2 (enum machine_mode mode
 
 	  temp = gen_rtx_LSHIFTRT (mode, result, shift);
 	  if (optab_handler (lshr_optab, mode) == CODE_FOR_nothing
-	      || rtx_cost (temp, SET, optimize_insn_for_speed_p ()) > COSTS_N_INSNS (2))
+	      || (set_src_cost (temp, optimize_insn_for_speed_p ())
+		  > COSTS_N_INSNS (2)))
 	    {
 	      temp = expand_binop (mode, xor_optab, op0, signmask,
 				   NULL_RTX, 1, OPTAB_LIB_WIDEN);
Index: gcc/expr.c
===================================================================
--- gcc/expr.c	2011-08-15 11:20:37.835148629 +0100
+++ gcc/expr.c	2011-08-15 11:53:01.553885745 +0100
@@ -3398,9 +3398,9 @@  compress_float_constant (rtx x, rtx y)
   REAL_VALUE_FROM_CONST_DOUBLE (r, y);
 
   if (targetm.legitimate_constant_p (dstmode, y))
-    oldcost = rtx_cost (y, SET, speed);
+    oldcost = set_src_cost (y, speed);
   else
-    oldcost = rtx_cost (force_const_mem (dstmode, y), SET, speed);
+    oldcost = set_src_cost (force_const_mem (dstmode, y), speed);
 
   for (srcmode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_srcmode));
        srcmode != orig_srcmode;
@@ -3427,7 +3427,8 @@  compress_float_constant (rtx x, rtx y)
 	  if (!insn_operand_matches (ic, 1, trunc_y))
 	    continue;
 	  /* This is valid, but may not be cheaper than the original. */
-	  newcost = rtx_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y), SET, speed);
+	  newcost = set_src_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y),
+				  speed);
 	  if (oldcost < newcost)
 	    continue;
 	}
@@ -3435,7 +3436,8 @@  compress_float_constant (rtx x, rtx y)
 	{
 	  trunc_y = force_const_mem (srcmode, trunc_y);
 	  /* This is valid, but may not be cheaper than the original. */
-	  newcost = rtx_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y), SET, speed);
+	  newcost = set_src_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y),
+				  speed);
 	  if (oldcost < newcost)
 	    continue;
 	  trunc_y = validize_mem (trunc_y);
Index: gcc/fwprop.c
===================================================================
--- gcc/fwprop.c	2011-08-15 11:20:37.850148588 +0100
+++ gcc/fwprop.c	2011-08-15 11:53:01.557885733 +0100
@@ -409,11 +409,11 @@  should_replace_address (rtx old_rtx, rtx
 	  - address_cost (new_rtx, mode, as, speed));
 
   /* If the addresses have equivalent cost, prefer the new address
-     if it has the highest `rtx_cost'.  That has the potential of
+     if it has the highest `set_src_cost'.  That has the potential of
      eliminating the most insns without additional costs, and it
      is the same that cse.c used to do.  */
   if (gain == 0)
-    gain = rtx_cost (new_rtx, SET, speed) - rtx_cost (old_rtx, SET, speed);
+    gain = set_src_cost (new_rtx, speed) - set_src_cost (old_rtx, speed);
 
   return (gain > 0);
 }
@@ -963,7 +963,7 @@  try_fwprop_subst (df_ref use, rtx *loc, 
      multiple sets.  If so, assume the cost of the new instruction is
      not greater than the old one.  */
   if (set)
-    old_cost = rtx_cost (SET_SRC (set), SET, speed);
+    old_cost = set_src_cost (SET_SRC (set), speed);
   if (dump_file)
     {
       fprintf (dump_file, "\nIn insn %d, replacing\n ", INSN_UID (insn));
@@ -984,7 +984,7 @@  try_fwprop_subst (df_ref use, rtx *loc, 
 
   else if (DF_REF_TYPE (use) == DF_REF_REG_USE
 	   && set
-	   && rtx_cost (SET_SRC (set), SET, speed) > old_cost)
+	   && set_src_cost (SET_SRC (set), speed) > old_cost)
     {
       if (dump_file)
 	fprintf (dump_file, "Changes to insn %d not profitable\n",
Index: gcc/gcse.c
===================================================================
--- gcc/gcse.c	2011-08-15 11:20:37.849148590 +0100
+++ gcc/gcse.c	2011-08-15 11:53:01.560885726 +0100
@@ -732,7 +732,7 @@  want_to_gcse_p (rtx x, int *max_distance
   /* GCSE'ing constants:
 
      We do not specifically distinguish between constant and non-constant
-     expressions in PRE and Hoist.  We use rtx_cost below to limit
+     expressions in PRE and Hoist.  We use set_src_cost below to limit
      the maximum distance simple expressions can travel.
 
      Nevertheless, constants are much easier to GCSE, and, hence,
@@ -773,7 +773,7 @@  want_to_gcse_p (rtx x, int *max_distance
 
 	  gcc_assert (!optimize_function_for_speed_p (cfun)
 		      && optimize_function_for_size_p (cfun));
-	  cost = rtx_cost (x, SET, 0);
+	  cost = set_src_cost (x, 0);
 
 	  if (cost < COSTS_N_INSNS (GCSE_UNRESTRICTED_COST))
 	    {
Index: gcc/ifcvt.c
===================================================================
--- gcc/ifcvt.c	2011-08-15 11:20:37.850148588 +0100
+++ gcc/ifcvt.c	2011-08-15 11:53:01.569885701 +0100
@@ -2126,7 +2126,7 @@  noce_try_sign_mask (struct noce_if_info 
      && (if_info->insn_b == NULL_RTX
 	 || BLOCK_FOR_INSN (if_info->insn_b) == if_info->test_bb));
   if (!(t_unconditional
-	|| (rtx_cost (t, SET, optimize_bb_for_speed_p (if_info->test_bb))
+	|| (set_src_cost (t, optimize_bb_for_speed_p (if_info->test_bb))
 	    < COSTS_N_INSNS (2))))
     return FALSE;
 
Index: gcc/loop-doloop.c
===================================================================
--- gcc/loop-doloop.c	2011-08-15 11:20:37.849148590 +0100
+++ gcc/loop-doloop.c	2011-08-15 11:53:01.572885692 +0100
@@ -655,7 +655,7 @@  doloop_optimize (struct loop *loop)
 
   max_cost
     = COSTS_N_INSNS (PARAM_VALUE (PARAM_MAX_ITERATIONS_COMPUTATION_COST));
-  if (rtx_cost (desc->niter_expr, SET, optimize_loop_for_speed_p (loop))
+  if (set_src_cost (desc->niter_expr, optimize_loop_for_speed_p (loop))
       > max_cost)
     {
       if (dump_file)
Index: gcc/loop-invariant.c
===================================================================
--- gcc/loop-invariant.c	2011-08-15 11:20:37.849148590 +0100
+++ gcc/loop-invariant.c	2011-08-15 11:53:01.573885690 +0100
@@ -704,7 +704,7 @@  create_new_invariant (struct def *def, r
      the loop.  Otherwise we save only cost of the computation.  */
   if (def)
     {
-      inv->cost = rtx_cost (set, SET, speed);
+      inv->cost = set_src_cost (set, speed);
       /* ??? Try to determine cheapness of address computation.  Unfortunately
          the address cost is only a relative measure, we can't really compare
 	 it with any absolute number, but only with other address costs.
@@ -719,7 +719,7 @@  create_new_invariant (struct def *def, r
     }
   else
     {
-      inv->cost = rtx_cost (SET_SRC (set), SET, speed);
+      inv->cost = set_src_cost (SET_SRC (set), speed);
       inv->cheap_address = false;
     }
 
Index: gcc/optabs.c
===================================================================
--- gcc/optabs.c	2011-08-15 11:20:37.849148590 +0100
+++ gcc/optabs.c	2011-08-15 11:53:01.576885683 +0100
@@ -1218,7 +1218,7 @@  avoid_expensive_constant (enum machine_m
   if (mode != VOIDmode
       && optimize
       && CONSTANT_P (x)
-      && rtx_cost (x, binoptab->code, speed) > rtx_cost (x, SET, speed))
+      && rtx_cost (x, binoptab->code, speed) > set_src_cost (x, speed))
     {
       if (CONST_INT_P (x))
 	{
Index: gcc/postreload.c
===================================================================
--- gcc/postreload.c	2011-08-15 11:20:37.849148590 +0100
+++ gcc/postreload.c	2011-08-15 11:53:01.580885671 +0100
@@ -275,7 +275,7 @@  reload_cse_simplify_set (rtx set, rtx in
     old_cost = register_move_cost (GET_MODE (src),
 				   REGNO_REG_CLASS (REGNO (src)), dclass);
   else
-    old_cost = rtx_cost (src, SET, speed);
+    old_cost = set_src_cost (src, speed);
 
   for (l = val->locs; l; l = l->next)
     {
@@ -310,7 +310,7 @@  reload_cse_simplify_set (rtx set, rtx in
 	      this_rtx = GEN_INT (this_val);
 	    }
 #endif
-	  this_cost = rtx_cost (this_rtx, SET, speed);
+	  this_cost = set_src_cost (this_rtx, speed);
 	}
       else if (REG_P (this_rtx))
 	{
@@ -318,7 +318,7 @@  reload_cse_simplify_set (rtx set, rtx in
 	  if (extend_op != UNKNOWN)
 	    {
 	      this_rtx = gen_rtx_fmt_e (extend_op, word_mode, this_rtx);
-	      this_cost = rtx_cost (this_rtx, SET, speed);
+	      this_cost = set_src_cost (this_rtx, speed);
 	    }
 	  else
 #endif
@@ -579,10 +579,12 @@  reload_cse_simplify_operands (rtx insn, 
 		      && recog_data.alternative_enabled_p[j]
 		      && reg_fits_class_p (testreg, rclass, 0, mode)
 		      && (!CONST_INT_P (recog_data.operand[i])
-			  || (rtx_cost (recog_data.operand[i], SET,
-			  		optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn)))
-			      > rtx_cost (testreg, SET,
-			  		optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn))))))
+			  || (set_src_cost (recog_data.operand[i],
+					    optimize_bb_for_speed_p
+					     (BLOCK_FOR_INSN (insn)))
+			      > set_src_cost (testreg,
+					      optimize_bb_for_speed_p
+					       (BLOCK_FOR_INSN (insn))))))
 		    {
 		      alternative_nregs[j]++;
 		      op_alt_regno[i][j] = regno;
@@ -916,12 +918,12 @@  try_replace_in_use (struct reg_use *use,
 	  && CONSTANT_P (XEXP (SET_SRC (new_set), 1)))
 	{
 	  rtx new_src;
-	  int old_cost = rtx_cost (SET_SRC (new_set), SET, speed);
+	  int old_cost = set_src_cost (SET_SRC (new_set), speed);
 
 	  gcc_assert (rtx_equal_p (XEXP (SET_SRC (new_set), 0), reg));
 	  new_src = simplify_replace_rtx (SET_SRC (new_set), reg, src);
 
-	  if (rtx_cost (new_src, SET, speed) <= old_cost
+	  if (set_src_cost (new_src, speed) <= old_cost
 	      && validate_change (use_insn, &SET_SRC (new_set),
 				  new_src, 0))
 	    return true;
@@ -1683,9 +1685,9 @@  move2add_use_add2_insn (rtx reg, rtx sym
       struct full_rtx_costs oldcst, newcst;
       rtx tem = gen_rtx_PLUS (GET_MODE (reg), reg, new_src);
 
-      get_full_rtx_cost (pat, SET, &oldcst);
+      get_full_set_src_cost (pat, &oldcst);
       SET_SRC (pat) = tem;
-      get_full_rtx_cost (pat, SET, &newcst);
+      get_full_set_src_cost (pat, &newcst);
       SET_SRC (pat) = src;
 
       if (costs_lt_p (&newcst, &oldcst, speed)
@@ -1752,7 +1754,7 @@  move2add_use_add3_insn (rtx reg, rtx sym
   rtx plus_expr;
 
   init_costs_to_max (&mincst);
-  get_full_rtx_cost (pat, SET, &oldcst);
+  get_full_set_src_cost (pat, &oldcst);
 
   plus_expr = gen_rtx_PLUS (GET_MODE (reg), reg, const0_rtx);
   SET_SRC (pat) = plus_expr;
@@ -1781,7 +1783,7 @@  move2add_use_add3_insn (rtx reg, rtx sym
 	else
 	  {
 	    XEXP (plus_expr, 1) = new_src;
-	    get_full_rtx_cost (pat, SET, &newcst);
+	    get_full_set_src_cost (pat, &newcst);
 
 	    if (costs_lt_p (&newcst, &mincst, speed))
 	      {
@@ -1934,9 +1936,9 @@  reload_cse_move2add (rtx first)
 			  struct full_rtx_costs oldcst, newcst;
 			  rtx tem = gen_rtx_PLUS (GET_MODE (reg), reg, new_src);
 
-			  get_full_rtx_cost (set, SET, &oldcst);
+			  get_full_set_src_cost (set, &oldcst);
 			  SET_SRC (set) = tem;
-			  get_full_rtx_cost (tem, SET, &newcst);
+			  get_full_set_src_cost (tem, &newcst);
 			  SET_SRC (set) = old_src;
 			  costs_add_n_insns (&oldcst, 1);
 
Index: gcc/reload1.c
===================================================================
--- gcc/reload1.c	2011-08-15 11:20:37.850148588 +0100
+++ gcc/reload1.c	2011-08-15 11:53:01.583885662 +0100
@@ -1646,8 +1646,7 @@  calculate_elim_costs_all_insns (void)
 		    {
 		      rtx t = eliminate_regs_1 (SET_SRC (set), VOIDmode, insn,
 						false, true);
-		      int cost = rtx_cost (t, SET,
-					   optimize_bb_for_speed_p (bb));
+		      int cost = set_src_cost (t, optimize_bb_for_speed_p (bb));
 		      int freq = REG_FREQ_FROM_BB (bb);
 
 		      reg_equiv_init_cost[regno] = cost * freq;
@@ -2505,7 +2504,7 @@  note_reg_elim_costly (rtx *px, void *dat
     {
       rtx t = reg_equiv_invariant (REGNO (x));
       rtx new_rtx = eliminate_regs_1 (t, Pmode, insn, true, true);
-      int cost = rtx_cost (new_rtx, SET, optimize_bb_for_speed_p (elim_bb));
+      int cost = set_src_cost (new_rtx, optimize_bb_for_speed_p (elim_bb));
       int freq = REG_FREQ_FROM_BB (elim_bb);
 
       if (cost != 0)
Index: gcc/rtlanal.c
===================================================================
--- gcc/rtlanal.c	2011-08-15 11:20:37.835148629 +0100
+++ gcc/rtlanal.c	2011-08-15 11:53:01.612885587 +0100
@@ -4782,7 +4782,7 @@  insn_rtx_cost (rtx pat, bool speed)
   else
     return 0;
 
-  cost = rtx_cost (SET_SRC (set), SET, speed);
+  cost = set_src_cost (SET_SRC (set), speed);
   return cost > 0 ? cost : COSTS_N_INSNS (1);
 }
 
Index: gcc/simplify-rtx.c
===================================================================
--- gcc/simplify-rtx.c	2011-08-15 11:20:37.835148629 +0100
+++ gcc/simplify-rtx.c	2011-08-15 11:53:01.625885549 +0100
@@ -2033,7 +2033,7 @@  simplify_binary_operation_1 (enum rtx_co
 	      coeff = immed_double_int_const (val, mode);
 
 	      tem = simplify_gen_binary (MULT, mode, lhs, coeff);
-	      return rtx_cost (tem, SET, speed) <= rtx_cost (orig, SET, speed)
+	      return set_src_cost (tem, speed) <= set_src_cost (orig, speed)
 		? tem : 0;
 	    }
 	}
@@ -2214,7 +2214,7 @@  simplify_binary_operation_1 (enum rtx_co
 	      coeff = immed_double_int_const (val, mode);
 
 	      tem = simplify_gen_binary (MULT, mode, lhs, coeff);
-	      return rtx_cost (tem, SET, speed) <= rtx_cost (orig, SET, speed)
+	      return set_src_cost (tem, speed) <= set_src_cost (orig, speed)
 		? tem : 0;
 	    }
 	}
Index: gcc/stmt.c
===================================================================
--- gcc/stmt.c	2011-08-15 11:20:37.850148588 +0100
+++ gcc/stmt.c	2011-08-15 11:53:01.662885448 +0100
@@ -2131,8 +2131,8 @@  bool lshift_cheap_p (void)
   if (!init[speed_p])
     {
       rtx reg = gen_rtx_REG (word_mode, 10000);
-      int cost = rtx_cost (gen_rtx_ASHIFT (word_mode, const1_rtx, reg), SET,
-      			   speed_p);
+      int cost = set_src_cost (gen_rtx_ASHIFT (word_mode, const1_rtx, reg),
+			       speed_p);
       cheap[speed_p] = cost < COSTS_N_INSNS (3);
       init[speed_p] = true;
     }
Index: gcc/tree-ssa-loop-ivopts.c
===================================================================
--- gcc/tree-ssa-loop-ivopts.c	2011-08-15 11:20:37.835148629 +0100
+++ gcc/tree-ssa-loop-ivopts.c	2011-08-15 11:53:01.674885416 +0100
@@ -2754,7 +2754,7 @@  seq_cost (rtx seq, bool speed)
     {
       set = single_set (seq);
       if (set)
-	cost += rtx_cost (SET_SRC (set), SET, speed);
+	cost += set_src_cost (SET_SRC (set), speed);
       else
 	cost++;
     }
@@ -2876,7 +2876,7 @@  computation_cost (tree expr, bool speed)
     cost += address_cost (XEXP (rslt, 0), TYPE_MODE (type),
 			  TYPE_ADDR_SPACE (type), speed);
   else if (!REG_P (rslt))
-    cost += rtx_cost (rslt, SET, speed);
+    cost += set_src_cost (rslt, speed);
 
   return cost;
 }
Index: gcc/config/avr/avr.c
===================================================================
--- gcc/config/avr/avr.c	2011-08-15 11:20:37.820148669 +0100
+++ gcc/config/avr/avr.c	2011-08-15 11:53:01.461885995 +0100
@@ -1637,7 +1637,7 @@  final_prescan_insn (rtx insn, rtx *opera
 
       if (set)
         fprintf (asm_out_file, "/* DEBUG: cost = %d.  */\n",
-                 rtx_cost (SET_SRC (set), SET, optimize_insn_for_speed_p()));
+                 set_src_cost (SET_SRC (set), optimize_insn_for_speed_p ()));
       else
         fprintf (asm_out_file, "/* DEBUG: pattern-cost = %d.  */\n",
                  rtx_cost (PATTERN (insn), INSN, optimize_insn_for_speed_p()));
Index: gcc/config/bfin/bfin.c
===================================================================
--- gcc/config/bfin/bfin.c	2011-08-15 11:20:37.820148669 +0100
+++ gcc/config/bfin/bfin.c	2011-08-15 11:53:01.470885971 +0100
@@ -2837,11 +2837,11 @@  bfin_rtx_costs (rtx x, int code_i, int o
 	  *total = cost2;
 	  if (GET_CODE (op0) != REG
 	      && (GET_CODE (op0) != SUBREG || GET_CODE (SUBREG_REG (op0)) != REG))
-	    *total += rtx_cost (op0, SET, speed);
+	    *total += set_src_cost (op0, speed);
 #if 0 /* We'd like to do this for accuracy, but it biases the loop optimizer
 	 towards creating too many induction variables.  */
 	  if (!reg_or_7bit_operand (op1, SImode))
-	    *total += rtx_cost (op1, SET, speed);
+	    *total += set_src_cost (op1, speed);
 #endif
 	}
       else if (GET_MODE (x) == DImode)
Index: gcc/config/mips/mips.c
===================================================================
--- gcc/config/mips/mips.c	2011-08-15 11:20:37.819148672 +0100
+++ gcc/config/mips/mips.c	2011-08-15 11:53:01.478885948 +0100
@@ -3333,7 +3333,7 @@  mips_binary_cost (rtx x, int single_cost
   else
     cost = single_cost;
   return (cost
-	  + rtx_cost (XEXP (x, 0), SET, speed)
+	  + set_src_cost (XEXP (x, 0), speed)
 	  + rtx_cost (XEXP (x, 1), GET_CODE (x), speed));
 }
 
@@ -3550,7 +3550,7 @@  mips_rtx_costs (rtx x, int code, int out
 	  && UINTVAL (XEXP (x, 1)) == 0xffffffff)
 	{
 	  *total = (mips_zero_extend_cost (mode, XEXP (x, 0))
-		    + rtx_cost (XEXP (x, 0), SET, speed));
+		    + set_src_cost (XEXP (x, 0), speed));
 	  return true;
 	}
       /* Fall through.  */
@@ -3585,7 +3585,7 @@  mips_rtx_costs (rtx x, int code, int out
     case LO_SUM:
       /* Low-part immediates need an extended MIPS16 instruction.  */
       *total = (COSTS_N_INSNS (TARGET_MIPS16 ? 2 : 1)
-		+ rtx_cost (XEXP (x, 0), SET, speed));
+		+ set_src_cost (XEXP (x, 0), speed));
       return true;
 
     case LT:
@@ -3626,17 +3626,17 @@  mips_rtx_costs (rtx x, int code, int out
 	  if (GET_CODE (op0) == MULT && GET_CODE (XEXP (op0, 0)) == NEG)
 	    {
 	      *total = (mips_fp_mult_cost (mode)
-			+ rtx_cost (XEXP (XEXP (op0, 0), 0), SET, speed)
-			+ rtx_cost (XEXP (op0, 1), SET, speed)
-			+ rtx_cost (op1, SET, speed));
+			+ set_src_cost (XEXP (XEXP (op0, 0), 0), speed)
+			+ set_src_cost (XEXP (op0, 1), speed)
+			+ set_src_cost (op1, speed));
 	      return true;
 	    }
 	  if (GET_CODE (op1) == MULT)
 	    {
 	      *total = (mips_fp_mult_cost (mode)
-			+ rtx_cost (op0, SET, speed)
-			+ rtx_cost (XEXP (op1, 0), SET, speed)
-			+ rtx_cost (XEXP (op1, 1), SET, speed));
+			+ set_src_cost (op0, speed)
+			+ set_src_cost (XEXP (op1, 0), speed)
+			+ set_src_cost (XEXP (op1, 1), speed));
 	      return true;
 	    }
 	}
@@ -3678,9 +3678,9 @@  mips_rtx_costs (rtx x, int code, int out
 	      && GET_CODE (XEXP (op, 0)) == MULT)
 	    {
 	      *total = (mips_fp_mult_cost (mode)
-			+ rtx_cost (XEXP (XEXP (op, 0), 0), SET, speed)
-			+ rtx_cost (XEXP (XEXP (op, 0), 1), SET, speed)
-			+ rtx_cost (XEXP (op, 1), SET, speed));
+			+ set_src_cost (XEXP (XEXP (op, 0), 0), speed)
+			+ set_src_cost (XEXP (XEXP (op, 0), 1), speed)
+			+ set_src_cost (XEXP (op, 1), speed));
 	      return true;
 	    }
 	}
@@ -3718,10 +3718,10 @@  mips_rtx_costs (rtx x, int code, int out
 	  if (outer_code == SQRT || GET_CODE (XEXP (x, 1)) == SQRT)
 	    /* An rsqrt<mode>a or rsqrt<mode>b pattern.  Count the
 	       division as being free.  */
-	    *total = rtx_cost (XEXP (x, 1), SET, speed);
+	    *total = set_src_cost (XEXP (x, 1), speed);
 	  else
 	    *total = (mips_fp_div_cost (mode)
-		      + rtx_cost (XEXP (x, 1), SET, speed));
+		      + set_src_cost (XEXP (x, 1), speed));
 	  return true;
 	}
       /* Fall through.  */
@@ -3749,7 +3749,7 @@  mips_rtx_costs (rtx x, int code, int out
 	      && CONST_INT_P (XEXP (x, 1))
 	      && exact_log2 (INTVAL (XEXP (x, 1))) >= 0)
 	    {
-	      *total = COSTS_N_INSNS (2) + rtx_cost (XEXP (x, 0), SET, speed);
+	      *total = COSTS_N_INSNS (2) + set_src_cost (XEXP (x, 0), speed);
 	      return true;
 	    }
 	  *total = COSTS_N_INSNS (mips_idiv_insns ());