From patchwork Mon Aug 15 14:56:41 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 110045 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id A05E4B6F67 for ; Tue, 16 Aug 2011 00:57:18 +1000 (EST) Received: (qmail 7691 invoked by alias); 15 Aug 2011 14:57:13 -0000 Received: (qmail 7661 invoked by uid 22791); 15 Aug 2011 14:57:08 -0000 X-SWARE-Spam-Status: No, hits=-2.4 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_LOW, TW_FW X-Spam-Check-By: sourceware.org Received: from mail-fx0-f47.google.com (HELO mail-fx0-f47.google.com) (209.85.161.47) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 15 Aug 2011 14:56:46 +0000 Received: by fxg11 with SMTP id 11so4063262fxg.20 for ; Mon, 15 Aug 2011 07:56:45 -0700 (PDT) Received: by 10.223.53.77 with SMTP id l13mr5470186fag.93.1313420205069; Mon, 15 Aug 2011 07:56:45 -0700 (PDT) Received: from richards-thinkpad.stglab.manchester.uk.ibm.com (gbibp9ph1--blueice3n2.emea.ibm.com [195.212.29.84]) by mx.google.com with ESMTPS id s14sm3260650fah.29.2011.08.15.07.56.42 (version=TLSv1/SSLv3 cipher=OTHER); Mon, 15 Aug 2011 07:56:43 -0700 (PDT) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@linaro.org Subject: Add a set_src_cost wrapper function Date: Mon, 15 Aug 2011 15:56:41 +0100 Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.2 (gnu/linux) MIME-Version: 1.0 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org 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 rsqrta or rsqrtb 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 ());