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

106   tree step;		/* Step of the iv (constant only).  */
187   bitmap depends_on;	/* The list of invariants that are used in step of the
380   if (iv->step)
386       fprintf (file, "  step ");
387       print_generic_expr (file, iv->step, TDF_SLIM);
886 /* Allocates an induction variable with given initial value BASE and step STEP
890 alloc_iv (tree base, tree step)
894   if (step && integer_zerop (step))
895     step = NULL_TREE;
899   iv->step = step;
911 set_iv (struct ivopts_data *data, tree iv, tree base, tree step)
918   info->iv = alloc_iv (base, step);
941 /* Determines the step of a biv defined in PHI.  Returns NULL if PHI does
942    not define a simple affine biv with nonzero step.  */
957   return (zero_p (iv.step) ? NULL_TREE : iv.step);
965   tree phi, step, type, base;
974       step = determine_biv_step (phi);
975       if (!step)
981 	  || contains_abnormal_ssa_name_p (step))
986       if (step)
987 	step = fold_convert (type, step);
989       set_iv (data, PHI_RESULT (phi), base, step);
1038   iv->step = NULL_TREE;
1052       || contains_abnormal_ssa_name_p (iv->step))
1068   set_iv (data, TREE_OPERAND (stmt, 0), iv.base, iv.step);
1097    variable and if so, its initial value and step.  */
1213   if (zero_p (iv->step))
1245   const_iv.step = NULL_TREE;
1277       || (!zero_p (iv0->step) && !zero_p (iv1->step)))
1284   if (zero_p (iv0->step) && zero_p (iv1->step))
1291   *civ = zero_p (iv0->step) ? *iv1: *iv0;
1344   tree step, iv_base, iv_step, lbound, off;
1362      and step to be loop invariants.  */
1365       step = array_ref_element_size (base);
1368       if (!expr_invariant_in_loop_p (loop, step)
1385   if (!iv->step)
1390       step = array_ref_element_size (base);
1392       /* We only handle addresses whose step is an integer constant.  */
1393       if (TREE_CODE (step) != INTEGER_CST)
1397     /* The step for pointer arithmetics already is 1 byte.  */
1398     step = build_int_cst (sizetype, 1);
1401   iv_step = iv->step;
1410   step = fold_build2 (MULT_EXPR, sizetype, step, iv_step);
1413     *dta->step_p = step;
1415     *dta->step_p = fold_build2 (PLUS_EXPR, sizetype, *dta->step_p, step);
1507   tree base = *op_p, step = NULL;
1543 	  step = civ->step;
1553 	  astep = civ->step;
1560 	      if (step)
1561 		step = fold_build2 (PLUS_EXPR, type, step, astep);
1563 		step = astep;
1567       if (zero_p (step))
1575       ifs_ivopts_data.step_p = &step;
1577 	  || zero_p (step))
1597   civ = alloc_iv (base, step);
1651 	  if (iv && !zero_p (iv->step))
1693       if (iv && !zero_p (iv->step))
1791   tree op0 = NULL_TREE, op1 = NULL_TREE, tmp, step;
1844       step = array_ref_element_size (expr);
1845       if (!cst_and_fits_in_hwi (step))
1848       st = int_cst_value (step);
1977 		 tree base, tree step, bool important, enum iv_position pos,
1991 	  if (step)
1992 	    step = fold_convert (type, step);
2008 	  if (!base && !step)
2014       if (!base && !step)
2020       if (zero_p (cand->iv->step))
2022 	  if (zero_p (step))
2027 	  if (step && operand_equal_p (step, cand->iv->step, 0))
2037       if (!base && !step)
2040 	cand->iv = alloc_iv (base, step);
2052       if (step
2053 	  && TREE_CODE (step) != INTEGER_CST)
2056 	  walk_tree (&step, find_depends, &cand->depends_on, NULL);
2108 	       tree base, tree step, bool important, struct iv_use *use)
2111     add_candidate_1 (data, base, step, important, IP_NORMAL, use, NULL_TREE);
2114     add_candidate_1 (data, base, step, important, IP_END, use, NULL_TREE);
2150   add_candidate (data, iv->base, iv->step, true, NULL);
2155 		 iv->step, true, NULL);
2164 			      iv->base, iv->step, true, IP_ORIGINAL, NULL,
2183       if (iv && iv->biv_p && !zero_p (iv->step))
2197   add_candidate (data, iv->base, iv->step, false, use);
2203 		 iv->step, true, use);
2208     add_candidate (data, base, iv->step, false, use);
3036   tree ustep = use->iv->step;
3038   tree cstep = cand->iv->step;
3080 	 considering the value of the step.  */
3850   tree ubase = use->iv->base, ustep = use->iv->step;
3865   cstep = cand->iv->step;
3894      increment.  If the step is not constant, we use zero instead.
4069   val = fold_build2 (MULT_EXPR, type, iv->step, niter);
4083     val = fold_build2 (PLUS_EXPR, type, val, cand->iv->step);
4093   tree step = iv->step, period, type;
4096   gcc_assert (step && TREE_CODE (step) == INTEGER_CST);
4098   /* Period of the iv is gcd (step, type range).  Since type range is power
4100      step.  */
4101   pow2div = num_ending_zeros (step);
4102   type = unsigned_type_for (TREE_TYPE (step));
4141   if (TREE_CODE (cand->iv->step) != INTEGER_CST)
4222       if (TREE_CODE (op) == SSA_NAME && !zero_p (get_iv (data, op)->step))
5312   create_iv (base, unshare_expr (cand->iv->step),
5374       tree step, ctype, utype;
5380       step = cand->iv->step;
5381       ctype = TREE_TYPE (step);
5383       if (TREE_CODE (step) == NEGATE_EXPR)
5386 	  step = TREE_OPERAND (step, 0);
5411 	      || operand_equal_p (op, step, 0)))
5419 				   unshare_expr (step)));
5639       || zero_p (get_iv (data, *op_p)->step))
5708 	  && !zero_p (info->iv->step)