re PR target/34711 (g++.dg/tree-ssa/ivopts-1.C fails for power and arm)

	PR target/34711
	* tree-ssa-loop-ivopts.c (comp_cost): New type.
	(zero_cost, infinite_cost): New constants.
	(struct cost_pair): Change type of cost to comp_cost.
	(struct iv_ca): Change type of cand_use_cost and cost to comp_cost.
	(new_cost, add_costs, sub_costs, compare_costs, infinite_cost_p):
	New functions.
	(set_use_iv_cost, force_expr_to_var_cost, force_var_cost,
	split_address_cost, ptr_difference_cost, difference_cost,
	get_computation_cost_at, get_computation_cost,
	determine_use_iv_cost_generic, determine_use_iv_cost_address,
	determine_use_iv_cost_condition, determine_use_iv_costs,
	cheaper_cost_pair, iv_ca_recount_cost, iv_ca_set_no_cp,
	iv_ca_set_cp, iv_ca_cost, iv_ca_new, iv_ca_dump, iv_ca_extend,
	iv_ca_narrow, iv_ca_prune, try_improve_iv_set, find_optimal_iv_set):
	Change type of cost to comp_cost.
	(determine_iv_cost): Increase cost of non-original ivs, instead
	of decreasing the cost of original ones.
	(get_address_cost): Indicate the complexity of the addressing mode 
	in comp_cost.
	(try_add_cand_for): Prefer using ivs not specific to some object.
	* tree-flow.h (force_expr_to_var_cost): Declaration removed.

From-SVN: r131877

gcc/ChangeLog

+2008-01-26  Zdenek Dvorak  <ook@ucw.cz>
+
+	PR target/34711
+	* tree-ssa-loop-ivopts.c (comp_cost): New type.
+	(zero_cost, infinite_cost): New constants.
+	(struct cost_pair): Change type of cost to comp_cost.
+	(struct iv_ca): Change type of cand_use_cost and cost to comp_cost.
+	(new_cost, add_costs, sub_costs, compare_costs, infinite_cost_p):
+	New functions.
+	(set_use_iv_cost, force_expr_to_var_cost, force_var_cost,
+	split_address_cost, ptr_difference_cost, difference_cost,
+	get_computation_cost_at, get_computation_cost,
+	determine_use_iv_cost_generic, determine_use_iv_cost_address,
+	determine_use_iv_cost_condition, determine_use_iv_costs,
+	cheaper_cost_pair, iv_ca_recount_cost, iv_ca_set_no_cp,
+	iv_ca_set_cp, iv_ca_cost, iv_ca_new, iv_ca_dump, iv_ca_extend,
+	iv_ca_narrow, iv_ca_prune, try_improve_iv_set, find_optimal_iv_set):
+	Change type of cost to comp_cost.
+	(determine_iv_cost): Increase cost of non-original ivs, instead
+	of decreasing the cost of original ones.
+	(get_address_cost): Indicate the complexity of the addressing mode 
+	in comp_cost.
+	(try_add_cand_for): Prefer using ivs not specific to some object.
+	* tree-flow.h (force_expr_to_var_cost): Declaration removed.
+
 2007-01-26  Peter Bergner  <bergner@vnet.ibm.com>
 	    Janis Johnson  <janis187@us.ibm.com>
 

gcc/tree-flow.h

@@ -1013,7 +1013,6 @@ bool for_each_index (tree *, bool (*) (tree, tree *, void *), void *);
 void create_iv (tree, tree, tree, struct loop *, block_stmt_iterator *, bool,
 		tree *, tree *);
 basic_block split_loop_exit_edge (edge);
-unsigned force_expr_to_var_cost (tree);
 void standard_iv_increment_position (struct loop *, block_stmt_iterator *,
 				     bool *);
 basic_block ip_end_pos (struct loop *);

gcc/tree-ssa-loop-ivopts.c

@@ -131,11 +131,24 @@ enum use_type
   USE_COMPARE		/* Use is a compare.  */
 };
 
+/* Cost of a computation.  */
+typedef struct
+{
+  unsigned cost;	/* The runtime cost.  */
+  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).  */
+} comp_cost;
+
+static const comp_cost zero_cost = {0, 0};
+static const comp_cost infinite_cost = {INFTY, INFTY};
+
 /* The candidate - cost pair.  */
 struct cost_pair
 {
   struct iv_cand *cand;	/* The candidate.  */
-  unsigned cost;	/* The cost.  */
+  comp_cost cost;	/* The cost.  */
   bitmap depends_on;	/* The list of invariants that have to be
 			   preserved.  */
   tree value;		/* For final value elimination, the expression for
@@ -263,7 +276,7 @@ struct iv_ca
   unsigned n_regs;
 
   /* Total cost of expressing uses.  */
-  unsigned cand_use_cost;
+  comp_cost cand_use_cost;
 
   /* Total cost of candidates.  */
   unsigned cand_cost;
@@ -272,7 +285,7 @@ struct iv_ca
   unsigned *n_invariant_uses;
 
   /* Total cost of the assignment.  */
-  unsigned cost;
+  comp_cost cost;
 };
 
 /* Difference of two iv candidate assignments.  */
