* tree-ssa-loop-niter.c (number_of_iterations_lt_to_ne,

	assert_no_overflow_lt, assert_loop_rolls_lt,
	number_of_iterations_lt, number_of_iterations_le,
	number_of_iterations_cond, number_of_iterations_exit):
	Use integer_zerop/integer_nonzerop instead of
	null_or_integer_zerop/nonnull_and_integer_nonzerop.
	* tree.h (null_or_integer_zerop, nonnull_and_integer_nonzerop):
	Removed.
	* tree-scalar-evolution.c (simple_iv): Return zero for step of
	an invariant.
	* tree-ssa-loop-ivopts.c (alloc_iv): Do not set step of invariants
	to zero.
	(get_iv): Return NULL for non-scalar types.  Use zero as a step
	of an invariant.
	(determine_biv_step, find_interesting_uses_op,
	find_interesting_uses_cond, find_interesting_uses_stmt,
	add_old_ivs_candidates, determine_use_iv_cost_condition,
	rewrite_use_compare, remove_unused_ivs):
	Use integer_zerop instead of null_or_integer_zerop.
	(struct ifs_ivopts_data): Replace step_p field with step field.
	(idx_find_step): Use zero as a step of an invariant.  Modify
	step instead of *step_p.
	(find_interesting_uses_address): Use zero as a step of an invariant.
	Use integer_zerop instead of null_or_integer_zerop.
	(find_interesting_uses_outside): Call find_interesting_uses_op only
	for phi nodes for real operands.
	(add_candidate_1): Expect step to be non-NULL.
	* tree-ssa-loop-prefetch.c (idx_analyze_ref): Expect step to be
	non-NULL.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@120179 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 20 insertions, 23 deletions

diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index 2187c2f332d..affb47d3b1c 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -193,7 +193,7 @@ number_of_iterations_lt_to_ne (tree type, affine_iv *iv0, affine_iv *iv1,
     mod = fold_build2 (MINUS_EXPR, niter_type, step, mod);
   tmod = fold_convert (type, mod);
 
-  if (nonnull_and_integer_nonzerop (iv0->step))
+  if (integer_nonzerop (iv0->step))
     {
       /* The final value of the iv is iv1->base + MOD, assuming that this
 	 computation does not overflow, and that
@@ -256,7 +256,7 @@ assert_no_overflow_lt (tree type, affine_iv *iv0, affine_iv *iv1,
   tree bound, d, assumption, diff;
   tree niter_type = TREE_TYPE (step);
 
-  if (nonnull_and_integer_nonzerop (iv0->step))
+  if (integer_nonzerop (iv0->step))
     {
       /* for (i = iv0->base; i < iv1->base; i += iv0->step) */
       if (iv0->no_overflow)
@@ -324,7 +324,7 @@ assert_loop_rolls_lt (tree type, affine_iv *iv0, affine_iv *iv1,
   tree assumption = boolean_true_node, bound, diff;
   tree mbz, mbzl, mbzr;
 
-  if (nonnull_and_integer_nonzerop (iv0->step))
+  if (integer_nonzerop (iv0->step))
     {
       diff = fold_build2 (MINUS_EXPR, type,
 			  iv0->step, build_int_cst (type, 1));
@@ -384,7 +384,7 @@ number_of_iterations_lt (tree type, affine_iv *iv0, affine_iv *iv1,
   tree niter_type = unsigned_type_for (type);
   tree delta, step, s;
 
-  if (nonnull_and_integer_nonzerop (iv0->step))
+  if (integer_nonzerop (iv0->step))
     {
       niter->control = *iv0;
       niter->cmp = LT_EXPR;
@@ -402,10 +402,8 @@ number_of_iterations_lt (tree type, affine_iv *iv0, affine_iv *iv1,
 		       fold_convert (niter_type, iv0->base));
 
   /* First handle the special case that the step is +-1.  */
-  if ((iv0->step && integer_onep (iv0->step)
-       && null_or_integer_zerop (iv1->step))
-      || (iv1->step && integer_all_onesp (iv1->step)
-	  && null_or_integer_zerop (iv0->step)))
+  if ((integer_onep (iv0->step) && integer_zerop (iv1->step))
+      || (integer_all_onesp (iv1->step) && integer_zerop (iv0->step)))
     {
       /* for (i = iv0->base; i < iv1->base; i++)
 
@@ -421,7 +419,7 @@ number_of_iterations_lt (tree type, affine_iv *iv0, affine_iv *iv1,
       return true;
     }
 
-  if (nonnull_and_integer_nonzerop (iv0->step))
+  if (integer_nonzerop (iv0->step))
     step = fold_convert (niter_type, iv0->step);
   else
     step = fold_convert (niter_type,
@@ -479,7 +477,7 @@ number_of_iterations_le (tree type, affine_iv *iv0, affine_iv *iv1,
 
   if (!never_infinite)
     {
-      if (nonnull_and_integer_nonzerop (iv0->step))
+      if (integer_nonzerop (iv0->step))
 	assumption = fold_build2 (NE_EXPR, boolean_type_node,
 				  iv1->base, TYPE_MAX_VALUE (type));
       else
@@ -493,7 +491,7 @@ number_of_iterations_le (tree type, affine_iv *iv0, affine_iv *iv1,
 					  niter->assumptions, assumption);
     }
 
-  if (nonnull_and_integer_nonzerop (iv0->step))
+  if (integer_nonzerop (iv0->step))
     iv1->base = fold_build2 (PLUS_EXPR, type,
 			     iv1->base, build_int_cst (type, 1));
   else
@@ -542,7 +540,7 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code,
   /* Make < comparison from > ones, and for NE_EXPR comparisons, ensure that
      the control variable is on lhs.  */
   if (code == GE_EXPR || code == GT_EXPR
-      || (code == NE_EXPR && null_or_integer_zerop (iv0->step)))
+      || (code == NE_EXPR && integer_zerop (iv0->step)))
     {
       SWAP (iv0, iv1);
       code = swap_tree_comparison (code);
@@ -578,9 +576,9 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code,
 
   /* If the control induction variable does not overflow, the loop obviously
      cannot be infinite.  */
-  if (!null_or_integer_zerop (iv0->step) && iv0->no_overflow)
+  if (!integer_zerop (iv0->step) && iv0->no_overflow)
     never_infinite = true;
-  else if (!null_or_integer_zerop (iv1->step) && iv1->no_overflow)
+  else if (!integer_zerop (iv1->step) && iv1->no_overflow)
     never_infinite = true;
   else
     never_infinite = false;
@@ -588,7 +586,7 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code,
   /* We can handle the case when neither of the sides of the comparison is
      invariant, provided that the test is NE_EXPR.  This rarely occurs in
      practice, but it is simple enough to manage.  */
-  if (!null_or_integer_zerop (iv0->step) && !null_or_integer_zerop (iv1->step))
+  if (!integer_zerop (iv0->step) && !integer_zerop (iv1->step))
     {
       if (code != NE_EXPR)
 	return false;
@@ -596,14 +594,14 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code,
       iv0->step = fold_binary_to_constant (MINUS_EXPR, type,
 					   iv0->step, iv1->step);
       iv0->no_overflow = false;
-      iv1->step = NULL_TREE;
+      iv1->step = build_int_cst (type, 0);
       iv1->no_overflow = true;
     }
 
   /* If the result of the comparison is a constant,  the loop is weird.  More
      precise handling would be possible, but the situation is not common enough
      to waste time on it.  */
-  if (null_or_integer_zerop (iv0->step) && null_or_integer_zerop (iv1->step))
+  if (integer_zerop (iv0->step) && integer_zerop (iv1->step))
     return false;
 
   /* Ignore loops of while (i-- < 10) type.  */
@@ -612,7 +610,7 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code,
       if (iv0->step && tree_int_cst_sign_bit (iv0->step))
 	return false;
 
-      if (!null_or_integer_zerop (iv1->step) && !tree_int_cst_sign_bit (iv1->step))
+      if (!integer_zerop (iv1->step) && !tree_int_cst_sign_bit (iv1->step))
 	return false;
     }
 
@@ -628,7 +626,7 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code,
   switch (code)
     {
     case NE_EXPR:
-      gcc_assert (null_or_integer_zerop (iv1->step));
+      gcc_assert (integer_zerop (iv1->step));
       return number_of_iterations_ne (type, iv0, iv1->base, niter, never_infinite);
     case LT_EXPR:
       return number_of_iterations_lt (type, iv0, iv1, niter, never_infinite);
@@ -1099,11 +1097,10 @@ number_of_iterations_exit (struct loop *loop, edge exit,
   
       /* We can provide a more specific warning if one of the operator is
 	 constant and the other advances by +1 or -1.  */
-      if (!null_or_integer_zerop (iv1.step)
-	  ? (null_or_integer_zerop (iv0.step)
+      if (!integer_zerop (iv1.step)
+	  ? (integer_zerop (iv0.step)
 	     && (integer_onep (iv1.step) || integer_all_onesp (iv1.step)))
-	  : (iv0.step
-	     && (integer_onep (iv0.step) || integer_all_onesp (iv0.step))))
+	  : (integer_onep (iv0.step) || integer_all_onesp (iv0.step)))
         wording =
           flag_unsafe_loop_optimizations
           ? N_("assuming that the loop is not infinite")