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.
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 ());