@@ -2266,18 +2279,73 @@ 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;
+}
+
+/* Adds costs COST1 and COST2.  */
+
+static comp_cost
+add_costs (comp_cost cost1, comp_cost cost2)
+{
+  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;
+}
+
+/* Returns true if COST is infinite.  */
+
+static bool
+infinite_cost_p (comp_cost cost)
+{
+  return cost.cost == INFTY;
+}
+
 /* Sets cost of (USE, CANDIDATE) pair to COST and record that it depends
    on invariants DEPENDS_ON and that the value used in expressing it
    is VALUE.*/
 
 static void
 set_use_iv_cost (struct ivopts_data *data,
-		 struct iv_use *use, struct iv_cand *cand, unsigned cost,
-		 bitmap depends_on, tree value)
+		 struct iv_use *use, struct iv_cand *cand,
+		 comp_cost cost, bitmap depends_on, tree value)
 {
   unsigned i, s;
 
-  if (cost == INFTY)
+  if (infinite_cost_p (cost))
     {
       BITMAP_FREE (depends_on);
       return;
@@ -2856,7 +2924,7 @@ multiplier_allowed_in_address_p (HOST_WIDE_INT ratio, enum machine_mode mode)
 
    TODO -- there must be some better way.  This all is quite crude.  */
 
-static unsigned
+static comp_cost
 get_address_cost (bool symbol_present, bool var_present,
 		  unsigned HOST_WIDE_INT offset, HOST_WIDE_INT ratio,
 		  enum machine_mode mem_mode)
@@ -2865,7 +2933,7 @@ get_address_cost (bool symbol_present, bool var_present,
   static HOST_WIDE_INT rat[MAX_MACHINE_MODE], off[MAX_MACHINE_MODE];
   static HOST_WIDE_INT min_offset[MAX_MACHINE_MODE], max_offset[MAX_MACHINE_MODE];
   static unsigned costs[MAX_MACHINE_MODE][2][2][2][2];
-  unsigned cost, acost;
+  unsigned cost, acost, complexity;
   bool offset_p, ratio_p;
   HOST_WIDE_INT s_offset;
   unsigned HOST_WIDE_INT mask;
@@ -3059,12 +3127,13 @@ get_address_cost (bool symbol_present, bool var_present,
     cost += add_cost (Pmode);
 
   acost = costs[mem_mode][symbol_present][var_present][offset_p][ratio_p];
-  return cost + acost;
+  complexity = (symbol_present != 0) + (var_present != 0) + offset_p + ratio_p;
+  return new_cost (cost + acost, complexity);
 }
 
 /* Estimates cost of forcing expression EXPR into a variable.  */
 
-unsigned
+static comp_cost
 force_expr_to_var_cost (tree expr)
 {
   static bool costs_initialized = false;
@@ -3072,7 +3141,7 @@ force_expr_to_var_cost (tree expr)
   static unsigned symbol_cost;
   static unsigned address_cost;
   tree op0, op1;
-  unsigned cost0, cost1, cost;
+  comp_cost cost0, cost1, cost;
   enum machine_mode mode;
 
   if (!costs_initialized)
@@ -3112,12 +3181,12 @@ force_expr_to_var_cost (tree expr)
   STRIP_NOPS (expr);
 
   if (SSA_VAR_P (expr))
-    return 0;
+    return zero_cost;
 
   if (TREE_INVARIANT (expr))
     {
       if (TREE_CODE (expr) == INTEGER_CST)
-	return integer_cost;
+	return new_cost (integer_cost, 0);
 
       if (TREE_CODE (expr) == ADDR_EXPR)
 	{
@@ -3126,10 +3195,10 @@ force_expr_to_var_cost (tree expr)
 	  if (TREE_CODE (obj) == VAR_DECL
 	      || TREE_CODE (obj) == PARM_DECL
 	      || TREE_CODE (obj) == RESULT_DECL)
-	    return symbol_cost;
+	    return new_cost (symbol_cost, 0);
 	}
 
-      return address_cost;
+      return new_cost (address_cost, 0);
     }
 
   switch (TREE_CODE (expr))
@@ -3144,12 +3213,12 @@ force_expr_to_var_cost (tree expr)
       STRIP_NOPS (op1);
 
       if (is_gimple_val (op0))
-	cost0 = 0;
+	cost0 = zero_cost;
       else
 	cost0 = force_expr_to_var_cost (op0);
 
       if (is_gimple_val (op1))
-	cost1 = 0;
+	cost1 = zero_cost;
       else
 	cost1 = force_expr_to_var_cost (op1);
 
@@ -3157,7 +3226,7 @@ force_expr_to_var_cost (tree expr)
 
     default:
       /* Just an arbitrary value, FIXME.  */
-      return target_spill_cost;
+      return new_cost (target_spill_cost, 0);
     }
 
   mode = TYPE_MODE (TREE_TYPE (expr));
@@ -3166,36 +3235,39 @@ force_expr_to_var_cost (tree expr)
     case POINTER_PLUS_EXPR:
     case PLUS_EXPR:
     case MINUS_EXPR:
-      cost = add_cost (mode);
+      cost = new_cost (add_cost (mode), 0);
       break;
 
     case MULT_EXPR:
       if (cst_and_fits_in_hwi (op0))
-	cost = multiply_by_cost (int_cst_value (op0), mode);
+	cost = new_cost (multiply_by_cost (int_cst_value (op0), mode), 0);
       else if (cst_and_fits_in_hwi (op1))
-	cost = multiply_by_cost (int_cst_value (op1), mode);
+	cost = new_cost (multiply_by_cost (int_cst_value (op1), mode), 0);
       else
-	return target_spill_cost;
+	return new_cost (target_spill_cost, 0);
       break;
 
     default:
       gcc_unreachable ();
     }
 
-  cost += cost0;
-  cost += cost1;
+  cost = add_costs (cost, cost0);
+  cost = add_costs (cost, cost1);
 
   /* Bound the cost by target_spill_cost.  The parts of complicated
      computations often are either loop invariant or at least can
      be shared between several iv uses, so letting this grow without
      limits would not give reasonable results.  */
-  return cost < target_spill_cost ? cost : target_spill_cost;
+  if (cost.cost > target_spill_cost)
+    cost.cost = target_spill_cost;
+
+  return cost;
 }
 
 /* Estimates cost of forcing EXPR into a variable.  DEPENDS_ON is a set of the
    invariants the computation depends on.  */
 
-static unsigned
+static comp_cost
 force_var_cost (struct ivopts_data *data,
 		tree expr, bitmap *depends_on)
 {
@@ -3213,7 +3285,7 @@ force_var_cost (struct ivopts_data *data,
    to false if the corresponding part is missing.  DEPENDS_ON is a set of the
    invariants the computation depends on.  */
 
-static unsigned
+static comp_cost
 split_address_cost (struct ivopts_data *data,
 		    tree addr, bool *symbol_present, bool *var_present,
 		    unsigned HOST_WIDE_INT *offset, bitmap *depends_on)
@@ -3236,7 +3308,7 @@ split_address_cost (struct ivopts_data *data,
       *var_present = true;
       fd_ivopts_data = data;
       walk_tree (&addr, find_depends, depends_on, NULL);
-      return target_spill_cost;
+      return new_cost (target_spill_cost, 0);
     }
 
   *offset += bitpos / BITS_PER_UNIT;
@@ -3245,12 +3317,12 @@ split_address_cost (struct ivopts_data *data,
     {
       *symbol_present = true;
       *var_present = false;
-      return 0;
+      return zero_cost;
     }
       
   *symbol_present = false;
   *var_present = true;
-  return 0;
+  return zero_cost;
 }
 
 /* Estimates cost of expressing difference of addresses E1 - E2 as
@@ -3259,13 +3331,13 @@ split_address_cost (struct ivopts_data *data,
    part is missing.  DEPENDS_ON is a set of the invariants the computation
    depends on.  */
 
-static unsigned
+static comp_cost
 ptr_difference_cost (struct ivopts_data *data,
 		     tree e1, tree e2, bool *symbol_present, bool *var_present,
 		     unsigned HOST_WIDE_INT *offset, bitmap *depends_on)
 {
   HOST_WIDE_INT diff = 0;
-  unsigned cost;
+  comp_cost cost;
 
   gcc_assert (TREE_CODE (e1) == ADDR_EXPR);
 
@@ -3274,10 +3346,10 @@ ptr_difference_cost (struct ivopts_data *data,
       *offset += diff;
       *symbol_present = false;
       *var_present = false;
-      return 0;
+      return zero_cost;
     }
 
-  if (e2 == integer_zero_node)
+  if (integer_zerop (e2))
     return split_address_cost (data, TREE_OPERAND (e1, 0),
 			       symbol_present, var_present, offset, depends_on);
 
@@ -3285,8 +3357,8 @@ ptr_difference_cost (struct ivopts_data *data,
   *var_present = true;
   
   cost = force_var_cost (data, e1, depends_on);
-  cost += force_var_cost (data, e2, depends_on);
-  cost += add_cost (Pmode);
+  cost = add_costs (cost, force_var_cost (data, e2, depends_on));
+  cost.cost += add_cost (Pmode);
 
   return cost;
 }
@@ -3297,12 +3369,12 @@ ptr_difference_cost (struct ivopts_data *data,
    part is missing.  DEPENDS_ON is a set of the invariants the computation
    depends on.  */
 
-static unsigned
+static comp_cost
 difference_cost (struct ivopts_data *data,
 		 tree e1, tree e2, bool *symbol_present, bool *var_present,
 		 unsigned HOST_WIDE_INT *offset, bitmap *depends_on)
 {
-  unsigned cost;
+  comp_cost cost;
   enum machine_mode mode = TYPE_MODE (TREE_TYPE (e1));
   unsigned HOST_WIDE_INT off1, off2;
 
@@ -3321,7 +3393,7 @@ difference_cost (struct ivopts_data *data,
   if (operand_equal_p (e1, e2, 0))
     {
       *var_present = false;
-      return 0;
+      return zero_cost;
     }
   *var_present = true;
   if (integer_zerop (e2))
@@ -3330,14 +3402,14 @@ difference_cost (struct ivopts_data *data,
   if (integer_zerop (e1))
     {
       cost = force_var_cost (data, e2, depends_on);
-      cost += multiply_by_cost (-1, mode);
+      cost.cost += multiply_by_cost (-1, mode);
 
       return cost;
     }
 
   cost = force_var_cost (data, e1, depends_on);
-  cost += force_var_cost (data, e2, depends_on);
-  cost += add_cost (mode);
+  cost = add_costs (cost, force_var_cost (data, e2, depends_on));
+  cost.cost += add_cost (mode);
 
   return cost;
 }
@@ -3348,7 +3420,7 @@ difference_cost (struct ivopts_data *data,
    register.  A set of invariants we depend on is stored in
    DEPENDS_ON.  AT is the statement at that the value is computed.  */
 
-static unsigned
+static comp_cost
 get_computation_cost_at (struct ivopts_data *data,
 			 struct iv_use *use, struct iv_cand *cand,
 			 bool address_p, bitmap *depends_on, tree at)
@@ -3359,14 +3431,15 @@ get_computation_cost_at (struct ivopts_data *data,
   unsigned HOST_WIDE_INT cstepi, offset = 0;
   HOST_WIDE_INT ratio, aratio;
   bool var_present, symbol_present;
-  unsigned cost = 0, n_sums;
+  comp_cost cost;
+  unsigned n_sums;
   double_int rat;
 
   *depends_on = NULL;
 
   /* Only consider real candidates.  */
   if (!cand->iv)
-    return INFTY;
+    return infinite_cost;
 
   cbase = cand->iv->base;
   cstep = cand->iv->step;
@@ -3375,7 +3448,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 INFTY;
+      return infinite_cost;
     }
 
   if (address_p)
@@ -3388,7 +3461,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 INFTY;
+	return infinite_cost;
     }
 
   if (TYPE_PRECISION (utype) != TYPE_PRECISION (ctype))
@@ -3409,12 +3482,12 @@ get_computation_cost_at (struct ivopts_data *data,
     cstepi = 0;
 
   if (!constant_multiple_of (ustep, cstep, &rat))
-    return INFTY;
+    return infinite_cost;
     
   if (double_int_fits_in_shwi_p (rat))
     ratio = double_int_to_shwi (rat);
   else
-    return INFTY;
+    return infinite_cost;
 
   /* use = ubase + ratio * (var - cbase).  If either cbase is a constant
      or ratio == 1, it is better to handle this like
@@ -3426,26 +3499,27 @@ get_computation_cost_at (struct ivopts_data *data,
   if (cst_and_fits_in_hwi (cbase))
     {
       offset = - ratio * int_cst_value (cbase); 
-      cost += difference_cost (data,
-			       ubase, integer_zero_node,
+      cost = difference_cost (data,
+			      ubase, build_int_cst (utype, 0),
 			      &symbol_present, &var_present, &offset,
 			      depends_on);
     }
   else if (ratio == 1)
     {
-      cost += difference_cost (data,
+      cost = difference_cost (data,
 			      ubase, cbase,
 			      &symbol_present, &var_present, &offset,
 			      depends_on);
     }
   else
     {
-      cost += force_var_cost (data, cbase, depends_on);
-      cost += add_cost (TYPE_MODE (ctype));
-      cost += difference_cost (data,
-			       ubase, integer_zero_node,
-			       &symbol_present, &var_present, &offset,
-			       depends_on);
+      cost = force_var_cost (data, cbase, depends_on);
+      cost.cost += add_cost (TYPE_MODE (ctype));
+      cost = add_costs (cost,
+			difference_cost (data,
+					 ubase, build_int_cst (utype, 0),
+					 &symbol_present, &var_present,
+					 &offset, depends_on));
     }
 
   /* If we are after the increment, the value of the candidate is higher by
@@ -3457,21 +3531,22 @@ get_computation_cost_at (struct ivopts_data *data,
      (symbol/var/const parts may be omitted).  If we are looking for an address,
      find the cost of addressing this.  */
   if (address_p)
-    return cost + get_address_cost (symbol_present, var_present, offset, ratio,
-				    TYPE_MODE (TREE_TYPE (*use->op_p)));
+    return add_costs (cost, get_address_cost (symbol_present, var_present,
+				offset, ratio,
+				TYPE_MODE (TREE_TYPE (*use->op_p))));
 
   /* Otherwise estimate the costs for computing the expression.  */
   aratio = ratio > 0 ? ratio : -ratio;
   if (!symbol_present && !var_present && !offset)
     {
       if (ratio != 1)
-	cost += multiply_by_cost (ratio, TYPE_MODE (ctype));
+	cost.cost += multiply_by_cost (ratio, TYPE_MODE (ctype));
 
       return cost;
     }
 
   if (aratio != 1)
-    cost += multiply_by_cost (aratio, TYPE_MODE (ctype));
+    cost.cost += multiply_by_cost (aratio, TYPE_MODE (ctype));
 
   n_sums = 1;
   if (var_present
@@ -3479,7 +3554,13 @@ get_computation_cost_at (struct ivopts_data *data,
       && (symbol_present || offset))
     n_sums++;
 
-  return cost + n_sums * add_cost (TYPE_MODE (ctype));
+  /* Having offset does not affect runtime cost in case it is added to
+     symbol, but it increases complexity.  */
+  if (offset)
+    cost.complexity++;
+
+  cost.cost += n_sums * add_cost (TYPE_MODE (ctype));
+  return cost;
 
 fallback:
   {
@@ -3487,12 +3568,12 @@ fallback:
     tree comp = get_computation_at (data->current_loop, use, cand, at);
 
     if (!comp)
-      return INFTY;
+      return infinite_cost;
 
     if (address_p)
       comp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (comp)), comp);
 
-    return computation_cost (comp);
+    return new_cost (computation_cost (comp), 0);
   }
 }
 
@@ -3502,7 +3583,7 @@ fallback:
    register.  A set of invariants we depend on is stored in
    DEPENDS_ON.  */
 
-static unsigned
+static comp_cost
 get_computation_cost (struct ivopts_data *data,
 		      struct iv_use *use, struct iv_cand *cand,
 		      bool address_p, bitmap *depends_on)
@@ -3519,7 +3600,7 @@ determine_use_iv_cost_generic (struct ivopts_data *data,
 			       struct iv_use *use, struct iv_cand *cand)
 {
   bitmap depends_on;
-  unsigned cost;
+  comp_cost cost;
 
   /* The simple case first -- if we need to express value of the preserved
      original biv, the cost is 0.  This also prevents us from counting the
@@ -3528,14 +3609,14 @@ determine_use_iv_cost_generic (struct ivopts_data *data,
   if (cand->pos == IP_ORIGINAL
       && cand->incremented_at == use->stmt)
     {
-      set_use_iv_cost (data, use, cand, 0, NULL, NULL_TREE);
+      set_use_iv_cost (data, use, cand, zero_cost, NULL, NULL_TREE);
       return true;
     }
 
   cost = get_computation_cost (data, use, cand, false, &depends_on);
   set_use_iv_cost (data, use, cand, cost, depends_on, NULL_TREE);
 
-  return cost != INFTY;
+  return !infinite_cost_p (cost);
 }
 
 /* Determines cost of basing replacement of USE on CAND in an address.  */
@@ -3545,11 +3626,11 @@ determine_use_iv_cost_address (struct ivopts_data *data,
 			       struct iv_use *use, struct iv_cand *cand)
 {
   bitmap depends_on;
-  unsigned cost = get_computation_cost (data, use, cand, true, &depends_on);
+  comp_cost cost = get_computation_cost (data, use, cand, true, &depends_on);
 
   set_use_iv_cost (data, use, cand, cost, depends_on, NULL_TREE);
 
-  return cost != INFTY;
+  return !infinite_cost_p (cost);
 }
 
 /* Computes value of candidate CAND at position AT in iteration NITER, and
@@ -3679,13 +3760,13 @@ determine_use_iv_cost_condition (struct ivopts_data *data,
   tree bound = NULL_TREE;
   struct iv *cmp_iv;
   bitmap depends_on_elim = NULL, depends_on_express = NULL, depends_on;
-  unsigned elim_cost, express_cost, cost;
+  comp_cost elim_cost, express_cost, cost;
   bool ok;
 
   /* Only consider real candidates.  */
   if (!cand->iv)
     {
-      set_use_iv_cost (data, use, cand, INFTY, NULL, NULL_TREE);
+      set_use_iv_cost (data, use, cand, infinite_cost, NULL, NULL_TREE);
       return false;
     }
 
@@ -3695,10 +3776,10 @@ determine_use_iv_cost_condition (struct ivopts_data *data,
       elim_cost = force_var_cost (data, bound, &depends_on_elim);
       /* The bound is a loop invariant, so it will be only computed
 	 once.  */
-      elim_cost /= AVG_LOOP_NITER (data->current_loop);
+      elim_cost.cost /= AVG_LOOP_NITER (data->current_loop);
     }
   else
-    elim_cost = INFTY;
+    elim_cost = infinite_cost;
 
   /* Try expressing the original giv.  If it is compared with an invariant,
      note that we cannot get rid of it.  */
@@ -3711,7 +3792,7 @@ determine_use_iv_cost_condition (struct ivopts_data *data,
   walk_tree (&cmp_iv->base, find_depends, &depends_on_express, NULL);
 
   /* Choose the better approach.  */
-  if (elim_cost < express_cost)
+  if (compare_costs (elim_cost, express_cost) < 0)
     {
       cost = elim_cost;
       depends_on = depends_on_elim;
@@ -3732,7 +3813,7 @@ determine_use_iv_cost_condition (struct ivopts_data *data,
   if (depends_on_express)
     BITMAP_FREE (depends_on_express);
 
-  return cost != INFTY;
+  return !infinite_cost_p (cost);
 }
 
 /* Determines cost of basing replacement of USE on CAND.  Returns false
@@ -3811,16 +3892,17 @@ determine_use_iv_costs (struct ivopts_data *data)
 	  use = iv_use (data, i);
 
 	  fprintf (dump_file, "Use %d:\n", i);
-	  fprintf (dump_file, "  cand\tcost\tdepends on\n");
+	  fprintf (dump_file, "  cand\tcost\tcompl.\tdepends on\n");
 	  for (j = 0; j < use->n_map_members; j++)
 	    {
 	      if (!use->cost_map[j].cand
-		  || use->cost_map[j].cost == INFTY)
+		  || infinite_cost_p (use->cost_map[j].cost))
 		continue;
 
-	      fprintf (dump_file, "  %d\t%d\t",
+	      fprintf (dump_file, "  %d\t%d\t%d\t",
 		       use->cost_map[j].cand->id,
-		       use->cost_map[j].cost);
+		       use->cost_map[j].cost.cost,
+		       use->cost_map[j].cost.complexity);
 	      if (use->cost_map[j].depends_on)
 		bitmap_print (dump_file,
 			      use->cost_map[j].depends_on, "","");
@@ -3838,7 +3920,8 @@ determine_use_iv_costs (struct ivopts_data *data)
 static void
 determine_iv_cost (struct ivopts_data *data, struct iv_cand *cand)
 {
-  unsigned cost_base, cost_step;
+  comp_cost cost_base;
+  unsigned cost, cost_step;
   tree base;
 
   if (!cand->iv)
@@ -3855,20 +3938,22 @@ determine_iv_cost (struct ivopts_data *data, struct iv_cand *cand)
   cost_base = force_var_cost (data, base, NULL);
   cost_step = add_cost (TYPE_MODE (TREE_TYPE (base)));
 
-  cand->cost = cost_step + cost_base / AVG_LOOP_NITER (current_loop);
+  cost = cost_step + cost_base.cost / AVG_LOOP_NITER (current_loop);
 
-  /* Prefer the original iv unless we may gain something by replacing it;
-     this is not really relevant for artificial ivs created by other
-     passes.  */
-  if (cand->pos == IP_ORIGINAL
-      && !DECL_ARTIFICIAL (SSA_NAME_VAR (cand->var_before)))
-    cand->cost--;
+  /* Prefer the original ivs unless we may gain something by replacing it.
+     The reason is to makee debugging simpler; so this is not relevant for
+     artificial ivs created by other optimization passes.  */
+  if (cand->pos != IP_ORIGINAL
+      || DECL_ARTIFICIAL (SSA_NAME_VAR (cand->var_before)))
+    cost++;
   
   /* Prefer not to insert statements into latch unless there are some
      already (so that we do not create unnecessary jumps).  */
   if (cand->pos == IP_END
       && empty_block_p (ip_end_pos (data->current_loop)))
-    cand->cost++;
+    cost++;
+
+  cand->cost = cost;
 }
 
 /* Determines costs of computation of the candidates.  */
@@ -3988,16 +4073,19 @@ 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;
 
-  if (a->cost < b->cost)
+  cmp = compare_costs (a->cost, b->cost);
+  if (cmp < 0)
     return true;
 
-  if (a->cost > b->cost)
+  if (cmp > 0)
     return false;
 
   /* In case the costs are the same, prefer the cheaper candidate.  */
@@ -4012,11 +4100,9 @@ cheaper_cost_pair (struct cost_pair *a, struct cost_pair *b)
 static void
 iv_ca_recount_cost (struct ivopts_data *data, struct iv_ca *ivs)
 {
-  unsigned cost = 0;
-
-  cost += ivs->cand_use_cost;
-  cost += ivs->cand_cost;
-  cost += ivopts_global_cost_for_size (data, ivs->n_regs);
+  comp_cost cost = ivs->cand_use_cost;
+  cost.cost += ivs->cand_cost;
+  cost.cost += ivopts_global_cost_for_size (data, ivs->n_regs);
 
   ivs->cost = cost;
 }
@@ -4070,7 +4156,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 -= cp->cost;
+  ivs->cand_use_cost = sub_costs (ivs->cand_use_cost, cp->cost);
 
   iv_ca_set_remove_invariants (ivs, cp->depends_on);
   iv_ca_recount_cost (data, ivs);
@@ -4128,7 +4214,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 += cp->cost;
+      ivs->cand_use_cost = add_costs (ivs->cand_use_cost, cp->cost);
       iv_ca_set_add_invariants (ivs, cp->depends_on);
       iv_ca_recount_cost (data, ivs);
     }
@@ -4166,10 +4252,10 @@ iv_ca_add_use (struct ivopts_data *data, struct iv_ca *ivs,
 
 /* Get cost for assignment IVS.  */
 
-static unsigned
+static comp_cost
 iv_ca_cost (struct iv_ca *ivs)
 {
-  return (ivs->bad_uses ? INFTY : ivs->cost);
+  return (ivs->bad_uses ? infinite_cost : ivs->cost);
 }
 
 /* Returns true if all dependences of CP are among invariants in IVS.  */
@@ -4331,10 +4417,10 @@ iv_ca_new (struct ivopts_data *data)
   nw->cands = BITMAP_ALLOC (NULL);
   nw->n_cands = 0;
   nw->n_regs = 0;
-  nw->cand_use_cost = 0;
+  nw->cand_use_cost = zero_cost;
   nw->cand_cost = 0;
   nw->n_invariant_uses = XCNEWVEC (unsigned, data->max_inv_id + 1);
-  nw->cost = 0;
+  nw->cost = zero_cost;
 
   return nw;
 }
@@ -4359,8 +4445,9 @@ iv_ca_dump (struct ivopts_data *data, FILE *file, struct iv_ca *ivs)
 {
   const char *pref = "  invariants ";
   unsigned i;
+  comp_cost cost = iv_ca_cost (ivs);
 
-  fprintf (file, "  cost %d\n", iv_ca_cost (ivs));
+  fprintf (file, "  cost %d (complexity %d)\n", cost.cost, cost.complexity);
   bitmap_print (file, ivs->cands, "  candidates ","\n");
 
   for (i = 1; i <= data->max_inv_id; i++)
@@ -4376,12 +4463,13 @@ iv_ca_dump (struct ivopts_data *data, FILE *file, struct iv_ca *ivs)
    new set, and store differences in DELTA.  Number of induction variables
    in the new set is stored to N_IVS.  */
 
-static unsigned
+static comp_cost
 iv_ca_extend (struct ivopts_data *data, struct iv_ca *ivs,
 	      struct iv_cand *cand, struct iv_ca_delta **delta,
 	      unsigned *n_ivs)
 {
-  unsigned i, cost;
+  unsigned i;
+  comp_cost cost;
   struct iv_use *use;
   struct cost_pair *old_cp, *new_cp;
 
@@ -4420,7 +4508,7 @@ iv_ca_extend (struct ivopts_data *data, struct iv_ca *ivs,
 /* Try narrowing set IVS by removing CAND.  Return the cost of
    the new set and store the differences in DELTA.  */
 
-static unsigned
+static comp_cost
 iv_ca_narrow (struct ivopts_data *data, struct iv_ca *ivs,
 	      struct iv_cand *cand, struct iv_ca_delta **delta)
 {
@@ -4429,7 +4517,7 @@ iv_ca_narrow (struct ivopts_data *data, struct iv_ca *ivs,
   struct cost_pair *old_cp, *new_cp, *cp;
   bitmap_iterator bi;
   struct iv_cand *cnd;
-  unsigned cost;
+  comp_cost cost;
 
   *delta = NULL;
   for (i = 0; i < n_iv_uses (data); i++)
@@ -4488,7 +4576,7 @@ iv_ca_narrow (struct ivopts_data *data, struct iv_ca *ivs,
       if (!new_cp)
 	{
 	  iv_ca_delta_free (delta);
-	  return INFTY;
+	  return infinite_cost;
 	}
 
       *delta = iv_ca_delta_add (use, old_cp, new_cp, *delta);
@@ -4505,13 +4593,14 @@ iv_ca_narrow (struct ivopts_data *data, struct iv_ca *ivs,
    from to EXCEPT_CAND from it.  Return cost of the new set, and store
    differences in DELTA.  */
 
-static unsigned
+static comp_cost
 iv_ca_prune (struct ivopts_data *data, struct iv_ca *ivs,
 	     struct iv_cand *except_cand, struct iv_ca_delta **delta)
 {
   bitmap_iterator bi;
   struct iv_ca_delta *act_delta, *best_delta;
-  unsigned i, best_cost, acost;
+  unsigned i;
+  comp_cost best_cost, acost;
   struct iv_cand *cand;
 
   best_delta = NULL;
@@ -4526,7 +4615,7 @@ iv_ca_prune (struct ivopts_data *data, struct iv_ca *ivs,
 
       acost = iv_ca_narrow (data, ivs, cand, &act_delta);
 
-      if (acost < best_cost)
+      if (compare_costs (acost, best_cost) < 0)
 	{
 	  best_cost = acost;
 	  iv_ca_delta_free (&best_delta);
@@ -4557,7 +4646,7 @@ static bool
 try_add_cand_for (struct ivopts_data *data, struct iv_ca *ivs,
 		  struct iv_use *use)
 {
-  unsigned best_cost, act_cost;
+  comp_cost best_cost, act_cost;
   unsigned i;
   bitmap_iterator bi;
   struct iv_cand *cand;
@@ -4574,18 +4663,21 @@ try_add_cand_for (struct ivopts_data *data, struct iv_ca *ivs,
       iv_ca_set_no_cp (data, ivs, use);
     }
 
-  /* First try important candidates.  Only if it fails, try the specific ones.
-     Rationale -- in loops with many variables the best choice often is to use
-     just one generic biv.  If we added here many ivs specific to the uses,
-     the optimization algorithm later would be likely to get stuck in a local
-     minimum, thus causing us to create too many ivs.  The approach from
-     few ivs to more seems more likely to be successful -- starting from few
-     ivs, replacing an expensive use by a specific iv should always be a
-     win.  */
+  /* First try important candidates not based on any memory object.  Only if
+     this fails, try the specific ones.  Rationale -- in loops with many
+     variables the best choice often is to use just one generic biv.  If we
+     added here many ivs specific to the uses, the optimization algorithm later
+     would be likely to get stuck in a local minimum, thus causing us to create
+     too many ivs.  The approach from few ivs to more seems more likely to be
+     successful -- starting from few ivs, replacing an expensive use by a
+     specific iv should always be a win.  */
   EXECUTE_IF_SET_IN_BITMAP (data->important_candidates, 0, i, bi)
     {
       cand = iv_cand (data, i);
 
+      if (cand->iv->base_object != NULL_TREE)
+	continue;
+
       if (iv_ca_cand_used_p (ivs, cand))
 	continue;
 
@@ -4598,7 +4690,7 @@ try_add_cand_for (struct ivopts_data *data, struct iv_ca *ivs,
       iv_ca_set_no_cp (data, ivs, use);
       act_delta = iv_ca_delta_add (use, NULL, cp, act_delta);
 
-      if (act_cost < best_cost)
+      if (compare_costs (act_cost, best_cost) < 0)
 	{
 	  best_cost = act_cost;
 
@@ -4609,7 +4701,7 @@ try_add_cand_for (struct ivopts_data *data, struct iv_ca *ivs,
 	iv_ca_delta_free (&act_delta);
     }
 
-  if (best_cost == INFTY)
+  if (infinite_cost_p (best_cost))
     {
       for (i = 0; i < use->n_map_members; i++)
 	{
@@ -4619,7 +4711,7 @@ try_add_cand_for (struct ivopts_data *data, struct iv_ca *ivs,
 	    continue;
 
 	  /* Already tried this.  */
-	  if (cand->important)
+	  if (cand->important && cand->iv->base_object == NULL_TREE)
 	    continue;
       
 	  if (iv_ca_cand_used_p (ivs, cand))
@@ -4632,7 +4724,7 @@ try_add_cand_for (struct ivopts_data *data, struct iv_ca *ivs,
 	  act_delta = iv_ca_delta_add (use, iv_ca_cand_for_use (ivs, use),
 				       cp, act_delta);
 
-	  if (act_cost < best_cost)
+	  if (compare_costs (act_cost, best_cost) < 0)
 	    {
 	      best_cost = act_cost;
 
@@ -4648,7 +4740,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 (best_cost != INFTY);
+  return !infinite_cost_p (best_cost);
 }
 
 /* Finds an initial assignment of candidates to uses.  */
@@ -4674,7 +4766,8 @@ get_initial_solution (struct ivopts_data *data)
 static bool
 try_improve_iv_set (struct ivopts_data *data, struct iv_ca *ivs)
 {
-  unsigned i, acost, best_cost = iv_ca_cost (ivs), n_ivs;
+  unsigned i, n_ivs;
+  comp_cost acost, best_cost = iv_ca_cost (ivs);
   struct iv_ca_delta *best_delta = NULL, *act_delta, *tmp_delta;
   struct iv_cand *cand;
 
@@ -4700,7 +4793,7 @@ try_improve_iv_set (struct ivopts_data *data, struct iv_ca *ivs)
 	  act_delta = iv_ca_delta_join (act_delta, tmp_delta);
 	}
 
-      if (acost < best_cost)
+      if (compare_costs (acost, best_cost) < 0)
 	{
 	  best_cost = acost;
 	  iv_ca_delta_free (&best_delta);
@@ -4721,7 +4814,7 @@ try_improve_iv_set (struct ivopts_data *data, struct iv_ca *ivs)
     }
 
   iv_ca_delta_commit (data, ivs, best_delta, true);
-  gcc_assert (best_cost == iv_ca_cost (ivs));
+  gcc_assert (compare_costs (best_cost, iv_ca_cost (ivs)) == 0);
   iv_ca_delta_free (&best_delta);
   return true;
 }
@@ -4762,7 +4855,10 @@ find_optimal_iv_set (struct ivopts_data *data)
     }
 
   if (dump_file && (dump_flags & TDF_DETAILS))
-    fprintf (dump_file, "Final cost %d\n\n", iv_ca_cost (set));
+    {
+      comp_cost cost = iv_ca_cost (set);
+      fprintf (dump_file, "Final cost %d (complexity %d)\n\n", cost.cost, cost.complexity);
+    }
 
   for (i = 0; i < n_iv_uses (data); i++)
     {