From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2472 invoked by alias); 26 May 2016 17:12:14 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 2455 invoked by uid 89); 26 May 2016 17:12:14 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.9 required=5.0 tests=BAYES_00,SPF_PASS autolearn=ham version=3.3.2 spammy=COST, subtraction, D*cz, somebody X-HELO: mx2.suse.de Received: from mx2.suse.de (HELO mx2.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (CAMELLIA256-SHA encrypted) ESMTPS; Thu, 26 May 2016 17:12:03 +0000 Received: from relay1.suse.de (charybdis-ext.suse.de [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id 2B6C5AB5D; Thu, 26 May 2016 17:12:00 +0000 (UTC) Subject: Re: [PATCH 1/3] Encapsulate comp_cost within a class with methods. To: "Bin.Cheng" References: <5739D143.1070300@suse.cz> <573D941C.4070507@suse.cz> Cc: gcc-patches List From: =?UTF-8?Q?Martin_Li=c5=a1ka?= Message-ID: <57472E5F.201@suse.cz> Date: Thu, 26 May 2016 21:02:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.7.2 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------060405060109010603000708" X-IsSubscribed: yes X-SW-Source: 2016-05/txt/msg02131.txt.bz2 This is a multi-part message in MIME format. --------------060405060109010603000708 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Content-length: 2299 On 05/19/2016 01:24 PM, Bin.Cheng wrote: > On Thu, May 19, 2016 at 11:23 AM, Martin Liška wrote: >> On 05/16/2016 03:55 PM, Martin Liška wrote: >>> On 05/16/2016 12:13 PM, Bin.Cheng wrote: >>>> Hi Martin, >>>> Could you please rebase this patch and the profiling one against >>>> latest trunk? The third patch was applied before these two now. >>>> >>>> Thanks, >>>> bin >>> >>> Hello. >>> >>> Sending the rebased version of the patch. >>> >>> Martin >>> >> >> Hello. >> >> As I've dramatically changed the 2/3 PATCH, a class encapsulation is not needed any longer. >> Thus, I've reduced this patch just to usage of member function/operators that are useful >> in my eyes. It's up the Bin whether to merge the patch? > Yes, I think we want c++-ify such structures. > >> +comp_cost >> +operator- (comp_cost cost1, comp_cost cost2) >> +{ >> + if (cost1.infinite_cost_p () || cost2.infinite_cost_p ()) >> + return comp_cost::get_infinite (); >> + >> + cost1.cost -= cost2.cost; >> + cost1.complexity -= cost2.complexity; >> + >> + return cost1; >> +} > For subtraction, should we expect the second operand as infinite? > Maybe add an assertion for it in case anything goes wrong here. Hi. Done. > >> +comp_cost >> +comp_cost::get_infinite () >> +{ >> + return comp_cost (INFTY, INFTY); >> +} >> + >> +comp_cost >> +comp_cost::get_no_cost () >> +{ >> + return comp_cost (); >> +} > I think we may keep the original global variables for > no_cost&infinite_cost, and save these two methods. Likewise. >> >> @@ -5982,11 +6083,11 @@ iv_ca_recount_cost (struct ivopts_data *data, struct iv_ca *ivs) >> { >> comp_cost cost = ivs->cand_use_cost; >> >> - cost.cost += ivs->cand_cost; >> + cost+= ivs->cand_cost; > Space. Likewise. > > This is pure refactoring, could you please make sure there is no falls > out by simply comparing SPEC code generation/disassembly? I am asking > since cost computation is sensitive, last time we didn't catch a "*" > character typo in dump info improvement patch. I've just verified that code generation for SPECv6 is unchanged and I'm going to install the patch. Thanks, Martin > > Okay with above changes, unless somebody else has comment on the C++ > part (which I know very little about). > > Thanks, > bin >> >> Martin --------------060405060109010603000708 Content-Type: text/x-patch; name="0001-IVOPTS-make-comp_cost-in-a-more-c-fashion.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="0001-IVOPTS-make-comp_cost-in-a-more-c-fashion.patch" Content-length: 25585 >From 6379f77c195ed128c4886c07747bf9b8b678c75c Mon Sep 17 00:00:00 2001 From: marxin Date: Tue, 17 May 2016 13:52:11 +0200 Subject: [PATCH] IVOPTS: make comp_cost in a more c++ fashion. gcc/ChangeLog: 2016-05-17 Martin Liska * tree-ssa-loop-ivopts.c (comp_cost::infinite_cost_p): New function. (operator+): Likewise. (operator-): Likewise. (comp_cost::operator+=): Likewise. (comp_cost::operator-=): Likewise. (comp_cost::operator/=): Likewise. (comp_cost::operator*=): Likewise. (operator<): Likewise. (operator==): Likewise. (operator<=): Likewise. (new_cost): Remove. (infinite_cost_p): Likewise. (add_costs): Likewise. (sub_costs): Likewise. (compare_costs): Likewise. (set_group_iv_cost): Use the newly introduced functions. (get_address_cost): Likewise. (get_shiftadd_cost): Likewise. (force_expr_to_var_cost): Likewise. (split_address_cost): Likewise. (ptr_difference_cost): Likewise. (difference_cost): Likewise. (get_computation_cost_at): Likewise. (determine_group_iv_cost_generic): Likewise. (determine_group_iv_cost_address): Likewise. (determine_group_iv_cost_cond): Likewise. (autoinc_possible_for_pair): Likewise. (determine_group_iv_costs): Likewise. (cheaper_cost_pair): Likewise. (iv_ca_recount_cost): Likewise. (iv_ca_set_no_cp): Likewise. (iv_ca_set_cp): Likewise. (iv_ca_cost): Likewise. (iv_ca_new): Likewise. (iv_ca_dump): Likewise. (iv_ca_narrow): Likewise. (iv_ca_prune): Likewise. (iv_ca_replace): Likewise. (try_add_cand_for): Likewise. (try_improve_iv_set): Likewise. (find_optimal_iv_set): Likewise. --- gcc/tree-ssa-loop-ivopts.c | 380 ++++++++++++++++++++++++++++----------------- 1 file changed, 235 insertions(+), 145 deletions(-) diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 9ce6b64..83b9aaf 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -173,16 +173,171 @@ enum use_type /* Cost of a computation. */ struct comp_cost { + comp_cost (): cost (0), complexity (0), scratch (0) + {} + + comp_cost (int cost, unsigned complexity, int scratch = 0) + : cost (cost), complexity (complexity), scratch (scratch) + {} + + /* Returns true if COST is infinite. */ + bool infinite_cost_p (); + + /* Adds costs COST1 and COST2. */ + friend comp_cost operator+ (comp_cost cost1, comp_cost cost2); + + /* Adds COST to the comp_cost. */ + comp_cost operator+= (comp_cost cost); + + /* Adds constant C to this comp_cost. */ + comp_cost operator+= (HOST_WIDE_INT c); + + /* Subtracts constant C to this comp_cost. */ + comp_cost operator-= (HOST_WIDE_INT c); + + /* Divide the comp_cost by constant C. */ + comp_cost operator/= (HOST_WIDE_INT c); + + /* Multiply the comp_cost by constant C. */ + comp_cost operator*= (HOST_WIDE_INT c); + + /* Subtracts costs COST1 and COST2. */ + friend comp_cost operator- (comp_cost cost1, comp_cost cost2); + + /* Subtracts COST from this comp_cost. */ + comp_cost operator-= (comp_cost cost); + + /* Returns true if COST1 is smaller than COST2. */ + friend bool operator< (comp_cost cost1, comp_cost cost2); + + /* Returns true if COST1 and COST2 are equal. */ + friend bool operator== (comp_cost cost1, comp_cost cost2); + + /* Returns true if COST1 is smaller or equal than COST2. */ + friend bool operator<= (comp_cost cost1, comp_cost cost2); + int cost; /* The runtime cost. */ - unsigned complexity; /* The estimate of the complexity of the code for + unsigned complexity; /* The estimate of the complexity of the code for the computation (in no concrete units -- complexity field should be larger for more complex expressions and addressing modes). */ int scratch; /* Scratch used during cost computation. */ }; -static const comp_cost no_cost = {0, 0, 0}; -static const comp_cost infinite_cost = {INFTY, INFTY, INFTY}; +static const comp_cost no_cost; +static const comp_cost infinite_cost (INFTY, INFTY, INFTY); + +bool +comp_cost::infinite_cost_p () +{ + return cost == INFTY; +} + +comp_cost +operator+ (comp_cost cost1, comp_cost cost2) +{ + if (cost1.infinite_cost_p () || cost2.infinite_cost_p ()) + return infinite_cost; + + cost1.cost += cost2.cost; + cost1.complexity += cost2.complexity; + + return cost1; +} + +comp_cost +operator- (comp_cost cost1, comp_cost cost2) +{ + if (cost1.infinite_cost_p ()) + return infinite_cost; + + gcc_assert (!cost2.infinite_cost_p ()); + + cost1.cost -= cost2.cost; + cost1.complexity -= cost2.complexity; + + return cost1; +} + +comp_cost +comp_cost::operator+= (comp_cost cost) +{ + *this = *this + cost; + return *this; +} + +comp_cost +comp_cost::operator+= (HOST_WIDE_INT c) +{ + if (infinite_cost_p ()) + return *this; + + this->cost += c; + + return *this; +} + +comp_cost +comp_cost::operator-= (HOST_WIDE_INT c) +{ + if (infinite_cost_p ()) + return *this; + + this->cost -= c; + + return *this; +} + +comp_cost +comp_cost::operator/= (HOST_WIDE_INT c) +{ + if (infinite_cost_p ()) + return *this; + + this->cost /= c; + + return *this; +} + +comp_cost +comp_cost::operator*= (HOST_WIDE_INT c) +{ + if (infinite_cost_p ()) + return *this; + + this->cost *= c; + + return *this; +} + +comp_cost +comp_cost::operator-= (comp_cost cost) +{ + *this = *this - cost; + return *this; +} + +bool +operator< (comp_cost cost1, comp_cost cost2) +{ + if (cost1.cost == cost2.cost) + return cost1.complexity < cost2.complexity; + + return cost1.cost < cost2.cost; +} + +bool +operator== (comp_cost cost1, comp_cost cost2) +{ + return cost1.cost == cost2.cost + && cost1.complexity == cost2.complexity; +} + +bool +operator<= (comp_cost cost1, comp_cost cost2) +{ + return cost1 < cost2 || cost1 == cost2; +} struct iv_inv_expr_ent; @@ -3284,64 +3439,6 @@ alloc_use_cost_map (struct ivopts_data *data) } } -/* Returns description of computation cost of expression whose runtime - cost is RUNTIME and complexity corresponds to COMPLEXITY. */ - -static comp_cost -new_cost (unsigned runtime, unsigned complexity) -{ - comp_cost cost; - - cost.cost = runtime; - cost.complexity = complexity; - - return cost; -} - -/* Returns true if COST is infinite. */ - -static bool -infinite_cost_p (comp_cost cost) -{ - return cost.cost == INFTY; -} - -/* Adds costs COST1 and COST2. */ - -static comp_cost -add_costs (comp_cost cost1, comp_cost cost2) -{ - if (infinite_cost_p (cost1) || infinite_cost_p (cost2)) - return infinite_cost; - - cost1.cost += cost2.cost; - cost1.complexity += cost2.complexity; - - return cost1; -} -/* Subtracts costs COST1 and COST2. */ - -static comp_cost -sub_costs (comp_cost cost1, comp_cost cost2) -{ - cost1.cost -= cost2.cost; - cost1.complexity -= cost2.complexity; - - return cost1; -} - -/* Returns a negative number if COST1 < COST2, a positive number if - COST1 > COST2, and 0 if COST1 = COST2. */ - -static int -compare_costs (comp_cost cost1, comp_cost cost2) -{ - if (cost1.cost == cost2.cost) - return cost1.complexity - cost2.complexity; - - return cost1.cost - cost2.cost; -} - /* Sets cost of (GROUP, CAND) pair to COST and record that it depends on invariants DEPENDS_ON and that the value used in expressing it is VALUE, and in case of iv elimination the comparison operator is COMP. */ @@ -3354,7 +3451,7 @@ set_group_iv_cost (struct ivopts_data *data, { unsigned i, s; - if (infinite_cost_p (cost)) + if (cost.infinite_cost_p ()) { BITMAP_FREE (depends_on); return; @@ -4170,7 +4267,7 @@ get_address_cost (bool symbol_present, bool var_present, else acost = data->costs[symbol_present][var_present][offset_p][ratio_p]; complexity = (symbol_present != 0) + (var_present != 0) + offset_p + ratio_p; - return new_cost (cost + acost, complexity); + return comp_cost (cost + acost, complexity); } /* Calculate the SPEED or size cost of shiftadd EXPR in MODE. MULT is the @@ -4207,12 +4304,12 @@ get_shiftadd_cost (tree expr, machine_mode mode, comp_cost cost0, ? shiftsub1_cost (speed, mode, m) : shiftsub0_cost (speed, mode, m))); - res = new_cost (MIN (as_cost, sa_cost), 0); - res = add_costs (res, mult_in_op1 ? cost0 : cost1); + res = comp_cost (MIN (as_cost, sa_cost), 0); + res += (mult_in_op1 ? cost0 : cost1); STRIP_NOPS (multop); if (!is_gimple_val (multop)) - res = add_costs (res, force_expr_to_var_cost (multop, speed)); + res += force_expr_to_var_cost (multop, speed); *cost = res; return true; @@ -4277,7 +4374,7 @@ force_expr_to_var_cost (tree expr, bool speed) if (is_gimple_min_invariant (expr)) { if (TREE_CODE (expr) == INTEGER_CST) - return new_cost (integer_cost [speed], 0); + return comp_cost (integer_cost [speed], 0); if (TREE_CODE (expr) == ADDR_EXPR) { @@ -4286,10 +4383,10 @@ force_expr_to_var_cost (tree expr, bool speed) if (TREE_CODE (obj) == VAR_DECL || TREE_CODE (obj) == PARM_DECL || TREE_CODE (obj) == RESULT_DECL) - return new_cost (symbol_cost [speed], 0); + return comp_cost (symbol_cost [speed], 0); } - return new_cost (address_cost [speed], 0); + return comp_cost (address_cost [speed], 0); } switch (TREE_CODE (expr)) @@ -4313,7 +4410,7 @@ force_expr_to_var_cost (tree expr, bool speed) default: /* Just an arbitrary value, FIXME. */ - return new_cost (target_spill_cost[speed], 0); + return comp_cost (target_spill_cost[speed], 0); } if (op0 == NULL_TREE @@ -4335,7 +4432,7 @@ force_expr_to_var_cost (tree expr, bool speed) case PLUS_EXPR: case MINUS_EXPR: case NEGATE_EXPR: - cost = new_cost (add_cost (speed, mode), 0); + cost = comp_cost (add_cost (speed, mode), 0); if (TREE_CODE (expr) != NEGATE_EXPR) { tree mult = NULL_TREE; @@ -4358,28 +4455,28 @@ force_expr_to_var_cost (tree expr, bool speed) tree inner_mode, outer_mode; outer_mode = TREE_TYPE (expr); inner_mode = TREE_TYPE (op0); - cost = new_cost (convert_cost (TYPE_MODE (outer_mode), + cost = comp_cost (convert_cost (TYPE_MODE (outer_mode), TYPE_MODE (inner_mode), speed), 0); } break; case MULT_EXPR: if (cst_and_fits_in_hwi (op0)) - cost = new_cost (mult_by_coeff_cost (int_cst_value (op0), + cost = comp_cost (mult_by_coeff_cost (int_cst_value (op0), mode, speed), 0); else if (cst_and_fits_in_hwi (op1)) - cost = new_cost (mult_by_coeff_cost (int_cst_value (op1), + cost = comp_cost (mult_by_coeff_cost (int_cst_value (op1), mode, speed), 0); else - return new_cost (target_spill_cost [speed], 0); + return comp_cost (target_spill_cost [speed], 0); break; default: gcc_unreachable (); } - cost = add_costs (cost, cost0); - cost = add_costs (cost, cost1); + cost += cost0; + cost += cost1; /* Bound the cost by target_spill_cost. The parts of complicated computations often are either loop invariant or at least can @@ -4438,7 +4535,7 @@ split_address_cost (struct ivopts_data *data, if (depends_on) walk_tree (&addr, find_depends, depends_on, NULL); - return new_cost (target_spill_cost[data->speed], 0); + return comp_cost (target_spill_cost[data->speed], 0); } *offset += bitpos / BITS_PER_UNIT; @@ -4538,7 +4635,7 @@ difference_cost (struct ivopts_data *data, if (integer_zerop (e1)) { comp_cost cost = force_var_cost (data, e2, depends_on); - cost.cost += mult_by_coeff_cost (-1, mode, data->speed); + cost += mult_by_coeff_cost (-1, mode, data->speed); return cost; } @@ -4805,7 +4902,7 @@ get_computation_cost_at (struct ivopts_data *data, ubase, build_int_cst (utype, 0), &symbol_present, &var_present, &offset, depends_on); - cost.cost /= avg_loop_niter (data->current_loop); + cost /= avg_loop_niter (data->current_loop); } else if (ratio == 1) { @@ -4829,7 +4926,7 @@ get_computation_cost_at (struct ivopts_data *data, ubase, real_cbase, &symbol_present, &var_present, &offset, depends_on); - cost.cost /= avg_loop_niter (data->current_loop); + cost /= avg_loop_niter (data->current_loop); } else if (address_p && !POINTER_TYPE_P (ctype) @@ -4852,21 +4949,19 @@ get_computation_cost_at (struct ivopts_data *data, ubase, real_cbase, &symbol_present, &var_present, &offset, depends_on); - cost.cost /= avg_loop_niter (data->current_loop); + cost /= avg_loop_niter (data->current_loop); } else { cost = force_var_cost (data, cbase, depends_on); - cost = add_costs (cost, - difference_cost (data, - ubase, build_int_cst (utype, 0), - &symbol_present, &var_present, - &offset, depends_on)); - cost.cost /= avg_loop_niter (data->current_loop); - cost.cost += add_cost (data->speed, TYPE_MODE (ctype)); + cost += difference_cost (data, ubase, build_int_cst (utype, 0), + &symbol_present, &var_present, &offset, + depends_on); + cost /= avg_loop_niter (data->current_loop); + cost += add_cost (data->speed, TYPE_MODE (ctype)); } - /* Record setup cost in scrach field. */ + /* Record setup cost in scratch field. */ cost.scratch = cost.cost; if (inv_expr && depends_on && *depends_on) @@ -4887,26 +4982,24 @@ get_computation_cost_at (struct ivopts_data *data, (symbol/var1/const parts may be omitted). If we are looking for an address, find the cost of addressing this. */ if (address_p) - return add_costs (cost, - get_address_cost (symbol_present, var_present, - offset, ratio, cstepi, - mem_mode, - TYPE_ADDR_SPACE (TREE_TYPE (utype)), - speed, stmt_is_after_inc, - can_autoinc)); + return cost + get_address_cost (symbol_present, var_present, + offset, ratio, cstepi, + mem_mode, + TYPE_ADDR_SPACE (TREE_TYPE (utype)), + speed, stmt_is_after_inc, can_autoinc); /* Otherwise estimate the costs for computing the expression. */ if (!symbol_present && !var_present && !offset) { if (ratio != 1) - cost.cost += mult_by_coeff_cost (ratio, TYPE_MODE (ctype), speed); + cost += mult_by_coeff_cost (ratio, TYPE_MODE (ctype), speed); return cost; } /* Symbol + offset should be compile-time computable so consider that they are added once to the variable, if present. */ if (var_present && (symbol_present || offset)) - cost.cost += adjust_setup_cost (data, + cost += adjust_setup_cost (data, add_cost (speed, TYPE_MODE (ctype))); /* Having offset does not affect runtime cost in case it is added to @@ -4914,11 +5007,11 @@ get_computation_cost_at (struct ivopts_data *data, if (offset) cost.complexity++; - cost.cost += add_cost (speed, TYPE_MODE (ctype)); + cost += add_cost (speed, TYPE_MODE (ctype)); aratio = ratio > 0 ? ratio : -ratio; if (aratio != 1) - cost.cost += mult_by_coeff_cost (aratio, TYPE_MODE (ctype), speed); + cost += mult_by_coeff_cost (aratio, TYPE_MODE (ctype), speed); return cost; fallback: @@ -4935,9 +5028,7 @@ fallback: if (address_p) comp = build_simple_mem_ref (comp); - cost = new_cost (computation_cost (comp, speed), 0); - cost.scratch = 0; - return cost; + return comp_cost (computation_cost (comp, speed), 0); } } @@ -4983,7 +5074,7 @@ determine_group_iv_cost_generic (struct ivopts_data *data, set_group_iv_cost (data, group, cand, cost, depends_on, NULL_TREE, ERROR_MARK, inv_expr); - return !infinite_cost_p (cost); + return !cost.infinite_cost_p (); } /* Determines cost of computing uses in GROUP with CAND in addresses. */ @@ -5003,10 +5094,10 @@ determine_group_iv_cost_address (struct ivopts_data *data, &depends_on, &can_autoinc, &inv_expr); sum_cost = cost; - if (!infinite_cost_p (sum_cost) && cand->ainc_use == use) + if (!sum_cost.infinite_cost_p () && cand->ainc_use == use) { if (can_autoinc) - sum_cost.cost -= cand->cost_step; + sum_cost -= cand->cost_step; /* If we generated the candidate solely for exploiting autoincrement opportunities, and it turns out it can't be used, set the cost to infinity to make sure we ignore it. */ @@ -5015,9 +5106,9 @@ determine_group_iv_cost_address (struct ivopts_data *data, } /* Uses in a group can share setup code, so only add setup cost once. */ - cost.cost -= cost.scratch; + cost -= cost.scratch; /* Compute and add costs for rest uses of this group. */ - for (i = 1; i < group->vuses.length () && !infinite_cost_p (sum_cost); i++) + for (i = 1; i < group->vuses.length () && !sum_cost.infinite_cost_p (); i++) { struct iv_use *next = group->vuses[i]; @@ -5042,15 +5133,15 @@ determine_group_iv_cost_address (struct ivopts_data *data, cost = get_computation_cost (data, next, cand, true, NULL, &can_autoinc, NULL); /* Remove setup cost. */ - if (!infinite_cost_p (cost)) - cost.cost -= cost.scratch; + if (!cost.infinite_cost_p ()) + cost -= cost.scratch; } - sum_cost = add_costs (sum_cost, cost); + sum_cost += cost; } set_group_iv_cost (data, group, cand, sum_cost, depends_on, NULL_TREE, ERROR_MARK, inv_expr); - return !infinite_cost_p (sum_cost); + return !sum_cost.infinite_cost_p (); } /* Computes value of candidate CAND at position AT in iteration NITER, and @@ -5513,11 +5604,11 @@ determine_group_iv_cost_cond (struct ivopts_data *data, TODO: The constant that we're subtracting from the cost should be target-dependent. This information should be added to the target costs for each backend. */ - if (!infinite_cost_p (elim_cost) /* Do not try to decrease infinite! */ + if (!elim_cost.infinite_cost_p () /* Do not try to decrease infinite! */ && integer_zerop (*bound_cst) && (operand_equal_p (*control_var, cand->var_after, 0) || operand_equal_p (*control_var, cand->var_before, 0))) - elim_cost.cost -= 1; + elim_cost -= 1; express_cost = get_computation_cost (data, use, cand, false, &depends_on_express, NULL, @@ -5531,10 +5622,10 @@ determine_group_iv_cost_cond (struct ivopts_data *data, bound_cost.cost = parm_decl_cost (data, *bound_cst); else if (TREE_CODE (*bound_cst) == INTEGER_CST) bound_cost.cost = 0; - express_cost.cost += bound_cost.cost; + express_cost += bound_cost; /* Choose the better approach, preferring the eliminated IV. */ - if (compare_costs (elim_cost, express_cost) <= 0) + if (elim_cost <= express_cost) { cost = elim_cost; depends_on = depends_on_elim; @@ -5559,7 +5650,7 @@ determine_group_iv_cost_cond (struct ivopts_data *data, if (depends_on_express) BITMAP_FREE (depends_on_express); - return !infinite_cost_p (cost); + return !cost.infinite_cost_p (); } /* Determines cost of computing uses in GROUP with CAND. Returns false @@ -5604,7 +5695,7 @@ autoinc_possible_for_pair (struct ivopts_data *data, struct iv_use *use, BITMAP_FREE (depends_on); - return !infinite_cost_p (cost) && can_autoinc; + return !cost.infinite_cost_p () && can_autoinc; } /* Examine IP_ORIGINAL candidates to see if they are incremented next to a @@ -5770,7 +5861,7 @@ determine_group_iv_costs (struct ivopts_data *data) for (j = 0; j < group->n_map_members; j++) { if (!group->cost_map[j].cand - || infinite_cost_p (group->cost_map[j].cost)) + || group->cost_map[j].cost.infinite_cost_p ()) continue; fprintf (dump_file, " %d\t%d\t%d\t", @@ -5944,19 +6035,16 @@ determine_set_costs (struct ivopts_data *data) static bool cheaper_cost_pair (struct cost_pair *a, struct cost_pair *b) { - int cmp; - if (!a) return false; if (!b) return true; - cmp = compare_costs (a->cost, b->cost); - if (cmp < 0) + if (a->cost < b->cost) return true; - if (cmp > 0) + if (b->cost < a->cost) return false; /* In case the costs are the same, prefer the cheaper candidate. */ @@ -5982,11 +6070,11 @@ iv_ca_recount_cost (struct ivopts_data *data, struct iv_ca *ivs) { comp_cost cost = ivs->cand_use_cost; - cost.cost += ivs->cand_cost; + cost += ivs->cand_cost; - cost.cost += ivopts_global_cost_for_size (data, - ivs->n_regs - + ivs->used_inv_exprs->elements ()); + cost += ivopts_global_cost_for_size (data, + ivs->n_regs + + ivs->used_inv_exprs->elements ()); ivs->cost = cost; } @@ -6040,7 +6128,7 @@ iv_ca_set_no_cp (struct ivopts_data *data, struct iv_ca *ivs, iv_ca_set_remove_invariants (ivs, cp->cand->depends_on); } - ivs->cand_use_cost = sub_costs (ivs->cand_use_cost, cp->cost); + ivs->cand_use_cost -= cp->cost; iv_ca_set_remove_invariants (ivs, cp->depends_on); @@ -6106,7 +6194,7 @@ iv_ca_set_cp (struct ivopts_data *data, struct iv_ca *ivs, iv_ca_set_add_invariants (ivs, cp->cand->depends_on); } - ivs->cand_use_cost = add_costs (ivs->cand_use_cost, cp->cost); + ivs->cand_use_cost += cp->cost; iv_ca_set_add_invariants (ivs, cp->depends_on); if (cp->inv_expr != NULL) @@ -6350,7 +6438,8 @@ iv_ca_dump (struct ivopts_data *data, FILE *file, struct iv_ca *ivs) unsigned i; comp_cost cost = iv_ca_cost (ivs); - fprintf (file, " cost: %d (complexity %d)\n", cost.cost, cost.complexity); + fprintf (file, " cost: %d (complexity %d)\n", cost.cost, + cost.complexity); fprintf (file, " cand_cost: %d\n cand_group_cost: %d (complexity %d)\n", ivs->cand_cost, ivs->cand_use_cost.cost, ivs->cand_use_cost.complexity); @@ -6361,8 +6450,9 @@ iv_ca_dump (struct ivopts_data *data, FILE *file, struct iv_ca *ivs) struct iv_group *group = data->vgroups[i]; struct cost_pair *cp = iv_ca_cand_for_group (ivs, group); if (cp) - fprintf (file, " group:%d --> iv_cand:%d, cost=(%d,%d)\n", - group->id, cp->cand->id, cp->cost.cost, cp->cost.complexity); + fprintf (file, " group:%d --> iv_cand:%d, cost=(%d,%d)\n", + group->id, cp->cand->id, cp->cost.cost, + cp->cost.complexity); else fprintf (file, " group:%d --> ??\n", group->id); } @@ -6480,7 +6570,7 @@ iv_ca_narrow (struct ivopts_data *data, struct iv_ca *ivs, iv_ca_set_cp (data, ivs, group, cp); acost = iv_ca_cost (ivs); - if (compare_costs (acost, best_cost) < 0) + if (acost < best_cost) { best_cost = acost; new_cp = cp; @@ -6503,7 +6593,7 @@ iv_ca_narrow (struct ivopts_data *data, struct iv_ca *ivs, iv_ca_set_cp (data, ivs, group, cp); acost = iv_ca_cost (ivs); - if (compare_costs (acost, best_cost) < 0) + if (acost < best_cost) { best_cost = acost; new_cp = cp; @@ -6555,7 +6645,7 @@ iv_ca_prune (struct ivopts_data *data, struct iv_ca *ivs, acost = iv_ca_narrow (data, ivs, cand, except_cand, &act_delta); - if (compare_costs (acost, best_cost) < 0) + if (acost < best_cost) { best_cost = acost; iv_ca_delta_free (&best_delta); @@ -6668,7 +6758,7 @@ iv_ca_replace (struct ivopts_data *data, struct iv_ca *ivs, iv_ca_delta_commit (data, ivs, act_delta, false); act_delta = iv_ca_delta_join (act_delta, tmp_delta); - if (compare_costs (acost, orig_cost) < 0) + if (acost < orig_cost) { *delta = act_delta; return acost; @@ -6737,7 +6827,7 @@ try_add_cand_for (struct ivopts_data *data, struct iv_ca *ivs, iv_ca_set_no_cp (data, ivs, group); act_delta = iv_ca_delta_add (group, NULL, cp, act_delta); - if (compare_costs (act_cost, best_cost) < 0) + if (act_cost < best_cost) { best_cost = act_cost; @@ -6748,7 +6838,7 @@ try_add_cand_for (struct ivopts_data *data, struct iv_ca *ivs, iv_ca_delta_free (&act_delta); } - if (infinite_cost_p (best_cost)) + if (best_cost.infinite_cost_p ()) { for (i = 0; i < group->n_map_members; i++) { @@ -6777,7 +6867,7 @@ try_add_cand_for (struct ivopts_data *data, struct iv_ca *ivs, iv_ca_cand_for_group (ivs, group), cp, act_delta); - if (compare_costs (act_cost, best_cost) < 0) + if (act_cost < best_cost) { best_cost = act_cost; @@ -6793,7 +6883,7 @@ try_add_cand_for (struct ivopts_data *data, struct iv_ca *ivs, iv_ca_delta_commit (data, ivs, best_delta, true); iv_ca_delta_free (&best_delta); - return !infinite_cost_p (best_cost); + return !best_cost.infinite_cost_p (); } /* Finds an initial assignment of candidates to uses. */ @@ -6849,7 +6939,7 @@ try_improve_iv_set (struct ivopts_data *data, act_delta = iv_ca_delta_join (act_delta, tmp_delta); } - if (compare_costs (acost, best_cost) < 0) + if (acost < best_cost) { best_cost = acost; iv_ca_delta_free (&best_delta); @@ -6883,7 +6973,7 @@ try_improve_iv_set (struct ivopts_data *data, } iv_ca_delta_commit (data, ivs, best_delta, true); - gcc_assert (compare_costs (best_cost, iv_ca_cost (ivs)) == 0); + gcc_assert (best_cost == iv_ca_cost (ivs)); iv_ca_delta_free (&best_delta); return true; } @@ -6953,7 +7043,7 @@ find_optimal_iv_set (struct ivopts_data *data) } /* Choose the one with the best cost. */ - if (compare_costs (origcost, cost) <= 0) + if (origcost <= cost) { if (set) iv_ca_free (&set); -- 2.8.2 --------------060405060109010603000708--