1 /* Functions to determine/estimate number of iterations of a loop.
2 Copyright (C) 2004-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
26 #include "basic-block.h"
27 #include "gimple-pretty-print.h"
33 #include "tree-chrec.h"
34 #include "tree-scalar-evolution.h"
35 #include "tree-data-ref.h"
38 #include "diagnostic-core.h"
39 #include "tree-inline.h"
40 #include "tree-pass.h"
43 #define SWAP(X, Y) do { affine_iv *tmp = (X); (X) = (Y); (Y) = tmp; } while (0)
45 /* The maximum number of dominator BBs we search for conditions
46 of loop header copies we use for simplifying a conditional
48 #define MAX_DOMINATORS_TO_WALK 8
52 Analysis of number of iterations of an affine exit test.
56 /* Bounds on some value, BELOW <= X <= UP. */
64 /* Splits expression EXPR to a variable part VAR and constant OFFSET. */
67 split_to_var_and_offset (tree expr
, tree
*var
, mpz_t offset
)
69 tree type
= TREE_TYPE (expr
);
75 mpz_set_ui (offset
, 0);
77 switch (TREE_CODE (expr
))
84 case POINTER_PLUS_EXPR
:
85 op0
= TREE_OPERAND (expr
, 0);
86 op1
= TREE_OPERAND (expr
, 1);
88 if (TREE_CODE (op1
) != INTEGER_CST
)
92 /* Always sign extend the offset. */
93 off
= tree_to_double_int (op1
);
94 off
= off
.sext (TYPE_PRECISION (type
));
95 mpz_set_double_int (offset
, off
, false);
97 mpz_neg (offset
, offset
);
101 *var
= build_int_cst_type (type
, 0);
102 off
= tree_to_double_int (expr
);
103 mpz_set_double_int (offset
, off
, TYPE_UNSIGNED (type
));
111 /* Stores estimate on the minimum/maximum value of the expression VAR + OFF
112 in TYPE to MIN and MAX. */
115 determine_value_range (tree type
, tree var
, mpz_t off
,
116 mpz_t min
, mpz_t max
)
118 /* If the expression is a constant, we know its value exactly. */
119 if (integer_zerop (var
))
126 /* If the computation may wrap, we know nothing about the value, except for
127 the range of the type. */
128 get_type_static_bounds (type
, min
, max
);
129 if (!nowrap_type_p (type
))
132 /* Since the addition of OFF does not wrap, if OFF is positive, then we may
133 add it to MIN, otherwise to MAX. */
134 if (mpz_sgn (off
) < 0)
135 mpz_add (max
, max
, off
);
137 mpz_add (min
, min
, off
);
140 /* Stores the bounds on the difference of the values of the expressions
141 (var + X) and (var + Y), computed in TYPE, to BNDS. */
144 bound_difference_of_offsetted_base (tree type
, mpz_t x
, mpz_t y
,
147 int rel
= mpz_cmp (x
, y
);
148 bool may_wrap
= !nowrap_type_p (type
);
151 /* If X == Y, then the expressions are always equal.
152 If X > Y, there are the following possibilities:
153 a) neither of var + X and var + Y overflow or underflow, or both of
154 them do. Then their difference is X - Y.
155 b) var + X overflows, and var + Y does not. Then the values of the
156 expressions are var + X - M and var + Y, where M is the range of
157 the type, and their difference is X - Y - M.
158 c) var + Y underflows and var + X does not. Their difference again
160 Therefore, if the arithmetics in type does not overflow, then the
161 bounds are (X - Y, X - Y), otherwise they are (X - Y - M, X - Y)
162 Similarly, if X < Y, the bounds are either (X - Y, X - Y) or
163 (X - Y, X - Y + M). */
167 mpz_set_ui (bnds
->below
, 0);
168 mpz_set_ui (bnds
->up
, 0);
173 mpz_set_double_int (m
, double_int::mask (TYPE_PRECISION (type
)), true);
174 mpz_add_ui (m
, m
, 1);
175 mpz_sub (bnds
->up
, x
, y
);
176 mpz_set (bnds
->below
, bnds
->up
);
181 mpz_sub (bnds
->below
, bnds
->below
, m
);
183 mpz_add (bnds
->up
, bnds
->up
, m
);
189 /* From condition C0 CMP C1 derives information regarding the
190 difference of values of VARX + OFFX and VARY + OFFY, computed in TYPE,
191 and stores it to BNDS. */
194 refine_bounds_using_guard (tree type
, tree varx
, mpz_t offx
,
195 tree vary
, mpz_t offy
,
196 tree c0
, enum tree_code cmp
, tree c1
,
199 tree varc0
, varc1
, tmp
, ctype
;
200 mpz_t offc0
, offc1
, loffx
, loffy
, bnd
;
202 bool no_wrap
= nowrap_type_p (type
);
211 STRIP_SIGN_NOPS (c0
);
212 STRIP_SIGN_NOPS (c1
);
213 ctype
= TREE_TYPE (c0
);
214 if (!useless_type_conversion_p (ctype
, type
))
220 /* We could derive quite precise information from EQ_EXPR, however, such
221 a guard is unlikely to appear, so we do not bother with handling
226 /* NE_EXPR comparisons do not contain much of useful information, except for
227 special case of comparing with the bounds of the type. */
228 if (TREE_CODE (c1
) != INTEGER_CST
229 || !INTEGRAL_TYPE_P (type
))
232 /* Ensure that the condition speaks about an expression in the same type
234 ctype
= TREE_TYPE (c0
);
235 if (TYPE_PRECISION (ctype
) != TYPE_PRECISION (type
))
237 c0
= fold_convert (type
, c0
);
238 c1
= fold_convert (type
, c1
);
240 if (TYPE_MIN_VALUE (type
)
241 && operand_equal_p (c1
, TYPE_MIN_VALUE (type
), 0))
246 if (TYPE_MAX_VALUE (type
)
247 && operand_equal_p (c1
, TYPE_MAX_VALUE (type
), 0))
260 split_to_var_and_offset (expand_simple_operations (c0
), &varc0
, offc0
);
261 split_to_var_and_offset (expand_simple_operations (c1
), &varc1
, offc1
);
263 /* We are only interested in comparisons of expressions based on VARX and
264 VARY. TODO -- we might also be able to derive some bounds from
265 expressions containing just one of the variables. */
267 if (operand_equal_p (varx
, varc1
, 0))
269 tmp
= varc0
; varc0
= varc1
; varc1
= tmp
;
270 mpz_swap (offc0
, offc1
);
271 cmp
= swap_tree_comparison (cmp
);
274 if (!operand_equal_p (varx
, varc0
, 0)
275 || !operand_equal_p (vary
, varc1
, 0))
278 mpz_init_set (loffx
, offx
);
279 mpz_init_set (loffy
, offy
);
281 if (cmp
== GT_EXPR
|| cmp
== GE_EXPR
)
283 tmp
= varx
; varx
= vary
; vary
= tmp
;
284 mpz_swap (offc0
, offc1
);
285 mpz_swap (loffx
, loffy
);
286 cmp
= swap_tree_comparison (cmp
);
290 /* If there is no overflow, the condition implies that
292 (VARX + OFFX) cmp (VARY + OFFY) + (OFFX - OFFY + OFFC1 - OFFC0).
294 The overflows and underflows may complicate things a bit; each
295 overflow decreases the appropriate offset by M, and underflow
296 increases it by M. The above inequality would not necessarily be
299 -- VARX + OFFX underflows and VARX + OFFC0 does not, or
300 VARX + OFFC0 overflows, but VARX + OFFX does not.
301 This may only happen if OFFX < OFFC0.
302 -- VARY + OFFY overflows and VARY + OFFC1 does not, or
303 VARY + OFFC1 underflows and VARY + OFFY does not.
304 This may only happen if OFFY > OFFC1. */
313 x_ok
= (integer_zerop (varx
)
314 || mpz_cmp (loffx
, offc0
) >= 0);
315 y_ok
= (integer_zerop (vary
)
316 || mpz_cmp (loffy
, offc1
) <= 0);
322 mpz_sub (bnd
, loffx
, loffy
);
323 mpz_add (bnd
, bnd
, offc1
);
324 mpz_sub (bnd
, bnd
, offc0
);
327 mpz_sub_ui (bnd
, bnd
, 1);
332 if (mpz_cmp (bnds
->below
, bnd
) < 0)
333 mpz_set (bnds
->below
, bnd
);
337 if (mpz_cmp (bnd
, bnds
->up
) < 0)
338 mpz_set (bnds
->up
, bnd
);
350 /* Stores the bounds on the value of the expression X - Y in LOOP to BNDS.
351 The subtraction is considered to be performed in arbitrary precision,
354 We do not attempt to be too clever regarding the value ranges of X and
355 Y; most of the time, they are just integers or ssa names offsetted by
356 integer. However, we try to use the information contained in the
357 comparisons before the loop (usually created by loop header copying). */
360 bound_difference (struct loop
*loop
, tree x
, tree y
, bounds
*bnds
)
362 tree type
= TREE_TYPE (x
);
365 mpz_t minx
, maxx
, miny
, maxy
;
373 /* Get rid of unnecessary casts, but preserve the value of
378 mpz_init (bnds
->below
);
382 split_to_var_and_offset (x
, &varx
, offx
);
383 split_to_var_and_offset (y
, &vary
, offy
);
385 if (!integer_zerop (varx
)
386 && operand_equal_p (varx
, vary
, 0))
388 /* Special case VARX == VARY -- we just need to compare the
389 offsets. The matters are a bit more complicated in the
390 case addition of offsets may wrap. */
391 bound_difference_of_offsetted_base (type
, offx
, offy
, bnds
);
395 /* Otherwise, use the value ranges to determine the initial
396 estimates on below and up. */
401 determine_value_range (type
, varx
, offx
, minx
, maxx
);
402 determine_value_range (type
, vary
, offy
, miny
, maxy
);
404 mpz_sub (bnds
->below
, minx
, maxy
);
405 mpz_sub (bnds
->up
, maxx
, miny
);
412 /* If both X and Y are constants, we cannot get any more precise. */
413 if (integer_zerop (varx
) && integer_zerop (vary
))
416 /* Now walk the dominators of the loop header and use the entry
417 guards to refine the estimates. */
418 for (bb
= loop
->header
;
419 bb
!= ENTRY_BLOCK_PTR
&& cnt
< MAX_DOMINATORS_TO_WALK
;
420 bb
= get_immediate_dominator (CDI_DOMINATORS
, bb
))
422 if (!single_pred_p (bb
))
424 e
= single_pred_edge (bb
);
426 if (!(e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
429 cond
= last_stmt (e
->src
);
430 c0
= gimple_cond_lhs (cond
);
431 cmp
= gimple_cond_code (cond
);
432 c1
= gimple_cond_rhs (cond
);
434 if (e
->flags
& EDGE_FALSE_VALUE
)
435 cmp
= invert_tree_comparison (cmp
, false);
437 refine_bounds_using_guard (type
, varx
, offx
, vary
, offy
,
447 /* Update the bounds in BNDS that restrict the value of X to the bounds
448 that restrict the value of X + DELTA. X can be obtained as a
449 difference of two values in TYPE. */
452 bounds_add (bounds
*bnds
, double_int delta
, tree type
)
457 mpz_set_double_int (mdelta
, delta
, false);
460 mpz_set_double_int (max
, double_int::mask (TYPE_PRECISION (type
)), true);
462 mpz_add (bnds
->up
, bnds
->up
, mdelta
);
463 mpz_add (bnds
->below
, bnds
->below
, mdelta
);
465 if (mpz_cmp (bnds
->up
, max
) > 0)
466 mpz_set (bnds
->up
, max
);
469 if (mpz_cmp (bnds
->below
, max
) < 0)
470 mpz_set (bnds
->below
, max
);
476 /* Update the bounds in BNDS that restrict the value of X to the bounds
477 that restrict the value of -X. */
480 bounds_negate (bounds
*bnds
)
484 mpz_init_set (tmp
, bnds
->up
);
485 mpz_neg (bnds
->up
, bnds
->below
);
486 mpz_neg (bnds
->below
, tmp
);
490 /* Returns inverse of X modulo 2^s, where MASK = 2^s-1. */
493 inverse (tree x
, tree mask
)
495 tree type
= TREE_TYPE (x
);
497 unsigned ctr
= tree_floor_log2 (mask
);
499 if (TYPE_PRECISION (type
) <= HOST_BITS_PER_WIDE_INT
)
501 unsigned HOST_WIDE_INT ix
;
502 unsigned HOST_WIDE_INT imask
;
503 unsigned HOST_WIDE_INT irslt
= 1;
505 gcc_assert (cst_and_fits_in_hwi (x
));
506 gcc_assert (cst_and_fits_in_hwi (mask
));
508 ix
= int_cst_value (x
);
509 imask
= int_cst_value (mask
);
518 rslt
= build_int_cst_type (type
, irslt
);
522 rslt
= build_int_cst (type
, 1);
525 rslt
= int_const_binop (MULT_EXPR
, rslt
, x
);
526 x
= int_const_binop (MULT_EXPR
, x
, x
);
528 rslt
= int_const_binop (BIT_AND_EXPR
, rslt
, mask
);
534 /* Derives the upper bound BND on the number of executions of loop with exit
535 condition S * i <> C. If NO_OVERFLOW is true, then the control variable of
536 the loop does not overflow. EXIT_MUST_BE_TAKEN is true if we are guaranteed
537 that the loop ends through this exit, i.e., the induction variable ever
538 reaches the value of C.
540 The value C is equal to final - base, where final and base are the final and
541 initial value of the actual induction variable in the analysed loop. BNDS
542 bounds the value of this difference when computed in signed type with
543 unbounded range, while the computation of C is performed in an unsigned
544 type with the range matching the range of the type of the induction variable.
545 In particular, BNDS.up contains an upper bound on C in the following cases:
546 -- if the iv must reach its final value without overflow, i.e., if
547 NO_OVERFLOW && EXIT_MUST_BE_TAKEN is true, or
548 -- if final >= base, which we know to hold when BNDS.below >= 0. */
551 number_of_iterations_ne_max (mpz_t bnd
, bool no_overflow
, tree c
, tree s
,
552 bounds
*bnds
, bool exit_must_be_taken
)
556 tree type
= TREE_TYPE (c
);
557 bool bnds_u_valid
= ((no_overflow
&& exit_must_be_taken
)
558 || mpz_sgn (bnds
->below
) >= 0);
561 || (TREE_CODE (c
) == INTEGER_CST
562 && TREE_CODE (s
) == INTEGER_CST
563 && tree_to_double_int (c
).mod (tree_to_double_int (s
),
564 TYPE_UNSIGNED (type
),
565 EXACT_DIV_EXPR
).is_zero ())
566 || (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (c
))
567 && multiple_of_p (type
, c
, s
)))
569 /* If C is an exact multiple of S, then its value will be reached before
570 the induction variable overflows (unless the loop is exited in some
571 other way before). Note that the actual induction variable in the
572 loop (which ranges from base to final instead of from 0 to C) may
573 overflow, in which case BNDS.up will not be giving a correct upper
574 bound on C; thus, BNDS_U_VALID had to be computed in advance. */
576 exit_must_be_taken
= true;
579 /* If the induction variable can overflow, the number of iterations is at
580 most the period of the control variable (or infinite, but in that case
581 the whole # of iterations analysis will fail). */
584 max
= double_int::mask (TYPE_PRECISION (type
)
585 - tree_low_cst (num_ending_zeros (s
), 1));
586 mpz_set_double_int (bnd
, max
, true);
590 /* Now we know that the induction variable does not overflow, so the loop
591 iterates at most (range of type / S) times. */
592 mpz_set_double_int (bnd
, double_int::mask (TYPE_PRECISION (type
)), true);
594 /* If the induction variable is guaranteed to reach the value of C before
596 if (exit_must_be_taken
)
598 /* ... then we can strengthen this to C / S, and possibly we can use
599 the upper bound on C given by BNDS. */
600 if (TREE_CODE (c
) == INTEGER_CST
)
601 mpz_set_double_int (bnd
, tree_to_double_int (c
), true);
602 else if (bnds_u_valid
)
603 mpz_set (bnd
, bnds
->up
);
607 mpz_set_double_int (d
, tree_to_double_int (s
), true);
608 mpz_fdiv_q (bnd
, bnd
, d
);
612 /* Determines number of iterations of loop whose ending condition
613 is IV <> FINAL. TYPE is the type of the iv. The number of
614 iterations is stored to NITER. EXIT_MUST_BE_TAKEN is true if
615 we know that the exit must be taken eventually, i.e., that the IV
616 ever reaches the value FINAL (we derived this earlier, and possibly set
617 NITER->assumptions to make sure this is the case). BNDS contains the
618 bounds on the difference FINAL - IV->base. */
621 number_of_iterations_ne (tree type
, affine_iv
*iv
, tree final
,
622 struct tree_niter_desc
*niter
, bool exit_must_be_taken
,
625 tree niter_type
= unsigned_type_for (type
);
626 tree s
, c
, d
, bits
, assumption
, tmp
, bound
;
629 niter
->control
= *iv
;
630 niter
->bound
= final
;
631 niter
->cmp
= NE_EXPR
;
633 /* Rearrange the terms so that we get inequality S * i <> C, with S
634 positive. Also cast everything to the unsigned type. If IV does
635 not overflow, BNDS bounds the value of C. Also, this is the
636 case if the computation |FINAL - IV->base| does not overflow, i.e.,
637 if BNDS->below in the result is nonnegative. */
638 if (tree_int_cst_sign_bit (iv
->step
))
640 s
= fold_convert (niter_type
,
641 fold_build1 (NEGATE_EXPR
, type
, iv
->step
));
642 c
= fold_build2 (MINUS_EXPR
, niter_type
,
643 fold_convert (niter_type
, iv
->base
),
644 fold_convert (niter_type
, final
));
645 bounds_negate (bnds
);
649 s
= fold_convert (niter_type
, iv
->step
);
650 c
= fold_build2 (MINUS_EXPR
, niter_type
,
651 fold_convert (niter_type
, final
),
652 fold_convert (niter_type
, iv
->base
));
656 number_of_iterations_ne_max (max
, iv
->no_overflow
, c
, s
, bnds
,
658 niter
->max
= mpz_get_double_int (niter_type
, max
, false);
661 /* First the trivial cases -- when the step is 1. */
662 if (integer_onep (s
))
668 /* Let nsd (step, size of mode) = d. If d does not divide c, the loop
669 is infinite. Otherwise, the number of iterations is
670 (inverse(s/d) * (c/d)) mod (size of mode/d). */
671 bits
= num_ending_zeros (s
);
672 bound
= build_low_bits_mask (niter_type
,
673 (TYPE_PRECISION (niter_type
)
674 - tree_low_cst (bits
, 1)));
676 d
= fold_binary_to_constant (LSHIFT_EXPR
, niter_type
,
677 build_int_cst (niter_type
, 1), bits
);
678 s
= fold_binary_to_constant (RSHIFT_EXPR
, niter_type
, s
, bits
);
680 if (!exit_must_be_taken
)
682 /* If we cannot assume that the exit is taken eventually, record the
683 assumptions for divisibility of c. */
684 assumption
= fold_build2 (FLOOR_MOD_EXPR
, niter_type
, c
, d
);
685 assumption
= fold_build2 (EQ_EXPR
, boolean_type_node
,
686 assumption
, build_int_cst (niter_type
, 0));
687 if (!integer_nonzerop (assumption
))
688 niter
->assumptions
= fold_build2 (TRUTH_AND_EXPR
, boolean_type_node
,
689 niter
->assumptions
, assumption
);
692 c
= fold_build2 (EXACT_DIV_EXPR
, niter_type
, c
, d
);
693 tmp
= fold_build2 (MULT_EXPR
, niter_type
, c
, inverse (s
, bound
));
694 niter
->niter
= fold_build2 (BIT_AND_EXPR
, niter_type
, tmp
, bound
);
698 /* Checks whether we can determine the final value of the control variable
699 of the loop with ending condition IV0 < IV1 (computed in TYPE).
700 DELTA is the difference IV1->base - IV0->base, STEP is the absolute value
701 of the step. The assumptions necessary to ensure that the computation
702 of the final value does not overflow are recorded in NITER. If we
703 find the final value, we adjust DELTA and return TRUE. Otherwise
704 we return false. BNDS bounds the value of IV1->base - IV0->base,
705 and will be updated by the same amount as DELTA. EXIT_MUST_BE_TAKEN is
706 true if we know that the exit must be taken eventually. */
709 number_of_iterations_lt_to_ne (tree type
, affine_iv
*iv0
, affine_iv
*iv1
,
710 struct tree_niter_desc
*niter
,
711 tree
*delta
, tree step
,
712 bool exit_must_be_taken
, bounds
*bnds
)
714 tree niter_type
= TREE_TYPE (step
);
715 tree mod
= fold_build2 (FLOOR_MOD_EXPR
, niter_type
, *delta
, step
);
718 tree assumption
= boolean_true_node
, bound
, noloop
;
719 bool ret
= false, fv_comp_no_overflow
;
721 if (POINTER_TYPE_P (type
))
724 if (TREE_CODE (mod
) != INTEGER_CST
)
726 if (integer_nonzerop (mod
))
727 mod
= fold_build2 (MINUS_EXPR
, niter_type
, step
, mod
);
728 tmod
= fold_convert (type1
, mod
);
731 mpz_set_double_int (mmod
, tree_to_double_int (mod
), true);
732 mpz_neg (mmod
, mmod
);
734 /* If the induction variable does not overflow and the exit is taken,
735 then the computation of the final value does not overflow. This is
736 also obviously the case if the new final value is equal to the
737 current one. Finally, we postulate this for pointer type variables,
738 as the code cannot rely on the object to that the pointer points being
739 placed at the end of the address space (and more pragmatically,
740 TYPE_{MIN,MAX}_VALUE is not defined for pointers). */
741 if (integer_zerop (mod
) || POINTER_TYPE_P (type
))
742 fv_comp_no_overflow
= true;
743 else if (!exit_must_be_taken
)
744 fv_comp_no_overflow
= false;
746 fv_comp_no_overflow
=
747 (iv0
->no_overflow
&& integer_nonzerop (iv0
->step
))
748 || (iv1
->no_overflow
&& integer_nonzerop (iv1
->step
));
750 if (integer_nonzerop (iv0
->step
))
752 /* The final value of the iv is iv1->base + MOD, assuming that this
753 computation does not overflow, and that
754 iv0->base <= iv1->base + MOD. */
755 if (!fv_comp_no_overflow
)
757 bound
= fold_build2 (MINUS_EXPR
, type1
,
758 TYPE_MAX_VALUE (type1
), tmod
);
759 assumption
= fold_build2 (LE_EXPR
, boolean_type_node
,
761 if (integer_zerop (assumption
))
764 if (mpz_cmp (mmod
, bnds
->below
) < 0)
765 noloop
= boolean_false_node
;
766 else if (POINTER_TYPE_P (type
))
767 noloop
= fold_build2 (GT_EXPR
, boolean_type_node
,
769 fold_build_pointer_plus (iv1
->base
, tmod
));
771 noloop
= fold_build2 (GT_EXPR
, boolean_type_node
,
773 fold_build2 (PLUS_EXPR
, type1
,
778 /* The final value of the iv is iv0->base - MOD, assuming that this
779 computation does not overflow, and that
780 iv0->base - MOD <= iv1->base. */
781 if (!fv_comp_no_overflow
)
783 bound
= fold_build2 (PLUS_EXPR
, type1
,
784 TYPE_MIN_VALUE (type1
), tmod
);
785 assumption
= fold_build2 (GE_EXPR
, boolean_type_node
,
787 if (integer_zerop (assumption
))
790 if (mpz_cmp (mmod
, bnds
->below
) < 0)
791 noloop
= boolean_false_node
;
792 else if (POINTER_TYPE_P (type
))
793 noloop
= fold_build2 (GT_EXPR
, boolean_type_node
,
794 fold_build_pointer_plus (iv0
->base
,
795 fold_build1 (NEGATE_EXPR
,
799 noloop
= fold_build2 (GT_EXPR
, boolean_type_node
,
800 fold_build2 (MINUS_EXPR
, type1
,
805 if (!integer_nonzerop (assumption
))
806 niter
->assumptions
= fold_build2 (TRUTH_AND_EXPR
, boolean_type_node
,
809 if (!integer_zerop (noloop
))
810 niter
->may_be_zero
= fold_build2 (TRUTH_OR_EXPR
, boolean_type_node
,
813 bounds_add (bnds
, tree_to_double_int (mod
), type
);
814 *delta
= fold_build2 (PLUS_EXPR
, niter_type
, *delta
, mod
);
822 /* Add assertions to NITER that ensure that the control variable of the loop
823 with ending condition IV0 < IV1 does not overflow. Types of IV0 and IV1
824 are TYPE. Returns false if we can prove that there is an overflow, true
825 otherwise. STEP is the absolute value of the step. */
828 assert_no_overflow_lt (tree type
, affine_iv
*iv0
, affine_iv
*iv1
,
829 struct tree_niter_desc
*niter
, tree step
)
831 tree bound
, d
, assumption
, diff
;
832 tree niter_type
= TREE_TYPE (step
);
834 if (integer_nonzerop (iv0
->step
))
836 /* for (i = iv0->base; i < iv1->base; i += iv0->step) */
837 if (iv0
->no_overflow
)
840 /* If iv0->base is a constant, we can determine the last value before
841 overflow precisely; otherwise we conservatively assume
844 if (TREE_CODE (iv0
->base
) == INTEGER_CST
)
846 d
= fold_build2 (MINUS_EXPR
, niter_type
,
847 fold_convert (niter_type
, TYPE_MAX_VALUE (type
)),
848 fold_convert (niter_type
, iv0
->base
));
849 diff
= fold_build2 (FLOOR_MOD_EXPR
, niter_type
, d
, step
);
852 diff
= fold_build2 (MINUS_EXPR
, niter_type
, step
,
853 build_int_cst (niter_type
, 1));
854 bound
= fold_build2 (MINUS_EXPR
, type
,
855 TYPE_MAX_VALUE (type
), fold_convert (type
, diff
));
856 assumption
= fold_build2 (LE_EXPR
, boolean_type_node
,
861 /* for (i = iv1->base; i > iv0->base; i += iv1->step) */
862 if (iv1
->no_overflow
)
865 if (TREE_CODE (iv1
->base
) == INTEGER_CST
)
867 d
= fold_build2 (MINUS_EXPR
, niter_type
,
868 fold_convert (niter_type
, iv1
->base
),
869 fold_convert (niter_type
, TYPE_MIN_VALUE (type
)));
870 diff
= fold_build2 (FLOOR_MOD_EXPR
, niter_type
, d
, step
);
873 diff
= fold_build2 (MINUS_EXPR
, niter_type
, step
,
874 build_int_cst (niter_type
, 1));
875 bound
= fold_build2 (PLUS_EXPR
, type
,
876 TYPE_MIN_VALUE (type
), fold_convert (type
, diff
));
877 assumption
= fold_build2 (GE_EXPR
, boolean_type_node
,
881 if (integer_zerop (assumption
))
883 if (!integer_nonzerop (assumption
))
884 niter
->assumptions
= fold_build2 (TRUTH_AND_EXPR
, boolean_type_node
,
885 niter
->assumptions
, assumption
);
887 iv0
->no_overflow
= true;
888 iv1
->no_overflow
= true;
892 /* Add an assumption to NITER that a loop whose ending condition
893 is IV0 < IV1 rolls. TYPE is the type of the control iv. BNDS
894 bounds the value of IV1->base - IV0->base. */
897 assert_loop_rolls_lt (tree type
, affine_iv
*iv0
, affine_iv
*iv1
,
898 struct tree_niter_desc
*niter
, bounds
*bnds
)
900 tree assumption
= boolean_true_node
, bound
, diff
;
901 tree mbz
, mbzl
, mbzr
, type1
;
902 bool rolls_p
, no_overflow_p
;
906 /* We are going to compute the number of iterations as
907 (iv1->base - iv0->base + step - 1) / step, computed in the unsigned
908 variant of TYPE. This formula only works if
910 -step + 1 <= (iv1->base - iv0->base) <= MAX - step + 1
912 (where MAX is the maximum value of the unsigned variant of TYPE, and
913 the computations in this formula are performed in full precision,
914 i.e., without overflows).
916 Usually, for loops with exit condition iv0->base + step * i < iv1->base,
917 we have a condition of the form iv0->base - step < iv1->base before the loop,
918 and for loops iv0->base < iv1->base - step * i the condition
919 iv0->base < iv1->base + step, due to loop header copying, which enable us
920 to prove the lower bound.
922 The upper bound is more complicated. Unless the expressions for initial
923 and final value themselves contain enough information, we usually cannot
924 derive it from the context. */
926 /* First check whether the answer does not follow from the bounds we gathered
928 if (integer_nonzerop (iv0
->step
))
929 dstep
= tree_to_double_int (iv0
->step
);
932 dstep
= tree_to_double_int (iv1
->step
).sext (TYPE_PRECISION (type
));
937 mpz_set_double_int (mstep
, dstep
, true);
938 mpz_neg (mstep
, mstep
);
939 mpz_add_ui (mstep
, mstep
, 1);
941 rolls_p
= mpz_cmp (mstep
, bnds
->below
) <= 0;
944 mpz_set_double_int (max
, double_int::mask (TYPE_PRECISION (type
)), true);
945 mpz_add (max
, max
, mstep
);
946 no_overflow_p
= (mpz_cmp (bnds
->up
, max
) <= 0
947 /* For pointers, only values lying inside a single object
948 can be compared or manipulated by pointer arithmetics.
949 Gcc in general does not allow or handle objects larger
950 than half of the address space, hence the upper bound
951 is satisfied for pointers. */
952 || POINTER_TYPE_P (type
));
956 if (rolls_p
&& no_overflow_p
)
960 if (POINTER_TYPE_P (type
))
963 /* Now the hard part; we must formulate the assumption(s) as expressions, and
964 we must be careful not to introduce overflow. */
966 if (integer_nonzerop (iv0
->step
))
968 diff
= fold_build2 (MINUS_EXPR
, type1
,
969 iv0
->step
, build_int_cst (type1
, 1));
971 /* We need to know that iv0->base >= MIN + iv0->step - 1. Since
972 0 address never belongs to any object, we can assume this for
974 if (!POINTER_TYPE_P (type
))
976 bound
= fold_build2 (PLUS_EXPR
, type1
,
977 TYPE_MIN_VALUE (type
), diff
);
978 assumption
= fold_build2 (GE_EXPR
, boolean_type_node
,
982 /* And then we can compute iv0->base - diff, and compare it with
984 mbzl
= fold_build2 (MINUS_EXPR
, type1
,
985 fold_convert (type1
, iv0
->base
), diff
);
986 mbzr
= fold_convert (type1
, iv1
->base
);
990 diff
= fold_build2 (PLUS_EXPR
, type1
,
991 iv1
->step
, build_int_cst (type1
, 1));
993 if (!POINTER_TYPE_P (type
))
995 bound
= fold_build2 (PLUS_EXPR
, type1
,
996 TYPE_MAX_VALUE (type
), diff
);
997 assumption
= fold_build2 (LE_EXPR
, boolean_type_node
,
1001 mbzl
= fold_convert (type1
, iv0
->base
);
1002 mbzr
= fold_build2 (MINUS_EXPR
, type1
,
1003 fold_convert (type1
, iv1
->base
), diff
);
1006 if (!integer_nonzerop (assumption
))
1007 niter
->assumptions
= fold_build2 (TRUTH_AND_EXPR
, boolean_type_node
,
1008 niter
->assumptions
, assumption
);
1011 mbz
= fold_build2 (GT_EXPR
, boolean_type_node
, mbzl
, mbzr
);
1012 niter
->may_be_zero
= fold_build2 (TRUTH_OR_EXPR
, boolean_type_node
,
1013 niter
->may_be_zero
, mbz
);
1017 /* Determines number of iterations of loop whose ending condition
1018 is IV0 < IV1. TYPE is the type of the iv. The number of
1019 iterations is stored to NITER. BNDS bounds the difference
1020 IV1->base - IV0->base. EXIT_MUST_BE_TAKEN is true if we know
1021 that the exit must be taken eventually. */
1024 number_of_iterations_lt (tree type
, affine_iv
*iv0
, affine_iv
*iv1
,
1025 struct tree_niter_desc
*niter
,
1026 bool exit_must_be_taken
, bounds
*bnds
)
1028 tree niter_type
= unsigned_type_for (type
);
1029 tree delta
, step
, s
;
1032 if (integer_nonzerop (iv0
->step
))
1034 niter
->control
= *iv0
;
1035 niter
->cmp
= LT_EXPR
;
1036 niter
->bound
= iv1
->base
;
1040 niter
->control
= *iv1
;
1041 niter
->cmp
= GT_EXPR
;
1042 niter
->bound
= iv0
->base
;
1045 delta
= fold_build2 (MINUS_EXPR
, niter_type
,
1046 fold_convert (niter_type
, iv1
->base
),
1047 fold_convert (niter_type
, iv0
->base
));
1049 /* First handle the special case that the step is +-1. */
1050 if ((integer_onep (iv0
->step
) && integer_zerop (iv1
->step
))
1051 || (integer_all_onesp (iv1
->step
) && integer_zerop (iv0
->step
)))
1053 /* for (i = iv0->base; i < iv1->base; i++)
1057 for (i = iv1->base; i > iv0->base; i--).
1059 In both cases # of iterations is iv1->base - iv0->base, assuming that
1060 iv1->base >= iv0->base.
1062 First try to derive a lower bound on the value of
1063 iv1->base - iv0->base, computed in full precision. If the difference
1064 is nonnegative, we are done, otherwise we must record the
1067 if (mpz_sgn (bnds
->below
) < 0)
1068 niter
->may_be_zero
= fold_build2 (LT_EXPR
, boolean_type_node
,
1069 iv1
->base
, iv0
->base
);
1070 niter
->niter
= delta
;
1071 niter
->max
= mpz_get_double_int (niter_type
, bnds
->up
, false);
1075 if (integer_nonzerop (iv0
->step
))
1076 step
= fold_convert (niter_type
, iv0
->step
);
1078 step
= fold_convert (niter_type
,
1079 fold_build1 (NEGATE_EXPR
, type
, iv1
->step
));
1081 /* If we can determine the final value of the control iv exactly, we can
1082 transform the condition to != comparison. In particular, this will be
1083 the case if DELTA is constant. */
1084 if (number_of_iterations_lt_to_ne (type
, iv0
, iv1
, niter
, &delta
, step
,
1085 exit_must_be_taken
, bnds
))
1089 zps
.base
= build_int_cst (niter_type
, 0);
1091 /* number_of_iterations_lt_to_ne will add assumptions that ensure that
1092 zps does not overflow. */
1093 zps
.no_overflow
= true;
1095 return number_of_iterations_ne (type
, &zps
, delta
, niter
, true, bnds
);
1098 /* Make sure that the control iv does not overflow. */
1099 if (!assert_no_overflow_lt (type
, iv0
, iv1
, niter
, step
))
1102 /* We determine the number of iterations as (delta + step - 1) / step. For
1103 this to work, we must know that iv1->base >= iv0->base - step + 1,
1104 otherwise the loop does not roll. */
1105 assert_loop_rolls_lt (type
, iv0
, iv1
, niter
, bnds
);
1107 s
= fold_build2 (MINUS_EXPR
, niter_type
,
1108 step
, build_int_cst (niter_type
, 1));
1109 delta
= fold_build2 (PLUS_EXPR
, niter_type
, delta
, s
);
1110 niter
->niter
= fold_build2 (FLOOR_DIV_EXPR
, niter_type
, delta
, step
);
1114 mpz_set_double_int (mstep
, tree_to_double_int (step
), true);
1115 mpz_add (tmp
, bnds
->up
, mstep
);
1116 mpz_sub_ui (tmp
, tmp
, 1);
1117 mpz_fdiv_q (tmp
, tmp
, mstep
);
1118 niter
->max
= mpz_get_double_int (niter_type
, tmp
, false);
1125 /* Determines number of iterations of loop whose ending condition
1126 is IV0 <= IV1. TYPE is the type of the iv. The number of
1127 iterations is stored to NITER. EXIT_MUST_BE_TAKEN is true if
1128 we know that this condition must eventually become false (we derived this
1129 earlier, and possibly set NITER->assumptions to make sure this
1130 is the case). BNDS bounds the difference IV1->base - IV0->base. */
1133 number_of_iterations_le (tree type
, affine_iv
*iv0
, affine_iv
*iv1
,
1134 struct tree_niter_desc
*niter
, bool exit_must_be_taken
,
1139 if (POINTER_TYPE_P (type
))
1142 /* Say that IV0 is the control variable. Then IV0 <= IV1 iff
1143 IV0 < IV1 + 1, assuming that IV1 is not equal to the greatest
1144 value of the type. This we must know anyway, since if it is
1145 equal to this value, the loop rolls forever. We do not check
1146 this condition for pointer type ivs, as the code cannot rely on
1147 the object to that the pointer points being placed at the end of
1148 the address space (and more pragmatically, TYPE_{MIN,MAX}_VALUE is
1149 not defined for pointers). */
1151 if (!exit_must_be_taken
&& !POINTER_TYPE_P (type
))
1153 if (integer_nonzerop (iv0
->step
))
1154 assumption
= fold_build2 (NE_EXPR
, boolean_type_node
,
1155 iv1
->base
, TYPE_MAX_VALUE (type
));
1157 assumption
= fold_build2 (NE_EXPR
, boolean_type_node
,
1158 iv0
->base
, TYPE_MIN_VALUE (type
));
1160 if (integer_zerop (assumption
))
1162 if (!integer_nonzerop (assumption
))
1163 niter
->assumptions
= fold_build2 (TRUTH_AND_EXPR
, boolean_type_node
,
1164 niter
->assumptions
, assumption
);
1167 if (integer_nonzerop (iv0
->step
))
1169 if (POINTER_TYPE_P (type
))
1170 iv1
->base
= fold_build_pointer_plus_hwi (iv1
->base
, 1);
1172 iv1
->base
= fold_build2 (PLUS_EXPR
, type1
, iv1
->base
,
1173 build_int_cst (type1
, 1));
1175 else if (POINTER_TYPE_P (type
))
1176 iv0
->base
= fold_build_pointer_plus_hwi (iv0
->base
, -1);
1178 iv0
->base
= fold_build2 (MINUS_EXPR
, type1
,
1179 iv0
->base
, build_int_cst (type1
, 1));
1181 bounds_add (bnds
, double_int_one
, type1
);
1183 return number_of_iterations_lt (type
, iv0
, iv1
, niter
, exit_must_be_taken
,
1187 /* Dumps description of affine induction variable IV to FILE. */
1190 dump_affine_iv (FILE *file
, affine_iv
*iv
)
1192 if (!integer_zerop (iv
->step
))
1193 fprintf (file
, "[");
1195 print_generic_expr (dump_file
, iv
->base
, TDF_SLIM
);
1197 if (!integer_zerop (iv
->step
))
1199 fprintf (file
, ", + , ");
1200 print_generic_expr (dump_file
, iv
->step
, TDF_SLIM
);
1201 fprintf (file
, "]%s", iv
->no_overflow
? "(no_overflow)" : "");
1205 /* Determine the number of iterations according to condition (for staying
1206 inside loop) which compares two induction variables using comparison
1207 operator CODE. The induction variable on left side of the comparison
1208 is IV0, the right-hand side is IV1. Both induction variables must have
1209 type TYPE, which must be an integer or pointer type. The steps of the
1210 ivs must be constants (or NULL_TREE, which is interpreted as constant zero).
1212 LOOP is the loop whose number of iterations we are determining.
1214 ONLY_EXIT is true if we are sure this is the only way the loop could be
1215 exited (including possibly non-returning function calls, exceptions, etc.)
1216 -- in this case we can use the information whether the control induction
1217 variables can overflow or not in a more efficient way.
1219 if EVERY_ITERATION is true, we know the test is executed on every iteration.
1221 The results (number of iterations and assumptions as described in
1222 comments at struct tree_niter_desc in tree-flow.h) are stored to NITER.
1223 Returns false if it fails to determine number of iterations, true if it
1224 was determined (possibly with some assumptions). */
1227 number_of_iterations_cond (struct loop
*loop
,
1228 tree type
, affine_iv
*iv0
, enum tree_code code
,
1229 affine_iv
*iv1
, struct tree_niter_desc
*niter
,
1230 bool only_exit
, bool every_iteration
)
1232 bool exit_must_be_taken
= false, ret
;
1235 /* If the test is not executed every iteration, wrapping may make the test
1237 TODO: the overflow case can be still used as unreliable estimate of upper
1238 bound. But we have no API to pass it down to number of iterations code
1239 and, at present, it will not use it anyway. */
1240 if (!every_iteration
1241 && (!iv0
->no_overflow
|| !iv1
->no_overflow
1242 || code
== NE_EXPR
|| code
== EQ_EXPR
))
1245 /* The meaning of these assumptions is this:
1247 then the rest of information does not have to be valid
1248 if may_be_zero then the loop does not roll, even if
1250 niter
->assumptions
= boolean_true_node
;
1251 niter
->may_be_zero
= boolean_false_node
;
1252 niter
->niter
= NULL_TREE
;
1253 niter
->max
= double_int_zero
;
1255 niter
->bound
= NULL_TREE
;
1256 niter
->cmp
= ERROR_MARK
;
1258 /* Make < comparison from > ones, and for NE_EXPR comparisons, ensure that
1259 the control variable is on lhs. */
1260 if (code
== GE_EXPR
|| code
== GT_EXPR
1261 || (code
== NE_EXPR
&& integer_zerop (iv0
->step
)))
1264 code
= swap_tree_comparison (code
);
1267 if (POINTER_TYPE_P (type
))
1269 /* Comparison of pointers is undefined unless both iv0 and iv1 point
1270 to the same object. If they do, the control variable cannot wrap
1271 (as wrap around the bounds of memory will never return a pointer
1272 that would be guaranteed to point to the same object, even if we
1273 avoid undefined behavior by casting to size_t and back). */
1274 iv0
->no_overflow
= true;
1275 iv1
->no_overflow
= true;
1278 /* If the control induction variable does not overflow and the only exit
1279 from the loop is the one that we analyze, we know it must be taken
1283 if (!integer_zerop (iv0
->step
) && iv0
->no_overflow
)
1284 exit_must_be_taken
= true;
1285 else if (!integer_zerop (iv1
->step
) && iv1
->no_overflow
)
1286 exit_must_be_taken
= true;
1289 /* We can handle the case when neither of the sides of the comparison is
1290 invariant, provided that the test is NE_EXPR. This rarely occurs in
1291 practice, but it is simple enough to manage. */
1292 if (!integer_zerop (iv0
->step
) && !integer_zerop (iv1
->step
))
1294 tree step_type
= POINTER_TYPE_P (type
) ? sizetype
: type
;
1295 if (code
!= NE_EXPR
)
1298 iv0
->step
= fold_binary_to_constant (MINUS_EXPR
, step_type
,
1299 iv0
->step
, iv1
->step
);
1300 iv0
->no_overflow
= false;
1301 iv1
->step
= build_int_cst (step_type
, 0);
1302 iv1
->no_overflow
= true;
1305 /* If the result of the comparison is a constant, the loop is weird. More
1306 precise handling would be possible, but the situation is not common enough
1307 to waste time on it. */
1308 if (integer_zerop (iv0
->step
) && integer_zerop (iv1
->step
))
1311 /* Ignore loops of while (i-- < 10) type. */
1312 if (code
!= NE_EXPR
)
1314 if (iv0
->step
&& tree_int_cst_sign_bit (iv0
->step
))
1317 if (!integer_zerop (iv1
->step
) && !tree_int_cst_sign_bit (iv1
->step
))
1321 /* If the loop exits immediately, there is nothing to do. */
1322 tree tem
= fold_binary (code
, boolean_type_node
, iv0
->base
, iv1
->base
);
1323 if (tem
&& integer_zerop (tem
))
1325 niter
->niter
= build_int_cst (unsigned_type_for (type
), 0);
1326 niter
->max
= double_int_zero
;
1330 /* OK, now we know we have a senseful loop. Handle several cases, depending
1331 on what comparison operator is used. */
1332 bound_difference (loop
, iv1
->base
, iv0
->base
, &bnds
);
1334 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1337 "Analyzing # of iterations of loop %d\n", loop
->num
);
1339 fprintf (dump_file
, " exit condition ");
1340 dump_affine_iv (dump_file
, iv0
);
1341 fprintf (dump_file
, " %s ",
1342 code
== NE_EXPR
? "!="
1343 : code
== LT_EXPR
? "<"
1345 dump_affine_iv (dump_file
, iv1
);
1346 fprintf (dump_file
, "\n");
1348 fprintf (dump_file
, " bounds on difference of bases: ");
1349 mpz_out_str (dump_file
, 10, bnds
.below
);
1350 fprintf (dump_file
, " ... ");
1351 mpz_out_str (dump_file
, 10, bnds
.up
);
1352 fprintf (dump_file
, "\n");
1358 gcc_assert (integer_zerop (iv1
->step
));
1359 ret
= number_of_iterations_ne (type
, iv0
, iv1
->base
, niter
,
1360 exit_must_be_taken
, &bnds
);
1364 ret
= number_of_iterations_lt (type
, iv0
, iv1
, niter
, exit_must_be_taken
,
1369 ret
= number_of_iterations_le (type
, iv0
, iv1
, niter
, exit_must_be_taken
,
1377 mpz_clear (bnds
.up
);
1378 mpz_clear (bnds
.below
);
1380 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1384 fprintf (dump_file
, " result:\n");
1385 if (!integer_nonzerop (niter
->assumptions
))
1387 fprintf (dump_file
, " under assumptions ");
1388 print_generic_expr (dump_file
, niter
->assumptions
, TDF_SLIM
);
1389 fprintf (dump_file
, "\n");
1392 if (!integer_zerop (niter
->may_be_zero
))
1394 fprintf (dump_file
, " zero if ");
1395 print_generic_expr (dump_file
, niter
->may_be_zero
, TDF_SLIM
);
1396 fprintf (dump_file
, "\n");
1399 fprintf (dump_file
, " # of iterations ");
1400 print_generic_expr (dump_file
, niter
->niter
, TDF_SLIM
);
1401 fprintf (dump_file
, ", bounded by ");
1402 dump_double_int (dump_file
, niter
->max
, true);
1403 fprintf (dump_file
, "\n");
1406 fprintf (dump_file
, " failed\n\n");
1411 /* Substitute NEW for OLD in EXPR and fold the result. */
1414 simplify_replace_tree (tree expr
, tree old
, tree new_tree
)
1417 tree ret
= NULL_TREE
, e
, se
;
1422 /* Do not bother to replace constants. */
1423 if (CONSTANT_CLASS_P (old
))
1427 || operand_equal_p (expr
, old
, 0))
1428 return unshare_expr (new_tree
);
1433 n
= TREE_OPERAND_LENGTH (expr
);
1434 for (i
= 0; i
< n
; i
++)
1436 e
= TREE_OPERAND (expr
, i
);
1437 se
= simplify_replace_tree (e
, old
, new_tree
);
1442 ret
= copy_node (expr
);
1444 TREE_OPERAND (ret
, i
) = se
;
1447 return (ret
? fold (ret
) : expr
);
1450 /* Expand definitions of ssa names in EXPR as long as they are simple
1451 enough, and return the new expression. */
1454 expand_simple_operations (tree expr
)
1457 tree ret
= NULL_TREE
, e
, ee
, e1
;
1458 enum tree_code code
;
1461 if (expr
== NULL_TREE
)
1464 if (is_gimple_min_invariant (expr
))
1467 code
= TREE_CODE (expr
);
1468 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
1470 n
= TREE_OPERAND_LENGTH (expr
);
1471 for (i
= 0; i
< n
; i
++)
1473 e
= TREE_OPERAND (expr
, i
);
1474 ee
= expand_simple_operations (e
);
1479 ret
= copy_node (expr
);
1481 TREE_OPERAND (ret
, i
) = ee
;
1487 fold_defer_overflow_warnings ();
1489 fold_undefer_and_ignore_overflow_warnings ();
1493 if (TREE_CODE (expr
) != SSA_NAME
)
1496 stmt
= SSA_NAME_DEF_STMT (expr
);
1497 if (gimple_code (stmt
) == GIMPLE_PHI
)
1499 basic_block src
, dest
;
1501 if (gimple_phi_num_args (stmt
) != 1)
1503 e
= PHI_ARG_DEF (stmt
, 0);
1505 /* Avoid propagating through loop exit phi nodes, which
1506 could break loop-closed SSA form restrictions. */
1507 dest
= gimple_bb (stmt
);
1508 src
= single_pred (dest
);
1509 if (TREE_CODE (e
) == SSA_NAME
1510 && src
->loop_father
!= dest
->loop_father
)
1513 return expand_simple_operations (e
);
1515 if (gimple_code (stmt
) != GIMPLE_ASSIGN
)
1518 /* Avoid expanding to expressions that contain SSA names that need
1519 to take part in abnormal coalescing. */
1521 FOR_EACH_SSA_TREE_OPERAND (e
, stmt
, iter
, SSA_OP_USE
)
1522 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (e
))
1525 e
= gimple_assign_rhs1 (stmt
);
1526 code
= gimple_assign_rhs_code (stmt
);
1527 if (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
)
1529 if (is_gimple_min_invariant (e
))
1532 if (code
== SSA_NAME
)
1533 return expand_simple_operations (e
);
1541 /* Casts are simple. */
1542 ee
= expand_simple_operations (e
);
1543 return fold_build1 (code
, TREE_TYPE (expr
), ee
);
1547 case POINTER_PLUS_EXPR
:
1548 /* And increments and decrements by a constant are simple. */
1549 e1
= gimple_assign_rhs2 (stmt
);
1550 if (!is_gimple_min_invariant (e1
))
1553 ee
= expand_simple_operations (e
);
1554 return fold_build2 (code
, TREE_TYPE (expr
), ee
, e1
);
1561 /* Tries to simplify EXPR using the condition COND. Returns the simplified
1562 expression (or EXPR unchanged, if no simplification was possible). */
1565 tree_simplify_using_condition_1 (tree cond
, tree expr
)
1568 tree e
, te
, e0
, e1
, e2
, notcond
;
1569 enum tree_code code
= TREE_CODE (expr
);
1571 if (code
== INTEGER_CST
)
1574 if (code
== TRUTH_OR_EXPR
1575 || code
== TRUTH_AND_EXPR
1576 || code
== COND_EXPR
)
1580 e0
= tree_simplify_using_condition_1 (cond
, TREE_OPERAND (expr
, 0));
1581 if (TREE_OPERAND (expr
, 0) != e0
)
1584 e1
= tree_simplify_using_condition_1 (cond
, TREE_OPERAND (expr
, 1));
1585 if (TREE_OPERAND (expr
, 1) != e1
)
1588 if (code
== COND_EXPR
)
1590 e2
= tree_simplify_using_condition_1 (cond
, TREE_OPERAND (expr
, 2));
1591 if (TREE_OPERAND (expr
, 2) != e2
)
1599 if (code
== COND_EXPR
)
1600 expr
= fold_build3 (code
, boolean_type_node
, e0
, e1
, e2
);
1602 expr
= fold_build2 (code
, boolean_type_node
, e0
, e1
);
1608 /* In case COND is equality, we may be able to simplify EXPR by copy/constant
1609 propagation, and vice versa. Fold does not handle this, since it is
1610 considered too expensive. */
1611 if (TREE_CODE (cond
) == EQ_EXPR
)
1613 e0
= TREE_OPERAND (cond
, 0);
1614 e1
= TREE_OPERAND (cond
, 1);
1616 /* We know that e0 == e1. Check whether we cannot simplify expr
1618 e
= simplify_replace_tree (expr
, e0
, e1
);
1619 if (integer_zerop (e
) || integer_nonzerop (e
))
1622 e
= simplify_replace_tree (expr
, e1
, e0
);
1623 if (integer_zerop (e
) || integer_nonzerop (e
))
1626 if (TREE_CODE (expr
) == EQ_EXPR
)
1628 e0
= TREE_OPERAND (expr
, 0);
1629 e1
= TREE_OPERAND (expr
, 1);
1631 /* If e0 == e1 (EXPR) implies !COND, then EXPR cannot be true. */
1632 e
= simplify_replace_tree (cond
, e0
, e1
);
1633 if (integer_zerop (e
))
1635 e
= simplify_replace_tree (cond
, e1
, e0
);
1636 if (integer_zerop (e
))
1639 if (TREE_CODE (expr
) == NE_EXPR
)
1641 e0
= TREE_OPERAND (expr
, 0);
1642 e1
= TREE_OPERAND (expr
, 1);
1644 /* If e0 == e1 (!EXPR) implies !COND, then EXPR must be true. */
1645 e
= simplify_replace_tree (cond
, e0
, e1
);
1646 if (integer_zerop (e
))
1647 return boolean_true_node
;
1648 e
= simplify_replace_tree (cond
, e1
, e0
);
1649 if (integer_zerop (e
))
1650 return boolean_true_node
;
1653 te
= expand_simple_operations (expr
);
1655 /* Check whether COND ==> EXPR. */
1656 notcond
= invert_truthvalue (cond
);
1657 e
= fold_binary (TRUTH_OR_EXPR
, boolean_type_node
, notcond
, te
);
1658 if (e
&& integer_nonzerop (e
))
1661 /* Check whether COND ==> not EXPR. */
1662 e
= fold_binary (TRUTH_AND_EXPR
, boolean_type_node
, cond
, te
);
1663 if (e
&& integer_zerop (e
))
1669 /* Tries to simplify EXPR using the condition COND. Returns the simplified
1670 expression (or EXPR unchanged, if no simplification was possible).
1671 Wrapper around tree_simplify_using_condition_1 that ensures that chains
1672 of simple operations in definitions of ssa names in COND are expanded,
1673 so that things like casts or incrementing the value of the bound before
1674 the loop do not cause us to fail. */
1677 tree_simplify_using_condition (tree cond
, tree expr
)
1679 cond
= expand_simple_operations (cond
);
1681 return tree_simplify_using_condition_1 (cond
, expr
);
1684 /* Tries to simplify EXPR using the conditions on entry to LOOP.
1685 Returns the simplified expression (or EXPR unchanged, if no
1686 simplification was possible).*/
1689 simplify_using_initial_conditions (struct loop
*loop
, tree expr
)
1697 if (TREE_CODE (expr
) == INTEGER_CST
)
1700 /* Limit walking the dominators to avoid quadraticness in
1701 the number of BBs times the number of loops in degenerate
1703 for (bb
= loop
->header
;
1704 bb
!= ENTRY_BLOCK_PTR
&& cnt
< MAX_DOMINATORS_TO_WALK
;
1705 bb
= get_immediate_dominator (CDI_DOMINATORS
, bb
))
1707 if (!single_pred_p (bb
))
1709 e
= single_pred_edge (bb
);
1711 if (!(e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
1714 stmt
= last_stmt (e
->src
);
1715 cond
= fold_build2 (gimple_cond_code (stmt
),
1717 gimple_cond_lhs (stmt
),
1718 gimple_cond_rhs (stmt
));
1719 if (e
->flags
& EDGE_FALSE_VALUE
)
1720 cond
= invert_truthvalue (cond
);
1721 expr
= tree_simplify_using_condition (cond
, expr
);
1728 /* Tries to simplify EXPR using the evolutions of the loop invariants
1729 in the superloops of LOOP. Returns the simplified expression
1730 (or EXPR unchanged, if no simplification was possible). */
1733 simplify_using_outer_evolutions (struct loop
*loop
, tree expr
)
1735 enum tree_code code
= TREE_CODE (expr
);
1739 if (is_gimple_min_invariant (expr
))
1742 if (code
== TRUTH_OR_EXPR
1743 || code
== TRUTH_AND_EXPR
1744 || code
== COND_EXPR
)
1748 e0
= simplify_using_outer_evolutions (loop
, TREE_OPERAND (expr
, 0));
1749 if (TREE_OPERAND (expr
, 0) != e0
)
1752 e1
= simplify_using_outer_evolutions (loop
, TREE_OPERAND (expr
, 1));
1753 if (TREE_OPERAND (expr
, 1) != e1
)
1756 if (code
== COND_EXPR
)
1758 e2
= simplify_using_outer_evolutions (loop
, TREE_OPERAND (expr
, 2));
1759 if (TREE_OPERAND (expr
, 2) != e2
)
1767 if (code
== COND_EXPR
)
1768 expr
= fold_build3 (code
, boolean_type_node
, e0
, e1
, e2
);
1770 expr
= fold_build2 (code
, boolean_type_node
, e0
, e1
);
1776 e
= instantiate_parameters (loop
, expr
);
1777 if (is_gimple_min_invariant (e
))
1783 /* Returns true if EXIT is the only possible exit from LOOP. */
1786 loop_only_exit_p (const struct loop
*loop
, const_edge exit
)
1789 gimple_stmt_iterator bsi
;
1793 if (exit
!= single_exit (loop
))
1796 body
= get_loop_body (loop
);
1797 for (i
= 0; i
< loop
->num_nodes
; i
++)
1799 for (bsi
= gsi_start_bb (body
[i
]); !gsi_end_p (bsi
); gsi_next (&bsi
))
1801 call
= gsi_stmt (bsi
);
1802 if (gimple_code (call
) != GIMPLE_CALL
)
1805 if (gimple_has_side_effects (call
))
1817 /* Stores description of number of iterations of LOOP derived from
1818 EXIT (an exit edge of the LOOP) in NITER. Returns true if some
1819 useful information could be derived (and fields of NITER has
1820 meaning described in comments at struct tree_niter_desc
1821 declaration), false otherwise. If WARN is true and
1822 -Wunsafe-loop-optimizations was given, warn if the optimizer is going to use
1823 potentially unsafe assumptions.
1824 When EVERY_ITERATION is true, only tests that are known to be executed
1825 every iteration are considered (i.e. only test that alone bounds the loop).
1829 number_of_iterations_exit (struct loop
*loop
, edge exit
,
1830 struct tree_niter_desc
*niter
,
1831 bool warn
, bool every_iteration
)
1836 enum tree_code code
;
1840 safe
= dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
);
1842 if (every_iteration
&& !safe
)
1845 niter
->assumptions
= boolean_false_node
;
1846 stmt
= last_stmt (exit
->src
);
1847 if (!stmt
|| gimple_code (stmt
) != GIMPLE_COND
)
1850 /* We want the condition for staying inside loop. */
1851 code
= gimple_cond_code (stmt
);
1852 if (exit
->flags
& EDGE_TRUE_VALUE
)
1853 code
= invert_tree_comparison (code
, false);
1868 op0
= gimple_cond_lhs (stmt
);
1869 op1
= gimple_cond_rhs (stmt
);
1870 type
= TREE_TYPE (op0
);
1872 if (TREE_CODE (type
) != INTEGER_TYPE
1873 && !POINTER_TYPE_P (type
))
1876 if (!simple_iv (loop
, loop_containing_stmt (stmt
), op0
, &iv0
, false))
1878 if (!simple_iv (loop
, loop_containing_stmt (stmt
), op1
, &iv1
, false))
1881 /* We don't want to see undefined signed overflow warnings while
1882 computing the number of iterations. */
1883 fold_defer_overflow_warnings ();
1885 iv0
.base
= expand_simple_operations (iv0
.base
);
1886 iv1
.base
= expand_simple_operations (iv1
.base
);
1887 if (!number_of_iterations_cond (loop
, type
, &iv0
, code
, &iv1
, niter
,
1888 loop_only_exit_p (loop
, exit
), safe
))
1890 fold_undefer_and_ignore_overflow_warnings ();
1896 niter
->assumptions
= simplify_using_outer_evolutions (loop
,
1897 niter
->assumptions
);
1898 niter
->may_be_zero
= simplify_using_outer_evolutions (loop
,
1899 niter
->may_be_zero
);
1900 niter
->niter
= simplify_using_outer_evolutions (loop
, niter
->niter
);
1904 = simplify_using_initial_conditions (loop
,
1905 niter
->assumptions
);
1907 = simplify_using_initial_conditions (loop
,
1908 niter
->may_be_zero
);
1910 fold_undefer_and_ignore_overflow_warnings ();
1912 /* If NITER has simplified into a constant, update MAX. */
1913 if (TREE_CODE (niter
->niter
) == INTEGER_CST
)
1914 niter
->max
= tree_to_double_int (niter
->niter
);
1916 if (integer_onep (niter
->assumptions
))
1919 /* With -funsafe-loop-optimizations we assume that nothing bad can happen.
1920 But if we can prove that there is overflow or some other source of weird
1921 behavior, ignore the loop even with -funsafe-loop-optimizations. */
1922 if (integer_zerop (niter
->assumptions
) || !single_exit (loop
))
1925 if (flag_unsafe_loop_optimizations
)
1926 niter
->assumptions
= boolean_true_node
;
1930 const char *wording
;
1931 location_t loc
= gimple_location (stmt
);
1933 /* We can provide a more specific warning if one of the operator is
1934 constant and the other advances by +1 or -1. */
1935 if (!integer_zerop (iv1
.step
)
1936 ? (integer_zerop (iv0
.step
)
1937 && (integer_onep (iv1
.step
) || integer_all_onesp (iv1
.step
)))
1938 : (integer_onep (iv0
.step
) || integer_all_onesp (iv0
.step
)))
1940 flag_unsafe_loop_optimizations
1941 ? N_("assuming that the loop is not infinite")
1942 : N_("cannot optimize possibly infinite loops");
1945 flag_unsafe_loop_optimizations
1946 ? N_("assuming that the loop counter does not overflow")
1947 : N_("cannot optimize loop, the loop counter may overflow");
1949 warning_at ((LOCATION_LINE (loc
) > 0) ? loc
: input_location
,
1950 OPT_Wunsafe_loop_optimizations
, "%s", gettext (wording
));
1953 return flag_unsafe_loop_optimizations
;
1956 /* Try to determine the number of iterations of LOOP. If we succeed,
1957 expression giving number of iterations is returned and *EXIT is
1958 set to the edge from that the information is obtained. Otherwise
1959 chrec_dont_know is returned. */
1962 find_loop_niter (struct loop
*loop
, edge
*exit
)
1965 vec
<edge
> exits
= get_loop_exit_edges (loop
);
1967 tree niter
= NULL_TREE
, aniter
;
1968 struct tree_niter_desc desc
;
1971 FOR_EACH_VEC_ELT (exits
, i
, ex
)
1973 if (!number_of_iterations_exit (loop
, ex
, &desc
, false))
1976 if (integer_nonzerop (desc
.may_be_zero
))
1978 /* We exit in the first iteration through this exit.
1979 We won't find anything better. */
1980 niter
= build_int_cst (unsigned_type_node
, 0);
1985 if (!integer_zerop (desc
.may_be_zero
))
1988 aniter
= desc
.niter
;
1992 /* Nothing recorded yet. */
1998 /* Prefer constants, the lower the better. */
1999 if (TREE_CODE (aniter
) != INTEGER_CST
)
2002 if (TREE_CODE (niter
) != INTEGER_CST
)
2009 if (tree_int_cst_lt (aniter
, niter
))
2018 return niter
? niter
: chrec_dont_know
;
2021 /* Return true if loop is known to have bounded number of iterations. */
2024 finite_loop_p (struct loop
*loop
)
2029 if (flag_unsafe_loop_optimizations
)
2031 flags
= flags_from_decl_or_type (current_function_decl
);
2032 if ((flags
& (ECF_CONST
|ECF_PURE
)) && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
2034 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2035 fprintf (dump_file
, "Found loop %i to be finite: it is within pure or const function.\n",
2040 if (loop
->any_upper_bound
2041 || max_loop_iterations (loop
, &nit
))
2043 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2044 fprintf (dump_file
, "Found loop %i to be finite: upper bound found.\n",
2053 Analysis of a number of iterations of a loop by a brute-force evaluation.
2057 /* Bound on the number of iterations we try to evaluate. */
2059 #define MAX_ITERATIONS_TO_TRACK \
2060 ((unsigned) PARAM_VALUE (PARAM_MAX_ITERATIONS_TO_TRACK))
2062 /* Returns the loop phi node of LOOP such that ssa name X is derived from its
2063 result by a chain of operations such that all but exactly one of their
2064 operands are constants. */
2067 chain_of_csts_start (struct loop
*loop
, tree x
)
2069 gimple stmt
= SSA_NAME_DEF_STMT (x
);
2071 basic_block bb
= gimple_bb (stmt
);
2072 enum tree_code code
;
2075 || !flow_bb_inside_loop_p (loop
, bb
))
2078 if (gimple_code (stmt
) == GIMPLE_PHI
)
2080 if (bb
== loop
->header
)
2086 if (gimple_code (stmt
) != GIMPLE_ASSIGN
)
2089 code
= gimple_assign_rhs_code (stmt
);
2090 if (gimple_references_memory_p (stmt
)
2091 || TREE_CODE_CLASS (code
) == tcc_reference
2092 || (code
== ADDR_EXPR
2093 && !is_gimple_min_invariant (gimple_assign_rhs1 (stmt
))))
2096 use
= SINGLE_SSA_TREE_OPERAND (stmt
, SSA_OP_USE
);
2097 if (use
== NULL_TREE
)
2100 return chain_of_csts_start (loop
, use
);
2103 /* Determines whether the expression X is derived from a result of a phi node
2104 in header of LOOP such that
2106 * the derivation of X consists only from operations with constants
2107 * the initial value of the phi node is constant
2108 * the value of the phi node in the next iteration can be derived from the
2109 value in the current iteration by a chain of operations with constants.
2111 If such phi node exists, it is returned, otherwise NULL is returned. */
2114 get_base_for (struct loop
*loop
, tree x
)
2119 if (is_gimple_min_invariant (x
))
2122 phi
= chain_of_csts_start (loop
, x
);
2126 init
= PHI_ARG_DEF_FROM_EDGE (phi
, loop_preheader_edge (loop
));
2127 next
= PHI_ARG_DEF_FROM_EDGE (phi
, loop_latch_edge (loop
));
2129 if (TREE_CODE (next
) != SSA_NAME
)
2132 if (!is_gimple_min_invariant (init
))
2135 if (chain_of_csts_start (loop
, next
) != phi
)
2141 /* Given an expression X, then
2143 * if X is NULL_TREE, we return the constant BASE.
2144 * otherwise X is a SSA name, whose value in the considered loop is derived
2145 by a chain of operations with constant from a result of a phi node in
2146 the header of the loop. Then we return value of X when the value of the
2147 result of this phi node is given by the constant BASE. */
2150 get_val_for (tree x
, tree base
)
2154 gcc_assert (is_gimple_min_invariant (base
));
2159 stmt
= SSA_NAME_DEF_STMT (x
);
2160 if (gimple_code (stmt
) == GIMPLE_PHI
)
2163 gcc_assert (is_gimple_assign (stmt
));
2165 /* STMT must be either an assignment of a single SSA name or an
2166 expression involving an SSA name and a constant. Try to fold that
2167 expression using the value for the SSA name. */
2168 if (gimple_assign_ssa_name_copy_p (stmt
))
2169 return get_val_for (gimple_assign_rhs1 (stmt
), base
);
2170 else if (gimple_assign_rhs_class (stmt
) == GIMPLE_UNARY_RHS
2171 && TREE_CODE (gimple_assign_rhs1 (stmt
)) == SSA_NAME
)
2173 return fold_build1 (gimple_assign_rhs_code (stmt
),
2174 gimple_expr_type (stmt
),
2175 get_val_for (gimple_assign_rhs1 (stmt
), base
));
2177 else if (gimple_assign_rhs_class (stmt
) == GIMPLE_BINARY_RHS
)
2179 tree rhs1
= gimple_assign_rhs1 (stmt
);
2180 tree rhs2
= gimple_assign_rhs2 (stmt
);
2181 if (TREE_CODE (rhs1
) == SSA_NAME
)
2182 rhs1
= get_val_for (rhs1
, base
);
2183 else if (TREE_CODE (rhs2
) == SSA_NAME
)
2184 rhs2
= get_val_for (rhs2
, base
);
2187 return fold_build2 (gimple_assign_rhs_code (stmt
),
2188 gimple_expr_type (stmt
), rhs1
, rhs2
);
2195 /* Tries to count the number of iterations of LOOP till it exits by EXIT
2196 by brute force -- i.e. by determining the value of the operands of the
2197 condition at EXIT in first few iterations of the loop (assuming that
2198 these values are constant) and determining the first one in that the
2199 condition is not satisfied. Returns the constant giving the number
2200 of the iterations of LOOP if successful, chrec_dont_know otherwise. */
2203 loop_niter_by_eval (struct loop
*loop
, edge exit
)
2206 tree op
[2], val
[2], next
[2], aval
[2];
2211 cond
= last_stmt (exit
->src
);
2212 if (!cond
|| gimple_code (cond
) != GIMPLE_COND
)
2213 return chrec_dont_know
;
2215 cmp
= gimple_cond_code (cond
);
2216 if (exit
->flags
& EDGE_TRUE_VALUE
)
2217 cmp
= invert_tree_comparison (cmp
, false);
2227 op
[0] = gimple_cond_lhs (cond
);
2228 op
[1] = gimple_cond_rhs (cond
);
2232 return chrec_dont_know
;
2235 for (j
= 0; j
< 2; j
++)
2237 if (is_gimple_min_invariant (op
[j
]))
2240 next
[j
] = NULL_TREE
;
2245 phi
= get_base_for (loop
, op
[j
]);
2247 return chrec_dont_know
;
2248 val
[j
] = PHI_ARG_DEF_FROM_EDGE (phi
, loop_preheader_edge (loop
));
2249 next
[j
] = PHI_ARG_DEF_FROM_EDGE (phi
, loop_latch_edge (loop
));
2253 /* Don't issue signed overflow warnings. */
2254 fold_defer_overflow_warnings ();
2256 for (i
= 0; i
< MAX_ITERATIONS_TO_TRACK
; i
++)
2258 for (j
= 0; j
< 2; j
++)
2259 aval
[j
] = get_val_for (op
[j
], val
[j
]);
2261 acnd
= fold_binary (cmp
, boolean_type_node
, aval
[0], aval
[1]);
2262 if (acnd
&& integer_zerop (acnd
))
2264 fold_undefer_and_ignore_overflow_warnings ();
2265 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2267 "Proved that loop %d iterates %d times using brute force.\n",
2269 return build_int_cst (unsigned_type_node
, i
);
2272 for (j
= 0; j
< 2; j
++)
2274 val
[j
] = get_val_for (next
[j
], val
[j
]);
2275 if (!is_gimple_min_invariant (val
[j
]))
2277 fold_undefer_and_ignore_overflow_warnings ();
2278 return chrec_dont_know
;
2283 fold_undefer_and_ignore_overflow_warnings ();
2285 return chrec_dont_know
;
2288 /* Finds the exit of the LOOP by that the loop exits after a constant
2289 number of iterations and stores the exit edge to *EXIT. The constant
2290 giving the number of iterations of LOOP is returned. The number of
2291 iterations is determined using loop_niter_by_eval (i.e. by brute force
2292 evaluation). If we are unable to find the exit for that loop_niter_by_eval
2293 determines the number of iterations, chrec_dont_know is returned. */
2296 find_loop_niter_by_eval (struct loop
*loop
, edge
*exit
)
2299 vec
<edge
> exits
= get_loop_exit_edges (loop
);
2301 tree niter
= NULL_TREE
, aniter
;
2305 /* Loops with multiple exits are expensive to handle and less important. */
2306 if (!flag_expensive_optimizations
2307 && exits
.length () > 1)
2310 return chrec_dont_know
;
2313 FOR_EACH_VEC_ELT (exits
, i
, ex
)
2315 if (!just_once_each_iteration_p (loop
, ex
->src
))
2318 aniter
= loop_niter_by_eval (loop
, ex
);
2319 if (chrec_contains_undetermined (aniter
))
2323 && !tree_int_cst_lt (aniter
, niter
))
2331 return niter
? niter
: chrec_dont_know
;
2336 Analysis of upper bounds on number of iterations of a loop.
2340 static double_int
derive_constant_upper_bound_ops (tree
, tree
,
2341 enum tree_code
, tree
);
2343 /* Returns a constant upper bound on the value of the right-hand side of
2344 an assignment statement STMT. */
2347 derive_constant_upper_bound_assign (gimple stmt
)
2349 enum tree_code code
= gimple_assign_rhs_code (stmt
);
2350 tree op0
= gimple_assign_rhs1 (stmt
);
2351 tree op1
= gimple_assign_rhs2 (stmt
);
2353 return derive_constant_upper_bound_ops (TREE_TYPE (gimple_assign_lhs (stmt
)),
2357 /* Returns a constant upper bound on the value of expression VAL. VAL
2358 is considered to be unsigned. If its type is signed, its value must
2362 derive_constant_upper_bound (tree val
)
2364 enum tree_code code
;
2367 extract_ops_from_tree (val
, &code
, &op0
, &op1
);
2368 return derive_constant_upper_bound_ops (TREE_TYPE (val
), op0
, code
, op1
);
2371 /* Returns a constant upper bound on the value of expression OP0 CODE OP1,
2372 whose type is TYPE. The expression is considered to be unsigned. If
2373 its type is signed, its value must be nonnegative. */
2376 derive_constant_upper_bound_ops (tree type
, tree op0
,
2377 enum tree_code code
, tree op1
)
2380 double_int bnd
, max
, mmax
, cst
;
2383 if (INTEGRAL_TYPE_P (type
))
2384 maxt
= TYPE_MAX_VALUE (type
);
2386 maxt
= upper_bound_in_type (type
, type
);
2388 max
= tree_to_double_int (maxt
);
2393 return tree_to_double_int (op0
);
2396 subtype
= TREE_TYPE (op0
);
2397 if (!TYPE_UNSIGNED (subtype
)
2398 /* If TYPE is also signed, the fact that VAL is nonnegative implies
2399 that OP0 is nonnegative. */
2400 && TYPE_UNSIGNED (type
)
2401 && !tree_expr_nonnegative_p (op0
))
2403 /* If we cannot prove that the casted expression is nonnegative,
2404 we cannot establish more useful upper bound than the precision
2405 of the type gives us. */
2409 /* We now know that op0 is an nonnegative value. Try deriving an upper
2411 bnd
= derive_constant_upper_bound (op0
);
2413 /* If the bound does not fit in TYPE, max. value of TYPE could be
2421 case POINTER_PLUS_EXPR
:
2423 if (TREE_CODE (op1
) != INTEGER_CST
2424 || !tree_expr_nonnegative_p (op0
))
2427 /* Canonicalize to OP0 - CST. Consider CST to be signed, in order to
2428 choose the most logical way how to treat this constant regardless
2429 of the signedness of the type. */
2430 cst
= tree_to_double_int (op1
);
2431 cst
= cst
.sext (TYPE_PRECISION (type
));
2432 if (code
!= MINUS_EXPR
)
2435 bnd
= derive_constant_upper_bound (op0
);
2437 if (cst
.is_negative ())
2440 /* Avoid CST == 0x80000... */
2441 if (cst
.is_negative ())
2444 /* OP0 + CST. We need to check that
2445 BND <= MAX (type) - CST. */
2455 /* OP0 - CST, where CST >= 0.
2457 If TYPE is signed, we have already verified that OP0 >= 0, and we
2458 know that the result is nonnegative. This implies that
2461 If TYPE is unsigned, we must additionally know that OP0 >= CST,
2462 otherwise the operation underflows.
2465 /* This should only happen if the type is unsigned; however, for
2466 buggy programs that use overflowing signed arithmetics even with
2467 -fno-wrapv, this condition may also be true for signed values. */
2471 if (TYPE_UNSIGNED (type
))
2473 tree tem
= fold_binary (GE_EXPR
, boolean_type_node
, op0
,
2474 double_int_to_tree (type
, cst
));
2475 if (!tem
|| integer_nonzerop (tem
))
2484 case FLOOR_DIV_EXPR
:
2485 case EXACT_DIV_EXPR
:
2486 if (TREE_CODE (op1
) != INTEGER_CST
2487 || tree_int_cst_sign_bit (op1
))
2490 bnd
= derive_constant_upper_bound (op0
);
2491 return bnd
.udiv (tree_to_double_int (op1
), FLOOR_DIV_EXPR
);
2494 if (TREE_CODE (op1
) != INTEGER_CST
2495 || tree_int_cst_sign_bit (op1
))
2497 return tree_to_double_int (op1
);
2500 stmt
= SSA_NAME_DEF_STMT (op0
);
2501 if (gimple_code (stmt
) != GIMPLE_ASSIGN
2502 || gimple_assign_lhs (stmt
) != op0
)
2504 return derive_constant_upper_bound_assign (stmt
);
2511 /* Emit a -Waggressive-loop-optimizations warning if needed. */
2514 do_warn_aggressive_loop_optimizations (struct loop
*loop
,
2515 double_int i_bound
, gimple stmt
)
2517 /* Don't warn if the loop doesn't have known constant bound. */
2518 if (!loop
->nb_iterations
2519 || TREE_CODE (loop
->nb_iterations
) != INTEGER_CST
2520 || !warn_aggressive_loop_optimizations
2521 /* To avoid warning multiple times for the same loop,
2522 only start warning when we preserve loops. */
2523 || (cfun
->curr_properties
& PROP_loops
) == 0
2524 /* Only warn once per loop. */
2525 || loop
->warned_aggressive_loop_optimizations
2526 /* Only warn if undefined behavior gives us lower estimate than the
2527 known constant bound. */
2528 || i_bound
.ucmp (tree_to_double_int (loop
->nb_iterations
)) >= 0
2529 /* And undefined behavior happens unconditionally. */
2530 || !dominated_by_p (CDI_DOMINATORS
, loop
->latch
, gimple_bb (stmt
)))
2533 edge e
= single_exit (loop
);
2537 gimple estmt
= last_stmt (e
->src
);
2538 if (warning_at (gimple_location (stmt
), OPT_Waggressive_loop_optimizations
,
2539 "iteration %E invokes undefined behavior",
2540 double_int_to_tree (TREE_TYPE (loop
->nb_iterations
),
2542 inform (gimple_location (estmt
), "containing loop");
2543 loop
->warned_aggressive_loop_optimizations
= true;
2546 /* Records that AT_STMT is executed at most BOUND + 1 times in LOOP. IS_EXIT
2547 is true if the loop is exited immediately after STMT, and this exit
2548 is taken at last when the STMT is executed BOUND + 1 times.
2549 REALISTIC is true if BOUND is expected to be close to the real number
2550 of iterations. UPPER is true if we are sure the loop iterates at most
2551 BOUND times. I_BOUND is an unsigned double_int upper estimate on BOUND. */
2554 record_estimate (struct loop
*loop
, tree bound
, double_int i_bound
,
2555 gimple at_stmt
, bool is_exit
, bool realistic
, bool upper
)
2559 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2561 fprintf (dump_file
, "Statement %s", is_exit
? "(exit)" : "");
2562 print_gimple_stmt (dump_file
, at_stmt
, 0, TDF_SLIM
);
2563 fprintf (dump_file
, " is %sexecuted at most ",
2564 upper
? "" : "probably ");
2565 print_generic_expr (dump_file
, bound
, TDF_SLIM
);
2566 fprintf (dump_file
, " (bounded by ");
2567 dump_double_int (dump_file
, i_bound
, true);
2568 fprintf (dump_file
, ") + 1 times in loop %d.\n", loop
->num
);
2571 /* If the I_BOUND is just an estimate of BOUND, it rarely is close to the
2572 real number of iterations. */
2573 if (TREE_CODE (bound
) != INTEGER_CST
)
2576 gcc_checking_assert (i_bound
== tree_to_double_int (bound
));
2577 if (!upper
&& !realistic
)
2580 /* If we have a guaranteed upper bound, record it in the appropriate
2581 list, unless this is an !is_exit bound (i.e. undefined behavior in
2582 at_stmt) in a loop with known constant number of iterations. */
2585 || loop
->nb_iterations
== NULL_TREE
2586 || TREE_CODE (loop
->nb_iterations
) != INTEGER_CST
))
2588 struct nb_iter_bound
*elt
= ggc_alloc_nb_iter_bound ();
2590 elt
->bound
= i_bound
;
2591 elt
->stmt
= at_stmt
;
2592 elt
->is_exit
= is_exit
;
2593 elt
->next
= loop
->bounds
;
2597 /* If statement is executed on every path to the loop latch, we can directly
2598 infer the upper bound on the # of iterations of the loop. */
2599 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, gimple_bb (at_stmt
)))
2602 /* Update the number of iteration estimates according to the bound.
2603 If at_stmt is an exit then the loop latch is executed at most BOUND times,
2604 otherwise it can be executed BOUND + 1 times. We will lower the estimate
2605 later if such statement must be executed on last iteration */
2607 delta
= double_int_zero
;
2609 delta
= double_int_one
;
2612 /* If an overflow occurred, ignore the result. */
2613 if (i_bound
.ult (delta
))
2616 if (upper
&& !is_exit
)
2617 do_warn_aggressive_loop_optimizations (loop
, i_bound
, at_stmt
);
2618 record_niter_bound (loop
, i_bound
, realistic
, upper
);
2621 /* Record the estimate on number of iterations of LOOP based on the fact that
2622 the induction variable BASE + STEP * i evaluated in STMT does not wrap and
2623 its values belong to the range <LOW, HIGH>. REALISTIC is true if the
2624 estimated number of iterations is expected to be close to the real one.
2625 UPPER is true if we are sure the induction variable does not wrap. */
2628 record_nonwrapping_iv (struct loop
*loop
, tree base
, tree step
, gimple stmt
,
2629 tree low
, tree high
, bool realistic
, bool upper
)
2631 tree niter_bound
, extreme
, delta
;
2632 tree type
= TREE_TYPE (base
), unsigned_type
;
2635 if (TREE_CODE (step
) != INTEGER_CST
|| integer_zerop (step
))
2638 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2640 fprintf (dump_file
, "Induction variable (");
2641 print_generic_expr (dump_file
, TREE_TYPE (base
), TDF_SLIM
);
2642 fprintf (dump_file
, ") ");
2643 print_generic_expr (dump_file
, base
, TDF_SLIM
);
2644 fprintf (dump_file
, " + ");
2645 print_generic_expr (dump_file
, step
, TDF_SLIM
);
2646 fprintf (dump_file
, " * iteration does not wrap in statement ");
2647 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
2648 fprintf (dump_file
, " in loop %d.\n", loop
->num
);
2651 unsigned_type
= unsigned_type_for (type
);
2652 base
= fold_convert (unsigned_type
, base
);
2653 step
= fold_convert (unsigned_type
, step
);
2655 if (tree_int_cst_sign_bit (step
))
2657 extreme
= fold_convert (unsigned_type
, low
);
2658 if (TREE_CODE (base
) != INTEGER_CST
)
2659 base
= fold_convert (unsigned_type
, high
);
2660 delta
= fold_build2 (MINUS_EXPR
, unsigned_type
, base
, extreme
);
2661 step
= fold_build1 (NEGATE_EXPR
, unsigned_type
, step
);
2665 extreme
= fold_convert (unsigned_type
, high
);
2666 if (TREE_CODE (base
) != INTEGER_CST
)
2667 base
= fold_convert (unsigned_type
, low
);
2668 delta
= fold_build2 (MINUS_EXPR
, unsigned_type
, extreme
, base
);
2671 /* STMT is executed at most NITER_BOUND + 1 times, since otherwise the value
2672 would get out of the range. */
2673 niter_bound
= fold_build2 (FLOOR_DIV_EXPR
, unsigned_type
, delta
, step
);
2674 max
= derive_constant_upper_bound (niter_bound
);
2675 record_estimate (loop
, niter_bound
, max
, stmt
, false, realistic
, upper
);
2678 /* Determine information about number of iterations a LOOP from the index
2679 IDX of a data reference accessed in STMT. RELIABLE is true if STMT is
2680 guaranteed to be executed in every iteration of LOOP. Callback for
2690 idx_infer_loop_bounds (tree base
, tree
*idx
, void *dta
)
2692 struct ilb_data
*data
= (struct ilb_data
*) dta
;
2693 tree ev
, init
, step
;
2694 tree low
, high
, type
, next
;
2695 bool sign
, upper
= true, at_end
= false;
2696 struct loop
*loop
= data
->loop
;
2697 bool reliable
= true;
2699 if (TREE_CODE (base
) != ARRAY_REF
)
2702 /* For arrays at the end of the structure, we are not guaranteed that they
2703 do not really extend over their declared size. However, for arrays of
2704 size greater than one, this is unlikely to be intended. */
2705 if (array_at_struct_end_p (base
))
2711 struct loop
*dloop
= loop_containing_stmt (data
->stmt
);
2715 ev
= analyze_scalar_evolution (dloop
, *idx
);
2716 ev
= instantiate_parameters (loop
, ev
);
2717 init
= initial_condition (ev
);
2718 step
= evolution_part_in_loop_num (ev
, loop
->num
);
2722 || TREE_CODE (step
) != INTEGER_CST
2723 || integer_zerop (step
)
2724 || tree_contains_chrecs (init
, NULL
)
2725 || chrec_contains_symbols_defined_in_loop (init
, loop
->num
))
2728 low
= array_ref_low_bound (base
);
2729 high
= array_ref_up_bound (base
);
2731 /* The case of nonconstant bounds could be handled, but it would be
2733 if (TREE_CODE (low
) != INTEGER_CST
2735 || TREE_CODE (high
) != INTEGER_CST
)
2737 sign
= tree_int_cst_sign_bit (step
);
2738 type
= TREE_TYPE (step
);
2740 /* The array of length 1 at the end of a structure most likely extends
2741 beyond its bounds. */
2743 && operand_equal_p (low
, high
, 0))
2746 /* In case the relevant bound of the array does not fit in type, or
2747 it does, but bound + step (in type) still belongs into the range of the
2748 array, the index may wrap and still stay within the range of the array
2749 (consider e.g. if the array is indexed by the full range of
2752 To make things simpler, we require both bounds to fit into type, although
2753 there are cases where this would not be strictly necessary. */
2754 if (!int_fits_type_p (high
, type
)
2755 || !int_fits_type_p (low
, type
))
2757 low
= fold_convert (type
, low
);
2758 high
= fold_convert (type
, high
);
2761 next
= fold_binary (PLUS_EXPR
, type
, low
, step
);
2763 next
= fold_binary (PLUS_EXPR
, type
, high
, step
);
2765 if (tree_int_cst_compare (low
, next
) <= 0
2766 && tree_int_cst_compare (next
, high
) <= 0)
2769 /* If access is not executed on every iteration, we must ensure that overlow may
2770 not make the access valid later. */
2771 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, gimple_bb (data
->stmt
))
2772 && scev_probably_wraps_p (initial_condition_in_loop_num (ev
, loop
->num
),
2773 step
, data
->stmt
, loop
, true))
2776 record_nonwrapping_iv (loop
, init
, step
, data
->stmt
, low
, high
, reliable
, upper
);
2780 /* Determine information about number of iterations a LOOP from the bounds
2781 of arrays in the data reference REF accessed in STMT. RELIABLE is true if
2782 STMT is guaranteed to be executed in every iteration of LOOP.*/
2785 infer_loop_bounds_from_ref (struct loop
*loop
, gimple stmt
, tree ref
)
2787 struct ilb_data data
;
2791 for_each_index (&ref
, idx_infer_loop_bounds
, &data
);
2794 /* Determine information about number of iterations of a LOOP from the way
2795 arrays are used in STMT. RELIABLE is true if STMT is guaranteed to be
2796 executed in every iteration of LOOP. */
2799 infer_loop_bounds_from_array (struct loop
*loop
, gimple stmt
)
2801 if (is_gimple_assign (stmt
))
2803 tree op0
= gimple_assign_lhs (stmt
);
2804 tree op1
= gimple_assign_rhs1 (stmt
);
2806 /* For each memory access, analyze its access function
2807 and record a bound on the loop iteration domain. */
2808 if (REFERENCE_CLASS_P (op0
))
2809 infer_loop_bounds_from_ref (loop
, stmt
, op0
);
2811 if (REFERENCE_CLASS_P (op1
))
2812 infer_loop_bounds_from_ref (loop
, stmt
, op1
);
2814 else if (is_gimple_call (stmt
))
2817 unsigned i
, n
= gimple_call_num_args (stmt
);
2819 lhs
= gimple_call_lhs (stmt
);
2820 if (lhs
&& REFERENCE_CLASS_P (lhs
))
2821 infer_loop_bounds_from_ref (loop
, stmt
, lhs
);
2823 for (i
= 0; i
< n
; i
++)
2825 arg
= gimple_call_arg (stmt
, i
);
2826 if (REFERENCE_CLASS_P (arg
))
2827 infer_loop_bounds_from_ref (loop
, stmt
, arg
);
2832 /* Determine information about number of iterations of a LOOP from the fact
2833 that pointer arithmetics in STMT does not overflow. */
2836 infer_loop_bounds_from_pointer_arith (struct loop
*loop
, gimple stmt
)
2838 tree def
, base
, step
, scev
, type
, low
, high
;
2841 if (!is_gimple_assign (stmt
)
2842 || gimple_assign_rhs_code (stmt
) != POINTER_PLUS_EXPR
)
2845 def
= gimple_assign_lhs (stmt
);
2846 if (TREE_CODE (def
) != SSA_NAME
)
2849 type
= TREE_TYPE (def
);
2850 if (!nowrap_type_p (type
))
2853 ptr
= gimple_assign_rhs1 (stmt
);
2854 if (!expr_invariant_in_loop_p (loop
, ptr
))
2857 var
= gimple_assign_rhs2 (stmt
);
2858 if (TYPE_PRECISION (type
) != TYPE_PRECISION (TREE_TYPE (var
)))
2861 scev
= instantiate_parameters (loop
, analyze_scalar_evolution (loop
, def
));
2862 if (chrec_contains_undetermined (scev
))
2865 base
= initial_condition_in_loop_num (scev
, loop
->num
);
2866 step
= evolution_part_in_loop_num (scev
, loop
->num
);
2869 || TREE_CODE (step
) != INTEGER_CST
2870 || tree_contains_chrecs (base
, NULL
)
2871 || chrec_contains_symbols_defined_in_loop (base
, loop
->num
))
2874 low
= lower_bound_in_type (type
, type
);
2875 high
= upper_bound_in_type (type
, type
);
2877 /* In C, pointer arithmetic p + 1 cannot use a NULL pointer, and p - 1 cannot
2878 produce a NULL pointer. The contrary would mean NULL points to an object,
2879 while NULL is supposed to compare unequal with the address of all objects.
2880 Furthermore, p + 1 cannot produce a NULL pointer and p - 1 cannot use a
2881 NULL pointer since that would mean wrapping, which we assume here not to
2882 happen. So, we can exclude NULL from the valid range of pointer
2884 if (flag_delete_null_pointer_checks
&& int_cst_value (low
) == 0)
2885 low
= build_int_cstu (TREE_TYPE (low
), TYPE_ALIGN_UNIT (TREE_TYPE (type
)));
2887 record_nonwrapping_iv (loop
, base
, step
, stmt
, low
, high
, false, true);
2890 /* Determine information about number of iterations of a LOOP from the fact
2891 that signed arithmetics in STMT does not overflow. */
2894 infer_loop_bounds_from_signedness (struct loop
*loop
, gimple stmt
)
2896 tree def
, base
, step
, scev
, type
, low
, high
;
2898 if (gimple_code (stmt
) != GIMPLE_ASSIGN
)
2901 def
= gimple_assign_lhs (stmt
);
2903 if (TREE_CODE (def
) != SSA_NAME
)
2906 type
= TREE_TYPE (def
);
2907 if (!INTEGRAL_TYPE_P (type
)
2908 || !TYPE_OVERFLOW_UNDEFINED (type
))
2911 scev
= instantiate_parameters (loop
, analyze_scalar_evolution (loop
, def
));
2912 if (chrec_contains_undetermined (scev
))
2915 base
= initial_condition_in_loop_num (scev
, loop
->num
);
2916 step
= evolution_part_in_loop_num (scev
, loop
->num
);
2919 || TREE_CODE (step
) != INTEGER_CST
2920 || tree_contains_chrecs (base
, NULL
)
2921 || chrec_contains_symbols_defined_in_loop (base
, loop
->num
))
2924 low
= lower_bound_in_type (type
, type
);
2925 high
= upper_bound_in_type (type
, type
);
2927 record_nonwrapping_iv (loop
, base
, step
, stmt
, low
, high
, false, true);
2930 /* The following analyzers are extracting informations on the bounds
2931 of LOOP from the following undefined behaviors:
2933 - data references should not access elements over the statically
2936 - signed variables should not overflow when flag_wrapv is not set.
2940 infer_loop_bounds_from_undefined (struct loop
*loop
)
2944 gimple_stmt_iterator bsi
;
2948 bbs
= get_loop_body (loop
);
2950 for (i
= 0; i
< loop
->num_nodes
; i
++)
2954 /* If BB is not executed in each iteration of the loop, we cannot
2955 use the operations in it to infer reliable upper bound on the
2956 # of iterations of the loop. However, we can use it as a guess.
2957 Reliable guesses come only from array bounds. */
2958 reliable
= dominated_by_p (CDI_DOMINATORS
, loop
->latch
, bb
);
2960 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
2962 gimple stmt
= gsi_stmt (bsi
);
2964 infer_loop_bounds_from_array (loop
, stmt
);
2968 infer_loop_bounds_from_signedness (loop
, stmt
);
2969 infer_loop_bounds_from_pointer_arith (loop
, stmt
);
2980 /* Compare double ints, callback for qsort. */
2983 double_int_cmp (const void *p1
, const void *p2
)
2985 const double_int
*d1
= (const double_int
*)p1
;
2986 const double_int
*d2
= (const double_int
*)p2
;
2994 /* Return index of BOUND in BOUNDS array sorted in increasing order.
2995 Lookup by binary search. */
2998 bound_index (vec
<double_int
> bounds
, double_int bound
)
3000 unsigned int end
= bounds
.length ();
3001 unsigned int begin
= 0;
3003 /* Find a matching index by means of a binary search. */
3004 while (begin
!= end
)
3006 unsigned int middle
= (begin
+ end
) / 2;
3007 double_int index
= bounds
[middle
];
3011 else if (index
.ult (bound
))
3019 /* We recorded loop bounds only for statements dominating loop latch (and thus
3020 executed each loop iteration). If there are any bounds on statements not
3021 dominating the loop latch we can improve the estimate by walking the loop
3022 body and seeing if every path from loop header to loop latch contains
3023 some bounded statement. */
3026 discover_iteration_bound_by_body_walk (struct loop
*loop
)
3028 pointer_map_t
*bb_bounds
;
3029 struct nb_iter_bound
*elt
;
3030 vec
<double_int
> bounds
= vNULL
;
3031 vec
<vec
<basic_block
> > queues
= vNULL
;
3032 vec
<basic_block
> queue
= vNULL
;
3033 ptrdiff_t queue_index
;
3034 ptrdiff_t latch_index
= 0;
3035 pointer_map_t
*block_priority
;
3037 /* Discover what bounds may interest us. */
3038 for (elt
= loop
->bounds
; elt
; elt
= elt
->next
)
3040 double_int bound
= elt
->bound
;
3042 /* Exit terminates loop at given iteration, while non-exits produce undefined
3043 effect on the next iteration. */
3046 bound
+= double_int_one
;
3047 /* If an overflow occurred, ignore the result. */
3048 if (bound
.is_zero ())
3052 if (!loop
->any_upper_bound
3053 || bound
.ult (loop
->nb_iterations_upper_bound
))
3054 bounds
.safe_push (bound
);
3057 /* Exit early if there is nothing to do. */
3058 if (!bounds
.exists ())
3061 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3062 fprintf (dump_file
, " Trying to walk loop body to reduce the bound.\n");
3064 /* Sort the bounds in decreasing order. */
3065 qsort (bounds
.address (), bounds
.length (),
3066 sizeof (double_int
), double_int_cmp
);
3068 /* For every basic block record the lowest bound that is guaranteed to
3069 terminate the loop. */
3071 bb_bounds
= pointer_map_create ();
3072 for (elt
= loop
->bounds
; elt
; elt
= elt
->next
)
3074 double_int bound
= elt
->bound
;
3077 bound
+= double_int_one
;
3078 /* If an overflow occurred, ignore the result. */
3079 if (bound
.is_zero ())
3083 if (!loop
->any_upper_bound
3084 || bound
.ult (loop
->nb_iterations_upper_bound
))
3086 ptrdiff_t index
= bound_index (bounds
, bound
);
3087 void **entry
= pointer_map_contains (bb_bounds
,
3088 gimple_bb (elt
->stmt
));
3090 *pointer_map_insert (bb_bounds
,
3091 gimple_bb (elt
->stmt
)) = (void *)index
;
3092 else if ((ptrdiff_t)*entry
> index
)
3093 *entry
= (void *)index
;
3097 block_priority
= pointer_map_create ();
3099 /* Perform shortest path discovery loop->header ... loop->latch.
3101 The "distance" is given by the smallest loop bound of basic block
3102 present in the path and we look for path with largest smallest bound
3105 To avoid the need for fibonacci heap on double ints we simply compress
3106 double ints into indexes to BOUNDS array and then represent the queue
3107 as arrays of queues for every index.
3108 Index of BOUNDS.length() means that the execution of given BB has
3109 no bounds determined.
3111 VISITED is a pointer map translating basic block into smallest index
3112 it was inserted into the priority queue with. */
3115 /* Start walk in loop header with index set to infinite bound. */
3116 queue_index
= bounds
.length ();
3117 queues
.safe_grow_cleared (queue_index
+ 1);
3118 queue
.safe_push (loop
->header
);
3119 queues
[queue_index
] = queue
;
3120 *pointer_map_insert (block_priority
, loop
->header
) = (void *)queue_index
;
3122 for (; queue_index
>= 0; queue_index
--)
3124 if (latch_index
< queue_index
)
3126 while (queues
[queue_index
].length ())
3129 ptrdiff_t bound_index
= queue_index
;
3134 queue
= queues
[queue_index
];
3137 /* OK, we later inserted the BB with lower priority, skip it. */
3138 if ((ptrdiff_t)*pointer_map_contains (block_priority
, bb
) > queue_index
)
3141 /* See if we can improve the bound. */
3142 entry
= pointer_map_contains (bb_bounds
, bb
);
3143 if (entry
&& (ptrdiff_t)*entry
< bound_index
)
3144 bound_index
= (ptrdiff_t)*entry
;
3146 /* Insert succesors into the queue, watch for latch edge
3147 and record greatest index we saw. */
3148 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
3150 bool insert
= false;
3153 if (loop_exit_edge_p (loop
, e
))
3156 if (e
== loop_latch_edge (loop
)
3157 && latch_index
< bound_index
)
3158 latch_index
= bound_index
;
3159 else if (!(entry
= pointer_map_contains (block_priority
, e
->dest
)))
3162 *pointer_map_insert (block_priority
, e
->dest
) = (void *)bound_index
;
3164 else if ((ptrdiff_t)*entry
< bound_index
)
3167 *entry
= (void *)bound_index
;
3171 queues
[bound_index
].safe_push (e
->dest
);
3175 queues
[queue_index
].release ();
3178 gcc_assert (latch_index
>= 0);
3179 if ((unsigned)latch_index
< bounds
.length ())
3181 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3183 fprintf (dump_file
, "Found better loop bound ");
3184 dump_double_int (dump_file
, bounds
[latch_index
], true);
3185 fprintf (dump_file
, "\n");
3187 record_niter_bound (loop
, bounds
[latch_index
], false, true);
3192 pointer_map_destroy (bb_bounds
);
3193 pointer_map_destroy (block_priority
);
3196 /* See if every path cross the loop goes through a statement that is known
3197 to not execute at the last iteration. In that case we can decrese iteration
3201 maybe_lower_iteration_bound (struct loop
*loop
)
3203 pointer_set_t
*not_executed_last_iteration
= NULL
;
3204 struct nb_iter_bound
*elt
;
3205 bool found_exit
= false;
3206 vec
<basic_block
> queue
= vNULL
;
3209 /* Collect all statements with interesting (i.e. lower than
3210 nb_iterations_upper_bound) bound on them.
3212 TODO: Due to the way record_estimate choose estimates to store, the bounds
3213 will be always nb_iterations_upper_bound-1. We can change this to record
3214 also statements not dominating the loop latch and update the walk bellow
3215 to the shortest path algorthm. */
3216 for (elt
= loop
->bounds
; elt
; elt
= elt
->next
)
3219 && elt
->bound
.ult (loop
->nb_iterations_upper_bound
))
3221 if (!not_executed_last_iteration
)
3222 not_executed_last_iteration
= pointer_set_create ();
3223 pointer_set_insert (not_executed_last_iteration
, elt
->stmt
);
3226 if (!not_executed_last_iteration
)
3229 /* Start DFS walk in the loop header and see if we can reach the
3230 loop latch or any of the exits (including statements with side
3231 effects that may terminate the loop otherwise) without visiting
3232 any of the statements known to have undefined effect on the last
3234 queue
.safe_push (loop
->header
);
3235 visited
= BITMAP_ALLOC (NULL
);
3236 bitmap_set_bit (visited
, loop
->header
->index
);
3241 basic_block bb
= queue
.pop ();
3242 gimple_stmt_iterator gsi
;
3243 bool stmt_found
= false;
3245 /* Loop for possible exits and statements bounding the execution. */
3246 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3248 gimple stmt
= gsi_stmt (gsi
);
3249 if (pointer_set_contains (not_executed_last_iteration
, stmt
))
3254 if (gimple_has_side_effects (stmt
))
3263 /* If no bounding statement is found, continue the walk. */
3269 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
3271 if (loop_exit_edge_p (loop
, e
)
3272 || e
== loop_latch_edge (loop
))
3277 if (bitmap_set_bit (visited
, e
->dest
->index
))
3278 queue
.safe_push (e
->dest
);
3282 while (queue
.length () && !found_exit
);
3284 /* If every path through the loop reach bounding statement before exit,
3285 then we know the last iteration of the loop will have undefined effect
3286 and we can decrease number of iterations. */
3290 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3291 fprintf (dump_file
, "Reducing loop iteration estimate by 1; "
3292 "undefined statement must be executed at the last iteration.\n");
3293 record_niter_bound (loop
, loop
->nb_iterations_upper_bound
- double_int_one
,
3296 BITMAP_FREE (visited
);
3298 pointer_set_destroy (not_executed_last_iteration
);
3301 /* Records estimates on numbers of iterations of LOOP. If USE_UNDEFINED_P
3302 is true also use estimates derived from undefined behavior. */
3305 estimate_numbers_of_iterations_loop (struct loop
*loop
)
3310 struct tree_niter_desc niter_desc
;
3315 /* Give up if we already have tried to compute an estimation. */
3316 if (loop
->estimate_state
!= EST_NOT_COMPUTED
)
3319 loop
->estimate_state
= EST_AVAILABLE
;
3320 /* Force estimate compuation but leave any existing upper bound in place. */
3321 loop
->any_estimate
= false;
3323 /* Ensure that loop->nb_iterations is computed if possible. If it turns out
3324 to be constant, we avoid undefined behavior implied bounds and instead
3325 diagnose those loops with -Waggressive-loop-optimizations. */
3326 number_of_latch_executions (loop
);
3328 exits
= get_loop_exit_edges (loop
);
3329 likely_exit
= single_likely_exit (loop
);
3330 FOR_EACH_VEC_ELT (exits
, i
, ex
)
3332 if (!number_of_iterations_exit (loop
, ex
, &niter_desc
, false, false))
3335 niter
= niter_desc
.niter
;
3336 type
= TREE_TYPE (niter
);
3337 if (TREE_CODE (niter_desc
.may_be_zero
) != INTEGER_CST
)
3338 niter
= build3 (COND_EXPR
, type
, niter_desc
.may_be_zero
,
3339 build_int_cst (type
, 0),
3341 record_estimate (loop
, niter
, niter_desc
.max
,
3342 last_stmt (ex
->src
),
3343 true, ex
== likely_exit
, true);
3347 if (flag_aggressive_loop_optimizations
)
3348 infer_loop_bounds_from_undefined (loop
);
3350 discover_iteration_bound_by_body_walk (loop
);
3352 maybe_lower_iteration_bound (loop
);
3354 /* If we have a measured profile, use it to estimate the number of
3356 if (loop
->header
->count
!= 0)
3358 gcov_type nit
= expected_loop_iterations_unbounded (loop
) + 1;
3359 bound
= gcov_type_to_double_int (nit
);
3360 record_niter_bound (loop
, bound
, true, false);
3363 /* If we know the exact number of iterations of this loop, try to
3364 not break code with undefined behavior by not recording smaller
3365 maximum number of iterations. */
3366 if (loop
->nb_iterations
3367 && TREE_CODE (loop
->nb_iterations
) == INTEGER_CST
)
3369 loop
->any_upper_bound
= true;
3370 loop
->nb_iterations_upper_bound
3371 = tree_to_double_int (loop
->nb_iterations
);
3375 /* Sets NIT to the estimated number of executions of the latch of the
3376 LOOP. If CONSERVATIVE is true, we must be sure that NIT is at least as
3377 large as the number of iterations. If we have no reliable estimate,
3378 the function returns false, otherwise returns true. */
3381 estimated_loop_iterations (struct loop
*loop
, double_int
*nit
)
3383 /* When SCEV information is available, try to update loop iterations
3384 estimate. Otherwise just return whatever we recorded earlier. */
3385 if (scev_initialized_p ())
3386 estimate_numbers_of_iterations_loop (loop
);
3388 return (get_estimated_loop_iterations (loop
, nit
));
3391 /* Similar to estimated_loop_iterations, but returns the estimate only
3392 if it fits to HOST_WIDE_INT. If this is not the case, or the estimate
3393 on the number of iterations of LOOP could not be derived, returns -1. */
3396 estimated_loop_iterations_int (struct loop
*loop
)
3399 HOST_WIDE_INT hwi_nit
;
3401 if (!estimated_loop_iterations (loop
, &nit
))
3404 if (!nit
.fits_shwi ())
3406 hwi_nit
= nit
.to_shwi ();
3408 return hwi_nit
< 0 ? -1 : hwi_nit
;
3412 /* Sets NIT to an upper bound for the maximum number of executions of the
3413 latch of the LOOP. If we have no reliable estimate, the function returns
3414 false, otherwise returns true. */
3417 max_loop_iterations (struct loop
*loop
, double_int
*nit
)
3419 /* When SCEV information is available, try to update loop iterations
3420 estimate. Otherwise just return whatever we recorded earlier. */
3421 if (scev_initialized_p ())
3422 estimate_numbers_of_iterations_loop (loop
);
3424 return get_max_loop_iterations (loop
, nit
);
3427 /* Similar to max_loop_iterations, but returns the estimate only
3428 if it fits to HOST_WIDE_INT. If this is not the case, or the estimate
3429 on the number of iterations of LOOP could not be derived, returns -1. */
3432 max_loop_iterations_int (struct loop
*loop
)
3435 HOST_WIDE_INT hwi_nit
;
3437 if (!max_loop_iterations (loop
, &nit
))
3440 if (!nit
.fits_shwi ())
3442 hwi_nit
= nit
.to_shwi ();
3444 return hwi_nit
< 0 ? -1 : hwi_nit
;
3447 /* Returns an estimate for the number of executions of statements
3448 in the LOOP. For statements before the loop exit, this exceeds
3449 the number of execution of the latch by one. */
3452 estimated_stmt_executions_int (struct loop
*loop
)
3454 HOST_WIDE_INT nit
= estimated_loop_iterations_int (loop
);
3460 snit
= (HOST_WIDE_INT
) ((unsigned HOST_WIDE_INT
) nit
+ 1);
3462 /* If the computation overflows, return -1. */
3463 return snit
< 0 ? -1 : snit
;
3466 /* Sets NIT to the estimated maximum number of executions of the latch of the
3467 LOOP, plus one. If we have no reliable estimate, the function returns
3468 false, otherwise returns true. */
3471 max_stmt_executions (struct loop
*loop
, double_int
*nit
)
3473 double_int nit_minus_one
;
3475 if (!max_loop_iterations (loop
, nit
))
3478 nit_minus_one
= *nit
;
3480 *nit
+= double_int_one
;
3482 return (*nit
).ugt (nit_minus_one
);
3485 /* Sets NIT to the estimated number of executions of the latch of the
3486 LOOP, plus one. If we have no reliable estimate, the function returns
3487 false, otherwise returns true. */
3490 estimated_stmt_executions (struct loop
*loop
, double_int
*nit
)
3492 double_int nit_minus_one
;
3494 if (!estimated_loop_iterations (loop
, nit
))
3497 nit_minus_one
= *nit
;
3499 *nit
+= double_int_one
;
3501 return (*nit
).ugt (nit_minus_one
);
3504 /* Records estimates on numbers of iterations of loops. */
3507 estimate_numbers_of_iterations (void)
3512 /* We don't want to issue signed overflow warnings while getting
3513 loop iteration estimates. */
3514 fold_defer_overflow_warnings ();
3516 FOR_EACH_LOOP (li
, loop
, 0)
3518 estimate_numbers_of_iterations_loop (loop
);
3521 fold_undefer_and_ignore_overflow_warnings ();
3524 /* Returns true if statement S1 dominates statement S2. */
3527 stmt_dominates_stmt_p (gimple s1
, gimple s2
)
3529 basic_block bb1
= gimple_bb (s1
), bb2
= gimple_bb (s2
);
3537 gimple_stmt_iterator bsi
;
3539 if (gimple_code (s2
) == GIMPLE_PHI
)
3542 if (gimple_code (s1
) == GIMPLE_PHI
)
3545 for (bsi
= gsi_start_bb (bb1
); gsi_stmt (bsi
) != s2
; gsi_next (&bsi
))
3546 if (gsi_stmt (bsi
) == s1
)
3552 return dominated_by_p (CDI_DOMINATORS
, bb2
, bb1
);
3555 /* Returns true when we can prove that the number of executions of
3556 STMT in the loop is at most NITER, according to the bound on
3557 the number of executions of the statement NITER_BOUND->stmt recorded in
3558 NITER_BOUND and fact that NITER_BOUND->stmt dominate STMT.
3560 ??? This code can become quite a CPU hog - we can have many bounds,
3561 and large basic block forcing stmt_dominates_stmt_p to be queried
3562 many times on a large basic blocks, so the whole thing is O(n^2)
3563 for scev_probably_wraps_p invocation (that can be done n times).
3565 It would make more sense (and give better answers) to remember BB
3566 bounds computed by discover_iteration_bound_by_body_walk. */
3569 n_of_executions_at_most (gimple stmt
,
3570 struct nb_iter_bound
*niter_bound
,
3573 double_int bound
= niter_bound
->bound
;
3574 tree nit_type
= TREE_TYPE (niter
), e
;
3577 gcc_assert (TYPE_UNSIGNED (nit_type
));
3579 /* If the bound does not even fit into NIT_TYPE, it cannot tell us that
3580 the number of iterations is small. */
3581 if (!double_int_fits_to_tree_p (nit_type
, bound
))
3584 /* We know that NITER_BOUND->stmt is executed at most NITER_BOUND->bound + 1
3585 times. This means that:
3587 -- if NITER_BOUND->is_exit is true, then everything after
3588 it at most NITER_BOUND->bound times.
3590 -- If NITER_BOUND->is_exit is false, then if we can prove that when STMT
3591 is executed, then NITER_BOUND->stmt is executed as well in the same
3592 iteration then STMT is executed at most NITER_BOUND->bound + 1 times.
3594 If we can determine that NITER_BOUND->stmt is always executed
3595 after STMT, then STMT is executed at most NITER_BOUND->bound + 2 times.
3596 We conclude that if both statements belong to the same
3597 basic block and STMT is before NITER_BOUND->stmt and there are no
3598 statements with side effects in between. */
3600 if (niter_bound
->is_exit
)
3602 if (stmt
== niter_bound
->stmt
3603 || !stmt_dominates_stmt_p (niter_bound
->stmt
, stmt
))
3609 if (!stmt_dominates_stmt_p (niter_bound
->stmt
, stmt
))
3611 gimple_stmt_iterator bsi
;
3612 if (gimple_bb (stmt
) != gimple_bb (niter_bound
->stmt
)
3613 || gimple_code (stmt
) == GIMPLE_PHI
3614 || gimple_code (niter_bound
->stmt
) == GIMPLE_PHI
)
3617 /* By stmt_dominates_stmt_p we already know that STMT appears
3618 before NITER_BOUND->STMT. Still need to test that the loop
3619 can not be terinated by a side effect in between. */
3620 for (bsi
= gsi_for_stmt (stmt
); gsi_stmt (bsi
) != niter_bound
->stmt
;
3622 if (gimple_has_side_effects (gsi_stmt (bsi
)))
3624 bound
+= double_int_one
;
3625 if (bound
.is_zero ()
3626 || !double_int_fits_to_tree_p (nit_type
, bound
))
3632 e
= fold_binary (cmp
, boolean_type_node
,
3633 niter
, double_int_to_tree (nit_type
, bound
));
3634 return e
&& integer_nonzerop (e
);
3637 /* Returns true if the arithmetics in TYPE can be assumed not to wrap. */
3640 nowrap_type_p (tree type
)
3642 if (INTEGRAL_TYPE_P (type
)
3643 && TYPE_OVERFLOW_UNDEFINED (type
))
3646 if (POINTER_TYPE_P (type
))
3652 /* Return false only when the induction variable BASE + STEP * I is
3653 known to not overflow: i.e. when the number of iterations is small
3654 enough with respect to the step and initial condition in order to
3655 keep the evolution confined in TYPEs bounds. Return true when the
3656 iv is known to overflow or when the property is not computable.
3658 USE_OVERFLOW_SEMANTICS is true if this function should assume that
3659 the rules for overflow of the given language apply (e.g., that signed
3660 arithmetics in C does not overflow). */
3663 scev_probably_wraps_p (tree base
, tree step
,
3664 gimple at_stmt
, struct loop
*loop
,
3665 bool use_overflow_semantics
)
3667 tree delta
, step_abs
;
3668 tree unsigned_type
, valid_niter
;
3669 tree type
= TREE_TYPE (step
);
3672 struct nb_iter_bound
*bound
;
3674 /* FIXME: We really need something like
3675 http://gcc.gnu.org/ml/gcc-patches/2005-06/msg02025.html.
3677 We used to test for the following situation that frequently appears
3678 during address arithmetics:
3680 D.1621_13 = (long unsigned intD.4) D.1620_12;
3681 D.1622_14 = D.1621_13 * 8;
3682 D.1623_15 = (doubleD.29 *) D.1622_14;
3684 And derived that the sequence corresponding to D_14
3685 can be proved to not wrap because it is used for computing a
3686 memory access; however, this is not really the case -- for example,
3687 if D_12 = (unsigned char) [254,+,1], then D_14 has values
3688 2032, 2040, 0, 8, ..., but the code is still legal. */
3690 if (chrec_contains_undetermined (base
)
3691 || chrec_contains_undetermined (step
))
3694 if (integer_zerop (step
))
3697 /* If we can use the fact that signed and pointer arithmetics does not
3698 wrap, we are done. */
3699 if (use_overflow_semantics
&& nowrap_type_p (TREE_TYPE (base
)))
3702 /* To be able to use estimates on number of iterations of the loop,
3703 we must have an upper bound on the absolute value of the step. */
3704 if (TREE_CODE (step
) != INTEGER_CST
)
3707 /* Don't issue signed overflow warnings. */
3708 fold_defer_overflow_warnings ();
3710 /* Otherwise, compute the number of iterations before we reach the
3711 bound of the type, and verify that the loop is exited before this
3713 unsigned_type
= unsigned_type_for (type
);
3714 base
= fold_convert (unsigned_type
, base
);
3716 if (tree_int_cst_sign_bit (step
))
3718 tree extreme
= fold_convert (unsigned_type
,
3719 lower_bound_in_type (type
, type
));
3720 delta
= fold_build2 (MINUS_EXPR
, unsigned_type
, base
, extreme
);
3721 step_abs
= fold_build1 (NEGATE_EXPR
, unsigned_type
,
3722 fold_convert (unsigned_type
, step
));
3726 tree extreme
= fold_convert (unsigned_type
,
3727 upper_bound_in_type (type
, type
));
3728 delta
= fold_build2 (MINUS_EXPR
, unsigned_type
, extreme
, base
);
3729 step_abs
= fold_convert (unsigned_type
, step
);
3732 valid_niter
= fold_build2 (FLOOR_DIV_EXPR
, unsigned_type
, delta
, step_abs
);
3734 estimate_numbers_of_iterations_loop (loop
);
3736 if (max_loop_iterations (loop
, &niter
)
3737 && double_int_fits_to_tree_p (TREE_TYPE (valid_niter
), niter
)
3738 && (e
= fold_binary (GT_EXPR
, boolean_type_node
, valid_niter
,
3739 double_int_to_tree (TREE_TYPE (valid_niter
),
3741 && integer_nonzerop (e
))
3743 fold_undefer_and_ignore_overflow_warnings ();
3747 for (bound
= loop
->bounds
; bound
; bound
= bound
->next
)
3749 if (n_of_executions_at_most (at_stmt
, bound
, valid_niter
))
3751 fold_undefer_and_ignore_overflow_warnings ();
3756 fold_undefer_and_ignore_overflow_warnings ();
3758 /* At this point we still don't have a proof that the iv does not
3759 overflow: give up. */
3763 /* Frees the information on upper bounds on numbers of iterations of LOOP. */
3766 free_numbers_of_iterations_estimates_loop (struct loop
*loop
)
3768 struct nb_iter_bound
*bound
, *next
;
3770 loop
->nb_iterations
= NULL
;
3771 loop
->estimate_state
= EST_NOT_COMPUTED
;
3772 for (bound
= loop
->bounds
; bound
; bound
= next
)
3778 loop
->bounds
= NULL
;
3781 /* Frees the information on upper bounds on numbers of iterations of loops. */
3784 free_numbers_of_iterations_estimates (void)
3789 FOR_EACH_LOOP (li
, loop
, 0)
3791 free_numbers_of_iterations_estimates_loop (loop
);
3795 /* Substitute value VAL for ssa name NAME inside expressions held
3799 substitute_in_loop_info (struct loop
*loop
, tree name
, tree val
)
3801 loop
->nb_iterations
= simplify_replace_tree (loop
->nb_iterations
, name
, val
);