From 2f759a3cbd5bcf2bfd0717a7f910efe19581636e Mon Sep 17 00:00:00 2001 From: marxin Date: Tue, 17 May 2016 13:52:11 +0200 Subject: [PATCH 1/4] 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. (comp_cost::get_infinite): Likewise. (comp_cost::get_no_cost): 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 | 439 ++++++++++++++++++++++++++++----------------- 1 file changed, 271 insertions(+), 168 deletions(-) diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 9ce6b64..f48b2f6 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -173,16 +173,184 @@ enum use_type /* Cost of a computation. */ struct comp_cost { + comp_cost (): cost (0), complexity (0), scratch (0) + {} + + comp_cost (int cost, unsigned complexity) + : cost (cost), complexity (complexity), scratch (0) + {} + + /* 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); + + /* Return infinite comp_cost. */ + static comp_cost get_infinite (); + + /* Return empty comp_cost. */ + static comp_cost get_no_cost (); + 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}; +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 comp_cost::get_infinite (); + + cost1.cost += cost2.cost; + cost1.complexity += cost2.complexity; + + return cost1; +} + +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; +} + +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; +} + +comp_cost +comp_cost::get_infinite () +{ + return comp_cost (INFTY, INFTY); +} + +comp_cost +comp_cost::get_no_cost () +{ + return comp_cost (); +} struct iv_inv_expr_ent; @@ -3284,64 +3452,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 +3464,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 +4280,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 +4317,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; @@ -4272,12 +4382,12 @@ force_expr_to_var_cost (tree expr, bool speed) STRIP_NOPS (expr); if (SSA_VAR_P (expr)) - return no_cost; + return comp_cost::get_no_cost (); 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 +4396,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,18 +4423,18 @@ 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 || TREE_CODE (op0) == SSA_NAME || CONSTANT_CLASS_P (op0)) - cost0 = no_cost; + cost0 = comp_cost::get_no_cost (); else cost0 = force_expr_to_var_cost (op0, speed); if (op1 == NULL_TREE || TREE_CODE (op1) == SSA_NAME || CONSTANT_CLASS_P (op1)) - cost1 = no_cost; + cost1 = comp_cost::get_no_cost (); else cost1 = force_expr_to_var_cost (op1, speed); @@ -4335,7 +4445,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 +4468,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 +4548,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; @@ -4447,12 +4557,12 @@ split_address_cost (struct ivopts_data *data, { *symbol_present = true; *var_present = false; - return no_cost; + return comp_cost::get_no_cost (); } *symbol_present = false; *var_present = true; - return no_cost; + return comp_cost::get_no_cost (); } /* Estimates cost of expressing difference of addresses E1 - E2 as @@ -4477,7 +4587,7 @@ ptr_difference_cost (struct ivopts_data *data, *offset += diff; *symbol_present = false; *var_present = false; - return no_cost; + return comp_cost::get_no_cost (); } if (integer_zerop (e2)) @@ -4527,7 +4637,7 @@ difference_cost (struct ivopts_data *data, if (operand_equal_p (e1, e2, 0)) { *var_present = false; - return no_cost; + return comp_cost::get_no_cost (); } *var_present = true; @@ -4538,7 +4648,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; } @@ -4732,7 +4842,7 @@ get_computation_cost_at (struct ivopts_data *data, /* Only consider real candidates. */ if (!cand->iv) - return infinite_cost; + return comp_cost::get_infinite (); cbase = cand->iv->base; cstep = cand->iv->step; @@ -4741,7 +4851,7 @@ get_computation_cost_at (struct ivopts_data *data, if (TYPE_PRECISION (utype) > TYPE_PRECISION (ctype)) { /* We do not have a precision to express the values of use. */ - return infinite_cost; + return comp_cost::get_infinite (); } if (address_p @@ -4758,7 +4868,7 @@ get_computation_cost_at (struct ivopts_data *data, if (use->iv->base_object && cand->iv->base_object && !operand_equal_p (use->iv->base_object, cand->iv->base_object, 0)) - return infinite_cost; + return comp_cost::get_infinite (); } if (TYPE_PRECISION (utype) < TYPE_PRECISION (ctype)) @@ -4779,12 +4889,12 @@ get_computation_cost_at (struct ivopts_data *data, cstepi = 0; if (!constant_multiple_of (ustep, cstep, &rat)) - return infinite_cost; + return comp_cost::get_infinite (); if (wi::fits_shwi_p (rat)) ratio = rat.to_shwi (); else - return infinite_cost; + return comp_cost::get_infinite (); STRIP_NOPS (cbase); ctype = TREE_TYPE (cbase); @@ -4805,7 +4915,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 +4939,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 +4962,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 +4995,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 +5020,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: @@ -4930,14 +5036,12 @@ fallback: tree comp = get_computation_at (data->current_loop, use, cand, at); if (!comp) - return infinite_cost; + return comp_cost::get_infinite (); 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); } } @@ -4976,14 +5080,14 @@ determine_group_iv_cost_generic (struct ivopts_data *data, cost of increment twice -- once at this use and once in the cost of the candidate. */ if (cand->pos == IP_ORIGINAL && cand->incremented_at == use->stmt) - cost = no_cost; + cost = comp_cost::get_no_cost (); else cost = get_computation_cost (data, use, cand, false, &depends_on, NULL, &inv_expr); 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. */ @@ -4997,27 +5101,27 @@ determine_group_iv_cost_address (struct ivopts_data *data, bool can_autoinc, first = true; iv_inv_expr_ent *inv_expr = NULL; struct iv_use *use = group->vuses[0]; - comp_cost sum_cost = no_cost, cost; + comp_cost sum_cost = comp_cost::get_no_cost (), cost; cost = get_computation_cost (data, use, cand, true, &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. */ else if (cand->pos == IP_AFTER_USE || cand->pos == IP_BEFORE_USE) - sum_cost = infinite_cost; + sum_cost = comp_cost::get_infinite (); } /* 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 +5146,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 @@ -5499,7 +5603,7 @@ determine_group_iv_cost_cond (struct ivopts_data *data, elim_cost.cost = adjust_setup_cost (data, elim_cost.cost); } else - elim_cost = infinite_cost; + elim_cost = comp_cost::get_infinite (); /* Try expressing the original giv. If it is compared with an invariant, note that we cannot get rid of it. */ @@ -5513,11 +5617,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 +5635,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 +5663,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 +5708,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 +5874,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 +6048,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 +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; - 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 +6141,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 +6207,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) @@ -6165,7 +6266,7 @@ iv_ca_cost (struct iv_ca *ivs) /* This was a conditional expression but it triggered a bug in Sun C 5.5. */ if (ivs->bad_groups) - return infinite_cost; + return comp_cost::get_infinite (); else return ivs->cost; } @@ -6319,11 +6420,11 @@ iv_ca_new (struct ivopts_data *data) nw->cands = BITMAP_ALLOC (NULL); nw->n_cands = 0; nw->n_regs = 0; - nw->cand_use_cost = no_cost; + nw->cand_use_cost = comp_cost::get_no_cost (); nw->cand_cost = 0; nw->n_invariant_uses = XCNEWVEC (unsigned, data->max_inv_id + 1); nw->used_inv_exprs = new hash_map (13); - nw->cost = no_cost; + nw->cost = comp_cost::get_no_cost (); return nw; } @@ -6350,7 +6451,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 +6463,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 +6583,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 +6606,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; @@ -6516,7 +6619,7 @@ iv_ca_narrow (struct ivopts_data *data, struct iv_ca *ivs, if (!new_cp) { iv_ca_delta_free (delta); - return infinite_cost; + return comp_cost::get_infinite (); } *delta = iv_ca_delta_add (group, old_cp, new_cp, *delta); @@ -6555,7 +6658,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 +6771,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 +6840,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 +6851,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 +6880,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 +6896,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 +6952,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 +6986,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; } @@ -6941,8 +7044,8 @@ find_optimal_iv_set (struct ivopts_data *data) if (!origset && !set) return NULL; - origcost = origset ? iv_ca_cost (origset) : infinite_cost; - cost = set ? iv_ca_cost (set) : infinite_cost; + origcost = origset ? iv_ca_cost (origset) : comp_cost::get_infinite (); + cost = set ? iv_ca_cost (set) : comp_cost::get_infinite (); if (dump_file && (dump_flags & TDF_DETAILS)) { @@ -6953,7 +7056,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