1 /* Chains of recurrences.
2 Copyright (C) 2003-2013 Free Software Foundation, Inc.
3 Contributed by Sebastian Pop <pop@cri.ensmp.fr>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This file implements operations on chains of recurrences. Chains
22 of recurrences are used for modeling evolution functions of scalar
28 #include "coretypes.h"
29 #include "tree-pretty-print.h"
32 #include "tree-chrec.h"
35 #include "tree-scalar-evolution.h"
37 /* Extended folder for chrecs. */
39 /* Determines whether CST is not a constant evolution. */
42 is_not_constant_evolution (const_tree cst
)
44 return (TREE_CODE (cst
) == POLYNOMIAL_CHREC
);
47 /* Fold CODE for a polynomial function and a constant. */
50 chrec_fold_poly_cst (enum tree_code code
,
57 gcc_assert (TREE_CODE (poly
) == POLYNOMIAL_CHREC
);
58 gcc_assert (!is_not_constant_evolution (cst
));
59 gcc_assert (type
== chrec_type (poly
));
64 return build_polynomial_chrec
65 (CHREC_VARIABLE (poly
),
66 chrec_fold_plus (type
, CHREC_LEFT (poly
), cst
),
70 return build_polynomial_chrec
71 (CHREC_VARIABLE (poly
),
72 chrec_fold_minus (type
, CHREC_LEFT (poly
), cst
),
76 return build_polynomial_chrec
77 (CHREC_VARIABLE (poly
),
78 chrec_fold_multiply (type
, CHREC_LEFT (poly
), cst
),
79 chrec_fold_multiply (type
, CHREC_RIGHT (poly
), cst
));
82 return chrec_dont_know
;
86 /* Fold the addition of two polynomial functions. */
89 chrec_fold_plus_poly_poly (enum tree_code code
,
95 struct loop
*loop0
= get_chrec_loop (poly0
);
96 struct loop
*loop1
= get_chrec_loop (poly1
);
97 tree rtype
= code
== POINTER_PLUS_EXPR
? chrec_type (poly1
) : type
;
101 gcc_assert (TREE_CODE (poly0
) == POLYNOMIAL_CHREC
);
102 gcc_assert (TREE_CODE (poly1
) == POLYNOMIAL_CHREC
);
103 if (POINTER_TYPE_P (chrec_type (poly0
)))
104 gcc_assert (ptrofftype_p (chrec_type (poly1
)));
106 gcc_assert (chrec_type (poly0
) == chrec_type (poly1
));
107 gcc_assert (type
== chrec_type (poly0
));
110 {a, +, b}_1 + {c, +, d}_2 -> {{a, +, b}_1 + c, +, d}_2,
111 {a, +, b}_2 + {c, +, d}_1 -> {{c, +, d}_1 + a, +, b}_2,
112 {a, +, b}_x + {c, +, d}_x -> {a+c, +, b+d}_x. */
113 if (flow_loop_nested_p (loop0
, loop1
))
115 if (code
== PLUS_EXPR
|| code
== POINTER_PLUS_EXPR
)
116 return build_polynomial_chrec
117 (CHREC_VARIABLE (poly1
),
118 chrec_fold_plus (type
, poly0
, CHREC_LEFT (poly1
)),
119 CHREC_RIGHT (poly1
));
121 return build_polynomial_chrec
122 (CHREC_VARIABLE (poly1
),
123 chrec_fold_minus (type
, poly0
, CHREC_LEFT (poly1
)),
124 chrec_fold_multiply (type
, CHREC_RIGHT (poly1
),
125 SCALAR_FLOAT_TYPE_P (type
)
126 ? build_real (type
, dconstm1
)
127 : build_int_cst_type (type
, -1)));
130 if (flow_loop_nested_p (loop1
, loop0
))
132 if (code
== PLUS_EXPR
|| code
== POINTER_PLUS_EXPR
)
133 return build_polynomial_chrec
134 (CHREC_VARIABLE (poly0
),
135 chrec_fold_plus (type
, CHREC_LEFT (poly0
), poly1
),
136 CHREC_RIGHT (poly0
));
138 return build_polynomial_chrec
139 (CHREC_VARIABLE (poly0
),
140 chrec_fold_minus (type
, CHREC_LEFT (poly0
), poly1
),
141 CHREC_RIGHT (poly0
));
144 /* This function should never be called for chrecs of loops that
145 do not belong to the same loop nest. */
146 gcc_assert (loop0
== loop1
);
148 if (code
== PLUS_EXPR
|| code
== POINTER_PLUS_EXPR
)
150 left
= chrec_fold_plus
151 (type
, CHREC_LEFT (poly0
), CHREC_LEFT (poly1
));
152 right
= chrec_fold_plus
153 (rtype
, CHREC_RIGHT (poly0
), CHREC_RIGHT (poly1
));
157 left
= chrec_fold_minus
158 (type
, CHREC_LEFT (poly0
), CHREC_LEFT (poly1
));
159 right
= chrec_fold_minus
160 (type
, CHREC_RIGHT (poly0
), CHREC_RIGHT (poly1
));
163 if (chrec_zerop (right
))
166 return build_polynomial_chrec
167 (CHREC_VARIABLE (poly0
), left
, right
);
172 /* Fold the multiplication of two polynomial functions. */
175 chrec_fold_multiply_poly_poly (tree type
,
181 struct loop
*loop0
= get_chrec_loop (poly0
);
182 struct loop
*loop1
= get_chrec_loop (poly1
);
186 gcc_assert (TREE_CODE (poly0
) == POLYNOMIAL_CHREC
);
187 gcc_assert (TREE_CODE (poly1
) == POLYNOMIAL_CHREC
);
188 gcc_assert (chrec_type (poly0
) == chrec_type (poly1
));
189 gcc_assert (type
== chrec_type (poly0
));
191 /* {a, +, b}_1 * {c, +, d}_2 -> {c*{a, +, b}_1, +, d}_2,
192 {a, +, b}_2 * {c, +, d}_1 -> {a*{c, +, d}_1, +, b}_2,
193 {a, +, b}_x * {c, +, d}_x -> {a*c, +, a*d + b*c + b*d, +, 2*b*d}_x. */
194 if (flow_loop_nested_p (loop0
, loop1
))
195 /* poly0 is a constant wrt. poly1. */
196 return build_polynomial_chrec
197 (CHREC_VARIABLE (poly1
),
198 chrec_fold_multiply (type
, CHREC_LEFT (poly1
), poly0
),
199 CHREC_RIGHT (poly1
));
201 if (flow_loop_nested_p (loop1
, loop0
))
202 /* poly1 is a constant wrt. poly0. */
203 return build_polynomial_chrec
204 (CHREC_VARIABLE (poly0
),
205 chrec_fold_multiply (type
, CHREC_LEFT (poly0
), poly1
),
206 CHREC_RIGHT (poly0
));
208 gcc_assert (loop0
== loop1
);
210 /* poly0 and poly1 are two polynomials in the same variable,
211 {a, +, b}_x * {c, +, d}_x -> {a*c, +, a*d + b*c + b*d, +, 2*b*d}_x. */
214 t0
= chrec_fold_multiply (type
, CHREC_LEFT (poly0
), CHREC_LEFT (poly1
));
217 t1
= chrec_fold_multiply (type
, CHREC_LEFT (poly0
), CHREC_RIGHT (poly1
));
218 t1
= chrec_fold_plus (type
, t1
, chrec_fold_multiply (type
,
220 CHREC_LEFT (poly1
)));
222 t2
= chrec_fold_multiply (type
, CHREC_RIGHT (poly0
), CHREC_RIGHT (poly1
));
223 /* "a*d + b*c + b*d". */
224 t1
= chrec_fold_plus (type
, t1
, t2
);
226 t2
= chrec_fold_multiply (type
, SCALAR_FLOAT_TYPE_P (type
)
227 ? build_real (type
, dconst2
)
228 : build_int_cst (type
, 2), t2
);
230 var
= CHREC_VARIABLE (poly0
);
231 return build_polynomial_chrec (var
, t0
,
232 build_polynomial_chrec (var
, t1
, t2
));
235 /* When the operands are automatically_generated_chrec_p, the fold has
236 to respect the semantics of the operands. */
239 chrec_fold_automatically_generated_operands (tree op0
,
242 if (op0
== chrec_dont_know
243 || op1
== chrec_dont_know
)
244 return chrec_dont_know
;
246 if (op0
== chrec_known
247 || op1
== chrec_known
)
250 if (op0
== chrec_not_analyzed_yet
251 || op1
== chrec_not_analyzed_yet
)
252 return chrec_not_analyzed_yet
;
254 /* The default case produces a safe result. */
255 return chrec_dont_know
;
258 /* Fold the addition of two chrecs. */
261 chrec_fold_plus_1 (enum tree_code code
, tree type
,
264 if (automatically_generated_chrec_p (op0
)
265 || automatically_generated_chrec_p (op1
))
266 return chrec_fold_automatically_generated_operands (op0
, op1
);
268 switch (TREE_CODE (op0
))
270 case POLYNOMIAL_CHREC
:
272 (!chrec_contains_symbols_defined_in_loop (op0
, CHREC_VARIABLE (op0
)));
273 switch (TREE_CODE (op1
))
275 case POLYNOMIAL_CHREC
:
277 (!chrec_contains_symbols_defined_in_loop (op1
,
278 CHREC_VARIABLE (op1
)));
279 return chrec_fold_plus_poly_poly (code
, type
, op0
, op1
);
282 if (tree_contains_chrecs (op1
, NULL
))
283 return chrec_dont_know
;
286 if (code
== PLUS_EXPR
|| code
== POINTER_PLUS_EXPR
)
287 return build_polynomial_chrec
288 (CHREC_VARIABLE (op0
),
289 chrec_fold_plus (type
, CHREC_LEFT (op0
), op1
),
292 return build_polynomial_chrec
293 (CHREC_VARIABLE (op0
),
294 chrec_fold_minus (type
, CHREC_LEFT (op0
), op1
),
299 if (tree_contains_chrecs (op0
, NULL
))
300 return chrec_dont_know
;
303 switch (TREE_CODE (op1
))
305 case POLYNOMIAL_CHREC
:
307 (!chrec_contains_symbols_defined_in_loop (op1
,
308 CHREC_VARIABLE (op1
)));
309 if (code
== PLUS_EXPR
|| code
== POINTER_PLUS_EXPR
)
310 return build_polynomial_chrec
311 (CHREC_VARIABLE (op1
),
312 chrec_fold_plus (type
, op0
, CHREC_LEFT (op1
)),
315 return build_polynomial_chrec
316 (CHREC_VARIABLE (op1
),
317 chrec_fold_minus (type
, op0
, CHREC_LEFT (op1
)),
318 chrec_fold_multiply (type
, CHREC_RIGHT (op1
),
319 SCALAR_FLOAT_TYPE_P (type
)
320 ? build_real (type
, dconstm1
)
321 : build_int_cst_type (type
, -1)));
324 if (tree_contains_chrecs (op1
, NULL
))
325 return chrec_dont_know
;
330 if ((tree_contains_chrecs (op0
, &size
)
331 || tree_contains_chrecs (op1
, &size
))
332 && size
< PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE
))
333 return build2 (code
, type
, op0
, op1
);
334 else if (size
< PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE
))
336 if (code
== POINTER_PLUS_EXPR
)
337 return fold_build_pointer_plus (fold_convert (type
, op0
),
340 return fold_build2 (code
, type
,
341 fold_convert (type
, op0
),
342 fold_convert (type
, op1
));
345 return chrec_dont_know
;
351 /* Fold the addition of two chrecs. */
354 chrec_fold_plus (tree type
,
359 if (automatically_generated_chrec_p (op0
)
360 || automatically_generated_chrec_p (op1
))
361 return chrec_fold_automatically_generated_operands (op0
, op1
);
363 if (integer_zerop (op0
))
364 return chrec_convert (type
, op1
, NULL
);
365 if (integer_zerop (op1
))
366 return chrec_convert (type
, op0
, NULL
);
368 if (POINTER_TYPE_P (type
))
369 code
= POINTER_PLUS_EXPR
;
373 return chrec_fold_plus_1 (code
, type
, op0
, op1
);
376 /* Fold the subtraction of two chrecs. */
379 chrec_fold_minus (tree type
,
383 if (automatically_generated_chrec_p (op0
)
384 || automatically_generated_chrec_p (op1
))
385 return chrec_fold_automatically_generated_operands (op0
, op1
);
387 if (integer_zerop (op1
))
390 return chrec_fold_plus_1 (MINUS_EXPR
, type
, op0
, op1
);
393 /* Fold the multiplication of two chrecs. */
396 chrec_fold_multiply (tree type
,
400 if (automatically_generated_chrec_p (op0
)
401 || automatically_generated_chrec_p (op1
))
402 return chrec_fold_automatically_generated_operands (op0
, op1
);
404 switch (TREE_CODE (op0
))
406 case POLYNOMIAL_CHREC
:
408 (!chrec_contains_symbols_defined_in_loop (op0
, CHREC_VARIABLE (op0
)));
409 switch (TREE_CODE (op1
))
411 case POLYNOMIAL_CHREC
:
413 (!chrec_contains_symbols_defined_in_loop (op1
,
414 CHREC_VARIABLE (op1
)));
415 return chrec_fold_multiply_poly_poly (type
, op0
, op1
);
418 if (tree_contains_chrecs (op1
, NULL
))
419 return chrec_dont_know
;
422 if (integer_onep (op1
))
424 if (integer_zerop (op1
))
425 return build_int_cst (type
, 0);
427 return build_polynomial_chrec
428 (CHREC_VARIABLE (op0
),
429 chrec_fold_multiply (type
, CHREC_LEFT (op0
), op1
),
430 chrec_fold_multiply (type
, CHREC_RIGHT (op0
), op1
));
434 if (tree_contains_chrecs (op0
, NULL
))
435 return chrec_dont_know
;
438 if (integer_onep (op0
))
441 if (integer_zerop (op0
))
442 return build_int_cst (type
, 0);
444 switch (TREE_CODE (op1
))
446 case POLYNOMIAL_CHREC
:
448 (!chrec_contains_symbols_defined_in_loop (op1
,
449 CHREC_VARIABLE (op1
)));
450 return build_polynomial_chrec
451 (CHREC_VARIABLE (op1
),
452 chrec_fold_multiply (type
, CHREC_LEFT (op1
), op0
),
453 chrec_fold_multiply (type
, CHREC_RIGHT (op1
), op0
));
456 if (tree_contains_chrecs (op1
, NULL
))
457 return chrec_dont_know
;
460 if (integer_onep (op1
))
462 if (integer_zerop (op1
))
463 return build_int_cst (type
, 0);
464 return fold_build2 (MULT_EXPR
, type
, op0
, op1
);
473 /* Evaluate the binomial coefficient. Return NULL_TREE if the intermediate
474 calculation overflows, otherwise return C(n,k) with type TYPE. */
477 tree_fold_binomial (tree type
, tree n
, unsigned int k
)
479 double_int num
, denom
, idx
, di_res
;
484 /* Handle the most frequent cases. */
486 return build_int_cst (type
, 1);
488 return fold_convert (type
, n
);
491 num
= TREE_INT_CST (n
);
493 /* Check that k <= n. */
494 if (num
.ult (double_int::from_uhwi (k
)))
497 /* Denominator = 2. */
498 denom
= double_int::from_uhwi (2);
500 /* Index = Numerator-1. */
501 idx
= num
- double_int_one
;
503 /* Numerator = Numerator*Index = n*(n-1). */
504 num
= num
.mul_with_sign (idx
, false, &overflow
);
508 for (i
= 3; i
<= k
; i
++)
513 /* Numerator *= Index. */
514 num
= num
.mul_with_sign (idx
, false, &overflow
);
518 /* Denominator *= i. */
519 denom
*= double_int::from_uhwi (i
);
522 /* Result = Numerator / Denominator. */
523 di_res
= num
.div (denom
, true, EXACT_DIV_EXPR
);
524 res
= build_int_cst_wide (type
, di_res
.low
, di_res
.high
);
525 return int_fits_type_p (res
, type
) ? res
: NULL_TREE
;
528 /* Helper function. Use the Newton's interpolating formula for
529 evaluating the value of the evolution function. */
532 chrec_evaluate (unsigned var
, tree chrec
, tree n
, unsigned int k
)
534 tree arg0
, arg1
, binomial_n_k
;
535 tree type
= TREE_TYPE (chrec
);
536 struct loop
*var_loop
= get_loop (cfun
, var
);
538 while (TREE_CODE (chrec
) == POLYNOMIAL_CHREC
539 && flow_loop_nested_p (var_loop
, get_chrec_loop (chrec
)))
540 chrec
= CHREC_LEFT (chrec
);
542 if (TREE_CODE (chrec
) == POLYNOMIAL_CHREC
543 && CHREC_VARIABLE (chrec
) == var
)
545 arg1
= chrec_evaluate (var
, CHREC_RIGHT (chrec
), n
, k
+ 1);
546 if (arg1
== chrec_dont_know
)
547 return chrec_dont_know
;
548 binomial_n_k
= tree_fold_binomial (type
, n
, k
);
550 return chrec_dont_know
;
551 arg0
= fold_build2 (MULT_EXPR
, type
,
552 CHREC_LEFT (chrec
), binomial_n_k
);
553 return chrec_fold_plus (type
, arg0
, arg1
);
556 binomial_n_k
= tree_fold_binomial (type
, n
, k
);
558 return chrec_dont_know
;
560 return fold_build2 (MULT_EXPR
, type
, chrec
, binomial_n_k
);
563 /* Evaluates "CHREC (X)" when the varying variable is VAR.
564 Example: Given the following parameters,
570 The result is given by the Newton's interpolating formula:
571 3 * \binom{10}{0} + 4 * \binom{10}{1}.
575 chrec_apply (unsigned var
,
579 tree type
= chrec_type (chrec
);
580 tree res
= chrec_dont_know
;
582 if (automatically_generated_chrec_p (chrec
)
583 || automatically_generated_chrec_p (x
)
585 /* When the symbols are defined in an outer loop, it is possible
586 to symbolically compute the apply, since the symbols are
587 constants with respect to the varying loop. */
588 || chrec_contains_symbols_defined_in_loop (chrec
, var
))
589 return chrec_dont_know
;
591 if (dump_file
&& (dump_flags
& TDF_SCEV
))
592 fprintf (dump_file
, "(chrec_apply \n");
594 if (TREE_CODE (x
) == INTEGER_CST
&& SCALAR_FLOAT_TYPE_P (type
))
595 x
= build_real_from_int_cst (type
, x
);
597 switch (TREE_CODE (chrec
))
599 case POLYNOMIAL_CHREC
:
600 if (evolution_function_is_affine_p (chrec
))
602 if (CHREC_VARIABLE (chrec
) != var
)
603 return build_polynomial_chrec
604 (CHREC_VARIABLE (chrec
),
605 chrec_apply (var
, CHREC_LEFT (chrec
), x
),
606 chrec_apply (var
, CHREC_RIGHT (chrec
), x
));
608 /* "{a, +, b} (x)" -> "a + b*x". */
609 x
= chrec_convert_rhs (type
, x
, NULL
);
610 res
= chrec_fold_multiply (TREE_TYPE (x
), CHREC_RIGHT (chrec
), x
);
611 res
= chrec_fold_plus (type
, CHREC_LEFT (chrec
), res
);
613 else if (TREE_CODE (x
) == INTEGER_CST
614 && tree_int_cst_sgn (x
) == 1)
615 /* testsuite/.../ssa-chrec-38.c. */
616 res
= chrec_evaluate (var
, chrec
, x
, 0);
618 res
= chrec_dont_know
;
622 res
= chrec_convert (TREE_TYPE (chrec
),
623 chrec_apply (var
, TREE_OPERAND (chrec
, 0), x
),
632 if (dump_file
&& (dump_flags
& TDF_SCEV
))
634 fprintf (dump_file
, " (varying_loop = %d\n", var
);
635 fprintf (dump_file
, ")\n (chrec = ");
636 print_generic_expr (dump_file
, chrec
, 0);
637 fprintf (dump_file
, ")\n (x = ");
638 print_generic_expr (dump_file
, x
, 0);
639 fprintf (dump_file
, ")\n (res = ");
640 print_generic_expr (dump_file
, res
, 0);
641 fprintf (dump_file
, "))\n");
647 /* For a given CHREC and an induction variable map IV_MAP that maps
648 (loop->num, expr) for every loop number of the current_loops an
649 expression, calls chrec_apply when the expression is not NULL. */
652 chrec_apply_map (tree chrec
, vec
<tree
> iv_map
)
657 FOR_EACH_VEC_ELT (iv_map
, i
, expr
)
659 chrec
= chrec_apply (i
, chrec
, expr
);
664 /* Replaces the initial condition in CHREC with INIT_COND. */
667 chrec_replace_initial_condition (tree chrec
,
670 if (automatically_generated_chrec_p (chrec
))
673 gcc_assert (chrec_type (chrec
) == chrec_type (init_cond
));
675 switch (TREE_CODE (chrec
))
677 case POLYNOMIAL_CHREC
:
678 return build_polynomial_chrec
679 (CHREC_VARIABLE (chrec
),
680 chrec_replace_initial_condition (CHREC_LEFT (chrec
), init_cond
),
681 CHREC_RIGHT (chrec
));
688 /* Returns the initial condition of a given CHREC. */
691 initial_condition (tree chrec
)
693 if (automatically_generated_chrec_p (chrec
))
696 if (TREE_CODE (chrec
) == POLYNOMIAL_CHREC
)
697 return initial_condition (CHREC_LEFT (chrec
));
702 /* Returns a univariate function that represents the evolution in
703 LOOP_NUM. Mask the evolution of any other loop. */
706 hide_evolution_in_other_loops_than_loop (tree chrec
,
709 struct loop
*loop
= get_loop (cfun
, loop_num
), *chloop
;
710 if (automatically_generated_chrec_p (chrec
))
713 switch (TREE_CODE (chrec
))
715 case POLYNOMIAL_CHREC
:
716 chloop
= get_chrec_loop (chrec
);
719 return build_polynomial_chrec
721 hide_evolution_in_other_loops_than_loop (CHREC_LEFT (chrec
),
723 CHREC_RIGHT (chrec
));
725 else if (flow_loop_nested_p (chloop
, loop
))
726 /* There is no evolution in this loop. */
727 return initial_condition (chrec
);
731 gcc_assert (flow_loop_nested_p (loop
, chloop
));
732 return hide_evolution_in_other_loops_than_loop (CHREC_LEFT (chrec
),
741 /* Returns the evolution part of CHREC in LOOP_NUM when RIGHT is
742 true, otherwise returns the initial condition in LOOP_NUM. */
745 chrec_component_in_loop_num (tree chrec
,
750 struct loop
*loop
= get_loop (cfun
, loop_num
), *chloop
;
752 if (automatically_generated_chrec_p (chrec
))
755 switch (TREE_CODE (chrec
))
757 case POLYNOMIAL_CHREC
:
758 chloop
= get_chrec_loop (chrec
);
763 component
= CHREC_RIGHT (chrec
);
765 component
= CHREC_LEFT (chrec
);
767 if (TREE_CODE (CHREC_LEFT (chrec
)) != POLYNOMIAL_CHREC
768 || CHREC_VARIABLE (CHREC_LEFT (chrec
)) != CHREC_VARIABLE (chrec
))
772 return build_polynomial_chrec
774 chrec_component_in_loop_num (CHREC_LEFT (chrec
),
780 else if (flow_loop_nested_p (chloop
, loop
))
781 /* There is no evolution part in this loop. */
786 gcc_assert (flow_loop_nested_p (loop
, chloop
));
787 return chrec_component_in_loop_num (CHREC_LEFT (chrec
),
800 /* Returns the evolution part in LOOP_NUM. Example: the call
801 evolution_part_in_loop_num ({{0, +, 1}_1, +, 2}_1, 1) returns
805 evolution_part_in_loop_num (tree chrec
,
808 return chrec_component_in_loop_num (chrec
, loop_num
, true);
811 /* Returns the initial condition in LOOP_NUM. Example: the call
812 initial_condition_in_loop_num ({{0, +, 1}_1, +, 2}_2, 2) returns
816 initial_condition_in_loop_num (tree chrec
,
819 return chrec_component_in_loop_num (chrec
, loop_num
, false);
822 /* Set or reset the evolution of CHREC to NEW_EVOL in loop LOOP_NUM.
823 This function is essentially used for setting the evolution to
824 chrec_dont_know, for example after having determined that it is
825 impossible to say how many times a loop will execute. */
828 reset_evolution_in_loop (unsigned loop_num
,
832 struct loop
*loop
= get_loop (cfun
, loop_num
);
834 if (POINTER_TYPE_P (chrec_type (chrec
)))
835 gcc_assert (ptrofftype_p (chrec_type (new_evol
)));
837 gcc_assert (chrec_type (chrec
) == chrec_type (new_evol
));
839 if (TREE_CODE (chrec
) == POLYNOMIAL_CHREC
840 && flow_loop_nested_p (loop
, get_chrec_loop (chrec
)))
842 tree left
= reset_evolution_in_loop (loop_num
, CHREC_LEFT (chrec
),
844 tree right
= reset_evolution_in_loop (loop_num
, CHREC_RIGHT (chrec
),
846 return build3 (POLYNOMIAL_CHREC
, TREE_TYPE (left
),
847 CHREC_VAR (chrec
), left
, right
);
850 while (TREE_CODE (chrec
) == POLYNOMIAL_CHREC
851 && CHREC_VARIABLE (chrec
) == loop_num
)
852 chrec
= CHREC_LEFT (chrec
);
854 return build_polynomial_chrec (loop_num
, chrec
, new_evol
);
857 /* Merges two evolution functions that were found by following two
858 alternate paths of a conditional expression. */
861 chrec_merge (tree chrec1
,
864 if (chrec1
== chrec_dont_know
865 || chrec2
== chrec_dont_know
)
866 return chrec_dont_know
;
868 if (chrec1
== chrec_known
869 || chrec2
== chrec_known
)
872 if (chrec1
== chrec_not_analyzed_yet
)
874 if (chrec2
== chrec_not_analyzed_yet
)
877 if (eq_evolutions_p (chrec1
, chrec2
))
880 return chrec_dont_know
;
887 /* Helper function for is_multivariate_chrec. */
890 is_multivariate_chrec_rec (const_tree chrec
, unsigned int rec_var
)
892 if (chrec
== NULL_TREE
)
895 if (TREE_CODE (chrec
) == POLYNOMIAL_CHREC
)
897 if (CHREC_VARIABLE (chrec
) != rec_var
)
900 return (is_multivariate_chrec_rec (CHREC_LEFT (chrec
), rec_var
)
901 || is_multivariate_chrec_rec (CHREC_RIGHT (chrec
), rec_var
));
907 /* Determine whether the given chrec is multivariate or not. */
910 is_multivariate_chrec (const_tree chrec
)
912 if (chrec
== NULL_TREE
)
915 if (TREE_CODE (chrec
) == POLYNOMIAL_CHREC
)
916 return (is_multivariate_chrec_rec (CHREC_LEFT (chrec
),
917 CHREC_VARIABLE (chrec
))
918 || is_multivariate_chrec_rec (CHREC_RIGHT (chrec
),
919 CHREC_VARIABLE (chrec
)));
924 /* Determines whether the chrec contains symbolic names or not. */
927 chrec_contains_symbols (const_tree chrec
)
931 if (chrec
== NULL_TREE
)
934 if (TREE_CODE (chrec
) == SSA_NAME
935 || TREE_CODE (chrec
) == VAR_DECL
936 || TREE_CODE (chrec
) == PARM_DECL
937 || TREE_CODE (chrec
) == FUNCTION_DECL
938 || TREE_CODE (chrec
) == LABEL_DECL
939 || TREE_CODE (chrec
) == RESULT_DECL
940 || TREE_CODE (chrec
) == FIELD_DECL
)
943 n
= TREE_OPERAND_LENGTH (chrec
);
944 for (i
= 0; i
< n
; i
++)
945 if (chrec_contains_symbols (TREE_OPERAND (chrec
, i
)))
950 /* Determines whether the chrec contains undetermined coefficients. */
953 chrec_contains_undetermined (const_tree chrec
)
957 if (chrec
== chrec_dont_know
)
960 if (chrec
== NULL_TREE
)
963 n
= TREE_OPERAND_LENGTH (chrec
);
964 for (i
= 0; i
< n
; i
++)
965 if (chrec_contains_undetermined (TREE_OPERAND (chrec
, i
)))
970 /* Determines whether the tree EXPR contains chrecs, and increment
971 SIZE if it is not a NULL pointer by an estimation of the depth of
975 tree_contains_chrecs (const_tree expr
, int *size
)
979 if (expr
== NULL_TREE
)
985 if (tree_is_chrec (expr
))
988 n
= TREE_OPERAND_LENGTH (expr
);
989 for (i
= 0; i
< n
; i
++)
990 if (tree_contains_chrecs (TREE_OPERAND (expr
, i
), size
))
995 /* Recursive helper function. */
998 evolution_function_is_invariant_rec_p (tree chrec
, int loopnum
)
1000 if (evolution_function_is_constant_p (chrec
))
1003 if (TREE_CODE (chrec
) == SSA_NAME
1005 || expr_invariant_in_loop_p (get_loop (cfun
, loopnum
), chrec
)))
1008 if (TREE_CODE (chrec
) == POLYNOMIAL_CHREC
)
1010 if (CHREC_VARIABLE (chrec
) == (unsigned) loopnum
1011 || flow_loop_nested_p (get_loop (cfun
, loopnum
),
1012 get_chrec_loop (chrec
))
1013 || !evolution_function_is_invariant_rec_p (CHREC_RIGHT (chrec
),
1015 || !evolution_function_is_invariant_rec_p (CHREC_LEFT (chrec
),
1021 switch (TREE_OPERAND_LENGTH (chrec
))
1024 if (!evolution_function_is_invariant_rec_p (TREE_OPERAND (chrec
, 1),
1029 if (!evolution_function_is_invariant_rec_p (TREE_OPERAND (chrec
, 0),
1041 /* Return true if CHREC is invariant in loop LOOPNUM, false otherwise. */
1044 evolution_function_is_invariant_p (tree chrec
, int loopnum
)
1046 return evolution_function_is_invariant_rec_p (chrec
, loopnum
);
1049 /* Determine whether the given tree is an affine multivariate
1053 evolution_function_is_affine_multivariate_p (const_tree chrec
, int loopnum
)
1055 if (chrec
== NULL_TREE
)
1058 switch (TREE_CODE (chrec
))
1060 case POLYNOMIAL_CHREC
:
1061 if (evolution_function_is_invariant_rec_p (CHREC_LEFT (chrec
), loopnum
))
1063 if (evolution_function_is_invariant_rec_p (CHREC_RIGHT (chrec
), loopnum
))
1067 if (TREE_CODE (CHREC_RIGHT (chrec
)) == POLYNOMIAL_CHREC
1068 && CHREC_VARIABLE (CHREC_RIGHT (chrec
))
1069 != CHREC_VARIABLE (chrec
)
1070 && evolution_function_is_affine_multivariate_p
1071 (CHREC_RIGHT (chrec
), loopnum
))
1079 if (evolution_function_is_invariant_rec_p (CHREC_RIGHT (chrec
), loopnum
)
1080 && TREE_CODE (CHREC_LEFT (chrec
)) == POLYNOMIAL_CHREC
1081 && CHREC_VARIABLE (CHREC_LEFT (chrec
)) != CHREC_VARIABLE (chrec
)
1082 && evolution_function_is_affine_multivariate_p
1083 (CHREC_LEFT (chrec
), loopnum
))
1094 /* Determine whether the given tree is a function in zero or one
1098 evolution_function_is_univariate_p (const_tree chrec
)
1100 if (chrec
== NULL_TREE
)
1103 switch (TREE_CODE (chrec
))
1105 case POLYNOMIAL_CHREC
:
1106 switch (TREE_CODE (CHREC_LEFT (chrec
)))
1108 case POLYNOMIAL_CHREC
:
1109 if (CHREC_VARIABLE (chrec
) != CHREC_VARIABLE (CHREC_LEFT (chrec
)))
1111 if (!evolution_function_is_univariate_p (CHREC_LEFT (chrec
)))
1116 if (tree_contains_chrecs (CHREC_LEFT (chrec
), NULL
))
1121 switch (TREE_CODE (CHREC_RIGHT (chrec
)))
1123 case POLYNOMIAL_CHREC
:
1124 if (CHREC_VARIABLE (chrec
) != CHREC_VARIABLE (CHREC_RIGHT (chrec
)))
1126 if (!evolution_function_is_univariate_p (CHREC_RIGHT (chrec
)))
1131 if (tree_contains_chrecs (CHREC_RIGHT (chrec
), NULL
))
1141 /* Returns the number of variables of CHREC. Example: the call
1142 nb_vars_in_chrec ({{0, +, 1}_5, +, 2}_6) returns 2. */
1145 nb_vars_in_chrec (tree chrec
)
1147 if (chrec
== NULL_TREE
)
1150 switch (TREE_CODE (chrec
))
1152 case POLYNOMIAL_CHREC
:
1153 return 1 + nb_vars_in_chrec
1154 (initial_condition_in_loop_num (chrec
, CHREC_VARIABLE (chrec
)));
1161 static tree
chrec_convert_1 (tree
, tree
, gimple
, bool);
1163 /* Converts BASE and STEP of affine scev to TYPE. LOOP is the loop whose iv
1164 the scev corresponds to. AT_STMT is the statement at that the scev is
1165 evaluated. USE_OVERFLOW_SEMANTICS is true if this function should assume that
1166 the rules for overflow of the given language apply (e.g., that signed
1167 arithmetics in C does not overflow) -- i.e., to use them to avoid unnecessary
1168 tests, but also to enforce that the result follows them. Returns true if the
1169 conversion succeeded, false otherwise. */
1172 convert_affine_scev (struct loop
*loop
, tree type
,
1173 tree
*base
, tree
*step
, gimple at_stmt
,
1174 bool use_overflow_semantics
)
1176 tree ct
= TREE_TYPE (*step
);
1177 bool enforce_overflow_semantics
;
1178 bool must_check_src_overflow
, must_check_rslt_overflow
;
1179 tree new_base
, new_step
;
1180 tree step_type
= POINTER_TYPE_P (type
) ? sizetype
: type
;
1183 (TYPE) (BASE + STEP * i) = (TYPE) BASE + (TYPE -- sign extend) STEP * i,
1184 but we must check some assumptions.
1186 1) If [BASE, +, STEP] wraps, the equation is not valid when precision
1187 of CT is smaller than the precision of TYPE. For example, when we
1188 cast unsigned char [254, +, 1] to unsigned, the values on left side
1189 are 254, 255, 0, 1, ..., but those on the right side are
1190 254, 255, 256, 257, ...
1191 2) In case that we must also preserve the fact that signed ivs do not
1192 overflow, we must additionally check that the new iv does not wrap.
1193 For example, unsigned char [125, +, 1] casted to signed char could
1194 become a wrapping variable with values 125, 126, 127, -128, -127, ...,
1195 which would confuse optimizers that assume that this does not
1197 must_check_src_overflow
= TYPE_PRECISION (ct
) < TYPE_PRECISION (type
);
1199 enforce_overflow_semantics
= (use_overflow_semantics
1200 && nowrap_type_p (type
));
1201 if (enforce_overflow_semantics
)
1203 /* We can avoid checking whether the result overflows in the following
1206 -- must_check_src_overflow is true, and the range of TYPE is superset
1207 of the range of CT -- i.e., in all cases except if CT signed and
1209 -- both CT and TYPE have the same precision and signedness, and we
1210 verify instead that the source does not overflow (this may be
1211 easier than verifying it for the result, as we may use the
1212 information about the semantics of overflow in CT). */
1213 if (must_check_src_overflow
)
1215 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (ct
))
1216 must_check_rslt_overflow
= true;
1218 must_check_rslt_overflow
= false;
1220 else if (TYPE_UNSIGNED (ct
) == TYPE_UNSIGNED (type
)
1221 && TYPE_PRECISION (ct
) == TYPE_PRECISION (type
))
1223 must_check_rslt_overflow
= false;
1224 must_check_src_overflow
= true;
1227 must_check_rslt_overflow
= true;
1230 must_check_rslt_overflow
= false;
1232 if (must_check_src_overflow
1233 && scev_probably_wraps_p (*base
, *step
, at_stmt
, loop
,
1234 use_overflow_semantics
))
1237 new_base
= chrec_convert_1 (type
, *base
, at_stmt
,
1238 use_overflow_semantics
);
1239 /* The step must be sign extended, regardless of the signedness
1240 of CT and TYPE. This only needs to be handled specially when
1241 CT is unsigned -- to avoid e.g. unsigned char [100, +, 255]
1242 (with values 100, 99, 98, ...) from becoming signed or unsigned
1243 [100, +, 255] with values 100, 355, ...; the sign-extension is
1244 performed by default when CT is signed. */
1246 if (TYPE_PRECISION (step_type
) > TYPE_PRECISION (ct
) && TYPE_UNSIGNED (ct
))
1248 tree signed_ct
= build_nonstandard_integer_type (TYPE_PRECISION (ct
), 0);
1249 new_step
= chrec_convert_1 (signed_ct
, new_step
, at_stmt
,
1250 use_overflow_semantics
);
1252 new_step
= chrec_convert_1 (step_type
, new_step
, at_stmt
, use_overflow_semantics
);
1254 if (automatically_generated_chrec_p (new_base
)
1255 || automatically_generated_chrec_p (new_step
))
1258 if (must_check_rslt_overflow
1259 /* Note that in this case we cannot use the fact that signed variables
1260 do not overflow, as this is what we are verifying for the new iv. */
1261 && scev_probably_wraps_p (new_base
, new_step
, at_stmt
, loop
, false))
1270 /* Convert CHREC for the right hand side of a CHREC.
1271 The increment for a pointer type is always sizetype. */
1274 chrec_convert_rhs (tree type
, tree chrec
, gimple at_stmt
)
1276 if (POINTER_TYPE_P (type
))
1279 return chrec_convert (type
, chrec
, at_stmt
);
1282 /* Convert CHREC to TYPE. When the analyzer knows the context in
1283 which the CHREC is built, it sets AT_STMT to the statement that
1284 contains the definition of the analyzed variable, otherwise the
1285 conversion is less accurate: the information is used for
1286 determining a more accurate estimation of the number of iterations.
1287 By default AT_STMT could be safely set to NULL_TREE.
1289 The following rule is always true: TREE_TYPE (chrec) ==
1290 TREE_TYPE (CHREC_LEFT (chrec)) == TREE_TYPE (CHREC_RIGHT (chrec)).
1291 An example of what could happen when adding two chrecs and the type
1292 of the CHREC_RIGHT is different than CHREC_LEFT is:
1294 {(uint) 0, +, (uchar) 10} +
1295 {(uint) 0, +, (uchar) 250}
1297 that would produce a wrong result if CHREC_RIGHT is not (uint):
1299 {(uint) 0, +, (uchar) 4}
1303 {(uint) 0, +, (uint) 260}
1307 chrec_convert (tree type
, tree chrec
, gimple at_stmt
)
1309 return chrec_convert_1 (type
, chrec
, at_stmt
, true);
1312 /* Convert CHREC to TYPE. When the analyzer knows the context in
1313 which the CHREC is built, it sets AT_STMT to the statement that
1314 contains the definition of the analyzed variable, otherwise the
1315 conversion is less accurate: the information is used for
1316 determining a more accurate estimation of the number of iterations.
1317 By default AT_STMT could be safely set to NULL_TREE.
1319 USE_OVERFLOW_SEMANTICS is true if this function should assume that
1320 the rules for overflow of the given language apply (e.g., that signed
1321 arithmetics in C does not overflow) -- i.e., to use them to avoid unnecessary
1322 tests, but also to enforce that the result follows them. */
1325 chrec_convert_1 (tree type
, tree chrec
, gimple at_stmt
,
1326 bool use_overflow_semantics
)
1332 if (automatically_generated_chrec_p (chrec
))
1335 ct
= chrec_type (chrec
);
1339 if (!evolution_function_is_affine_p (chrec
))
1342 loop
= get_chrec_loop (chrec
);
1343 base
= CHREC_LEFT (chrec
);
1344 step
= CHREC_RIGHT (chrec
);
1346 if (convert_affine_scev (loop
, type
, &base
, &step
, at_stmt
,
1347 use_overflow_semantics
))
1348 return build_polynomial_chrec (loop
->num
, base
, step
);
1350 /* If we cannot propagate the cast inside the chrec, just keep the cast. */
1352 /* Fold will not canonicalize (long)(i - 1) to (long)i - 1 because that
1353 may be more expensive. We do want to perform this optimization here
1354 though for canonicalization reasons. */
1355 if (use_overflow_semantics
1356 && (TREE_CODE (chrec
) == PLUS_EXPR
1357 || TREE_CODE (chrec
) == MINUS_EXPR
)
1358 && TREE_CODE (type
) == INTEGER_TYPE
1359 && TREE_CODE (ct
) == INTEGER_TYPE
1360 && TYPE_PRECISION (type
) > TYPE_PRECISION (ct
)
1361 && TYPE_OVERFLOW_UNDEFINED (ct
))
1362 res
= fold_build2 (TREE_CODE (chrec
), type
,
1363 fold_convert (type
, TREE_OPERAND (chrec
, 0)),
1364 fold_convert (type
, TREE_OPERAND (chrec
, 1)));
1365 /* Similar perform the trick that (signed char)((int)x + 2) can be
1366 narrowed to (signed char)((unsigned char)x + 2). */
1367 else if (use_overflow_semantics
1368 && TREE_CODE (chrec
) == POLYNOMIAL_CHREC
1369 && TREE_CODE (ct
) == INTEGER_TYPE
1370 && TREE_CODE (type
) == INTEGER_TYPE
1371 && TYPE_OVERFLOW_UNDEFINED (type
)
1372 && TYPE_PRECISION (type
) < TYPE_PRECISION (ct
))
1374 tree utype
= unsigned_type_for (type
);
1375 res
= build_polynomial_chrec (CHREC_VARIABLE (chrec
),
1376 fold_convert (utype
,
1377 CHREC_LEFT (chrec
)),
1378 fold_convert (utype
,
1379 CHREC_RIGHT (chrec
)));
1380 res
= chrec_convert_1 (type
, res
, at_stmt
, use_overflow_semantics
);
1383 res
= fold_convert (type
, chrec
);
1385 /* Don't propagate overflows. */
1386 if (CONSTANT_CLASS_P (res
))
1387 TREE_OVERFLOW (res
) = 0;
1389 /* But reject constants that don't fit in their type after conversion.
1390 This can happen if TYPE_MIN_VALUE or TYPE_MAX_VALUE are not the
1391 natural values associated with TYPE_PRECISION and TYPE_UNSIGNED,
1392 and can cause problems later when computing niters of loops. Note
1393 that we don't do the check before converting because we don't want
1394 to reject conversions of negative chrecs to unsigned types. */
1395 if (TREE_CODE (res
) == INTEGER_CST
1396 && TREE_CODE (type
) == INTEGER_TYPE
1397 && !int_fits_type_p (res
, type
))
1398 res
= chrec_dont_know
;
1403 /* Convert CHREC to TYPE, without regard to signed overflows. Returns the new
1404 chrec if something else than what chrec_convert would do happens, NULL_TREE
1408 chrec_convert_aggressive (tree type
, tree chrec
)
1410 tree inner_type
, left
, right
, lc
, rc
, rtype
;
1412 if (automatically_generated_chrec_p (chrec
)
1413 || TREE_CODE (chrec
) != POLYNOMIAL_CHREC
)
1416 inner_type
= TREE_TYPE (chrec
);
1417 if (TYPE_PRECISION (type
) > TYPE_PRECISION (inner_type
))
1420 rtype
= POINTER_TYPE_P (type
) ? sizetype
: type
;
1422 left
= CHREC_LEFT (chrec
);
1423 right
= CHREC_RIGHT (chrec
);
1424 lc
= chrec_convert_aggressive (type
, left
);
1426 lc
= chrec_convert (type
, left
, NULL
);
1427 rc
= chrec_convert_aggressive (rtype
, right
);
1429 rc
= chrec_convert (rtype
, right
, NULL
);
1431 return build_polynomial_chrec (CHREC_VARIABLE (chrec
), lc
, rc
);
1434 /* Returns true when CHREC0 == CHREC1. */
1437 eq_evolutions_p (const_tree chrec0
, const_tree chrec1
)
1439 if (chrec0
== NULL_TREE
1440 || chrec1
== NULL_TREE
1441 || TREE_CODE (chrec0
) != TREE_CODE (chrec1
))
1444 if (chrec0
== chrec1
)
1447 switch (TREE_CODE (chrec0
))
1450 return operand_equal_p (chrec0
, chrec1
, 0);
1452 case POLYNOMIAL_CHREC
:
1453 return (CHREC_VARIABLE (chrec0
) == CHREC_VARIABLE (chrec1
)
1454 && eq_evolutions_p (CHREC_LEFT (chrec0
), CHREC_LEFT (chrec1
))
1455 && eq_evolutions_p (CHREC_RIGHT (chrec0
), CHREC_RIGHT (chrec1
)));
1460 case POINTER_PLUS_EXPR
:
1461 return eq_evolutions_p (TREE_OPERAND (chrec0
, 0),
1462 TREE_OPERAND (chrec1
, 0))
1463 && eq_evolutions_p (TREE_OPERAND (chrec0
, 1),
1464 TREE_OPERAND (chrec1
, 1));
1471 /* Returns EV_GROWS if CHREC grows (assuming that it does not overflow),
1472 EV_DECREASES if it decreases, and EV_UNKNOWN if we cannot determine
1473 which of these cases happens. */
1476 scev_direction (const_tree chrec
)
1480 if (!evolution_function_is_affine_p (chrec
))
1481 return EV_DIR_UNKNOWN
;
1483 step
= CHREC_RIGHT (chrec
);
1484 if (TREE_CODE (step
) != INTEGER_CST
)
1485 return EV_DIR_UNKNOWN
;
1487 if (tree_int_cst_sign_bit (step
))
1488 return EV_DIR_DECREASES
;
1490 return EV_DIR_GROWS
;
1493 /* Iterates over all the components of SCEV, and calls CBCK. */
1496 for_each_scev_op (tree
*scev
, bool (*cbck
) (tree
*, void *), void *data
)
1498 switch (TREE_CODE_LENGTH (TREE_CODE (*scev
)))
1501 for_each_scev_op (&TREE_OPERAND (*scev
, 2), cbck
, data
);
1504 for_each_scev_op (&TREE_OPERAND (*scev
, 1), cbck
, data
);
1507 for_each_scev_op (&TREE_OPERAND (*scev
, 0), cbck
, data
);
1515 /* Returns true when the operation can be part of a linear
1519 operator_is_linear (tree scev
)
1521 switch (TREE_CODE (scev
))
1524 case POLYNOMIAL_CHREC
:
1526 case POINTER_PLUS_EXPR
:
1531 case NON_LVALUE_EXPR
:
1541 /* Return true when SCEV is a linear expression. Linear expressions
1542 can contain additions, substractions and multiplications.
1543 Multiplications are restricted to constant scaling: "cst * x". */
1546 scev_is_linear_expression (tree scev
)
1549 || !operator_is_linear (scev
))
1552 if (TREE_CODE (scev
) == MULT_EXPR
)
1553 return !(tree_contains_chrecs (TREE_OPERAND (scev
, 0), NULL
)
1554 && tree_contains_chrecs (TREE_OPERAND (scev
, 1), NULL
));
1556 if (TREE_CODE (scev
) == POLYNOMIAL_CHREC
1557 && !evolution_function_is_affine_multivariate_p (scev
, CHREC_VARIABLE (scev
)))
1560 switch (TREE_CODE_LENGTH (TREE_CODE (scev
)))
1563 return scev_is_linear_expression (TREE_OPERAND (scev
, 0))
1564 && scev_is_linear_expression (TREE_OPERAND (scev
, 1))
1565 && scev_is_linear_expression (TREE_OPERAND (scev
, 2));
1568 return scev_is_linear_expression (TREE_OPERAND (scev
, 0))
1569 && scev_is_linear_expression (TREE_OPERAND (scev
, 1));
1572 return scev_is_linear_expression (TREE_OPERAND (scev
, 0));
1582 /* Determines whether the expression CHREC contains only interger consts
1583 in the right parts. */
1586 evolution_function_right_is_integer_cst (const_tree chrec
)
1588 if (chrec
== NULL_TREE
)
1591 switch (TREE_CODE (chrec
))
1596 case POLYNOMIAL_CHREC
:
1597 return TREE_CODE (CHREC_RIGHT (chrec
)) == INTEGER_CST
1598 && (TREE_CODE (CHREC_LEFT (chrec
)) != POLYNOMIAL_CHREC
1599 || evolution_function_right_is_integer_cst (CHREC_LEFT (chrec
)));
1602 return evolution_function_right_is_integer_cst (TREE_OPERAND (chrec
, 0));