contrib/gcc/tree-ssa-loop-niter.c

149   if (tree_int_cst_sign_bit (iv->step))
152 			fold_build1 (NEGATE_EXPR, type, iv->step));
159       s = fold_convert (niter_type, iv->step);
165   /* First the trivial cases -- when the step is 1.  */
172   /* Let nsd (step, size of mode) = d.  If d does not divide c, the loop
205    of the step.  The assumptions necessary to ensure that the computation
213 			       tree *delta, tree step)
215   tree niter_type = TREE_TYPE (step);
216   tree mod = fold_build2 (FLOOR_MOD_EXPR, niter_type, *delta, step);
223     mod = fold_build2 (MINUS_EXPR, niter_type, step, mod);
226   if (nonzero_p (iv0->step))
280    otherwise.  STEP is the absolute value of the step.  */
284 		       struct tree_niter_desc *niter, tree step)
287   tree niter_type = TREE_TYPE (step);
289   if (nonzero_p (iv0->step))
291       /* for (i = iv0->base; i < iv1->base; i += iv0->step) */
304 	  diff = fold_build2 (FLOOR_MOD_EXPR, niter_type, d, step);
307 	diff = fold_build2 (MINUS_EXPR, niter_type, step,
316       /* for (i = iv1->base; i > iv0->base; i += iv1->step) */
325 	  diff = fold_build2 (FLOOR_MOD_EXPR, niter_type, d, step);
328 	diff = fold_build2 (MINUS_EXPR, niter_type, step,
357   if (nonzero_p (iv0->step))
360 			  iv0->step, build_int_cst (type, 1));
362       /* We need to know that iv0->base >= MIN + iv0->step - 1.  Since
381 			  iv1->step, build_int_cst (type, 1));
415   tree delta, step, s;
417   if (nonzero_p (iv0->step))
434   /* First handle the special case that the step is +-1.  */
435   if ((iv0->step && integer_onep (iv0->step)
436        && zero_p (iv1->step))
437       || (iv1->step && integer_all_onesp (iv1->step)
438 	  && zero_p (iv0->step)))
454   if (nonzero_p (iv0->step))
455     step = fold_convert (niter_type, iv0->step);
457     step = fold_convert (niter_type,
458 			 fold_build1 (NEGATE_EXPR, type, iv1->step));
463   if (number_of_iterations_lt_to_ne (type, iv0, iv1, niter, &delta, step))
468       zps.step = step;
477   if (!assert_no_overflow_lt (type, iv0, iv1, niter, step))
480   /* We determine the number of iterations as (delta + step - 1) / step.  For
481      this to work, we must know that iv1->base >= iv0->base - step + 1,
486 		   step, build_int_cst (niter_type, 1));
488   niter->niter = fold_build2 (FLOOR_DIV_EXPR, niter_type, delta, step);
512       if (nonzero_p (iv0->step))
526   if (nonzero_p (iv0->step))
575       || (code == NE_EXPR && zero_p (iv0->step)))
611   if (!zero_p (iv0->step) && iv0->no_overflow)
613   else if (!zero_p (iv1->step) && iv1->no_overflow)
621   if (!zero_p (iv0->step) && !zero_p (iv1->step))
626       iv0->step = fold_binary_to_constant (MINUS_EXPR, type,
627 					   iv0->step, iv1->step);
629       iv1->step = NULL_TREE;
636   if (zero_p (iv0->step) && zero_p (iv1->step))
642       if (iv0->step && tree_int_cst_sign_bit (iv0->step))
645       if (!zero_p (iv1->step) && !tree_int_cst_sign_bit (iv1->step))
661       gcc_assert (zero_p (iv1->step));
1147       if (!zero_p (iv1.step)
1148 	  ? (zero_p (iv0.step)
1149 	     && (integer_onep (iv1.step) || integer_all_onesp (iv1.step)))
1150 	  : (iv0.step
1151 	     && (integer_onep (iv0.step) || integer_all_onesp (iv0.step))))
1782 		    tree init, step, diff, estimation;
1792 		    step = evolution_part_in_loop_num (scev, loop->num);
1795 			|| step == NULL_TREE
1797 			|| TREE_CODE (step) != INTEGER_CST
1802 		    if (integer_nonzerop (step))
1806 			if (tree_int_cst_lt (step, integer_zero_node))
1815 						  step);
1991    enough with respect to the step and initial condition in order to
2000 scev_probably_wraps_p (tree base, tree step,
2007   tree type = TREE_TYPE (step);
2026       || chrec_contains_undetermined (step)
2027       || TREE_CODE (step) != INTEGER_CST)
2030   if (zero_p (step))
2047   if (tree_int_cst_sign_bit (step))
2053 			      fold_convert (unsigned_type, step));
2060       step_abs = fold_convert (unsigned_type, step);