Update in V2:
> I am not sure why not create a global one?
Changed, Enable global ranger in ivopt by enable_ranger (cfun, false)
and disable_ranger (cfun). It additionally optimizes existed testcases
a). gcc.dg/tree-ssa/pr19210-1.c
Ranger also derives n <= UINT_MAX - 4 after the preceding step-4 loop
in pr19210-1.c exits, discharging the next loop niter assumption. Adjust
the diagnostic expectation.
b). gcc.target/i386/kortest_ccz-1.c: The improved IV choice simplify the
hotloop, and reduced code size.
Since the codegen is better than before, so adjust testcase for that.
> These all should be using INTEGRAL_NB_TYPE_P rather than a direct
> comparison against INTEGER_TYPE. I fixed a bunch of cases where there
> was a comparison against INTEGER_TYPE in r17-89-g78280307c78ead. The
> direct comparison against INTEGER_TYPE makes me worried this part was
> created by a LLM.
Changed, Use INTEGRAL_NB_TYPE_P instead of comparison against INTEGER_TYPE.
> Why not just use tree_nop_conversion_p here?
Changed.
> I am trying to understand what values here are being compared. Are
> you just asking if the bounds has the upper bit not set? Maybe use
> nonzero bits would be easier to deal with that instead of comparing
> the lower/upper bounds of the range.
Changed, use range_fits_type_p which should be same as
wi::neg_p (vr.get_nonzero_bits (), SIGNED)?
> Again with the direct comparison to INTEGER_TYPE.
Changed.
Bootstrapped and regstested on x86_64-pc-linux-gnu{-m32,}.
Ok for trunk?
r15-6657 canonicalized signed arithmetic to unsigned and exposed a
17.5% code-size regression at -O2 in SPEC CPU2017 507.cactuBSSN_r.
The resulting conversion chains hide common outer-loop IV terms from
affine decomposition.
Enable ranger during IVOPTS and pass the use statement to tree-affine.
Use contextual ranges to remove value-preserving sign changes and fold
modular arithmetic into exact arithmetic. Keep candidate computations
context-free because they may be emitted in the loop preheader.
Ranger also derives n <= UINT_MAX - 4 after the preceding step-4 loop
in pr19210-1.c exits, discharging the next loop niter assumption. Adjust
the diagnostic expectation.
On ia32, the improved IV choice can spill a loop bound through a mask
register while still reducing code size and hot-loop work. Restrict the
unrelated no-kmov check to non-ia32 targets.
.i.e
inv_expr 3: ((unsigned long) k_41 * 8 + (unsigned long)\
input_array_dims_28(D)) - (unsigned long) (int) ((unsigned int k_41 +\
4294967295) * 8
Can be simplified to
(unsigned long) input_array_dims_28(D) + 8
When ranger proves k_41 >= 1
The fix slightly improves 507.cactuBSSN_r performance and improves
548.exchange2_r by about 6% on Intel GNR, AMD Zen 5, and Arm Graviton
5.
gcc/ChangeLog:
PR tree-optimization/126486
* tree-affine.cc: Include vr-values.h.
(aff_combination_convert): Accept and propagate range context.
(expr_to_aff_combination): Likewise. Fold sign-changing conversions
and negative unsigned offsets.
(tree_to_aff_combination): Accept and propagate range context.
* tree-affine.h (aff_combination_convert): Update declaration.
(tree_to_aff_combination): Likewise.
* tree-ssa-loop-ivopts.cc: Include gimple-range.h.
(get_computation_aff_1): Pass the use statement.
(tree_ssa_iv_optimize): Enable ranger.
gcc/testsuite/ChangeLog:
PR tree-optimization/126486
* gcc.dg/tree-ssa/pr126486.c: New test.
* gcc.dg/tree-ssa/pr19210-1.c: Remove obsolete missed diagnostic.
* gcc.target/i386/kortest_ccz-1.c: Restrict no-kmov scan to non-ia32.
Assisted-by: openai.gpt-5.6-sol xhigh <[email protected]>
---
gcc/testsuite/gcc.dg/tree-ssa/pr126486.c | 43 +++++
gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c | 4 +-
gcc/testsuite/gcc.target/i386/kortest_ccz-1.c | 2 +-
gcc/tree-affine.cc | 177 +++++++++++++++---
gcc/tree-affine.h | 4 +-
gcc/tree-ssa-loop-ivopts.cc | 15 +-
6 files changed, 205 insertions(+), 40 deletions(-)
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr126486.c
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr126486.c
b/gcc/testsuite/gcc.dg/tree-ssa/pr126486.c
new file mode 100644
index 00000000000..201366dc1f3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr126486.c
@@ -0,0 +1,43 @@
+/* PR tree-optimization/126486 */
+/* { dg-do run { target lp64 } } */
+/* { dg-options "-O2 -fdump-tree-ivopts-details" } */
+
+__attribute__((noipa))
+int
+foo (int n_dims, int *actual_indices, const long *input_array_dims,
+ int max_iter)
+{
+ int sum = 0;
+ int iter = 0;
+
+ while (iter < max_iter)
+ {
+ sum = actual_indices[0];
+ for (int k = n_dims - 1; k > 0; k--)
+ {
+ int product = 1;
+ for (int j = k - 1; j >= 0; j--)
+ product *= input_array_dims[j];
+ sum += actual_indices[k] * product;
+ }
+ iter++;
+ }
+ return sum;
+}
+
+int
+main (void)
+{
+ int actual_indices[] = { 1, 2, 3 };
+ long input_array_dims[] = { 4, 5, 6 };
+
+ if (foo (3, actual_indices, input_array_dims, 2) != 69)
+ __builtin_abort ();
+ return 0;
+}
+
+/* The common N_DIMS term should cancel. */
+/* { dg-final { scan-tree-dump-times "inv_expr \[0-9\]+:\[^\n\]*\\(signed
long\\) input_array_dims_\[0-9\]+\\(D\\) \\+ 8" 1 "ivopts" } } */
+
+/* The unsigned K - 1 term should cancel. */
+/* { dg-final { scan-tree-dump-not "inv_expr \[0-9\]+:\[^\n\]*\\(unsigned
int\\) k_\[0-9\]+ \\+ 4294967295" "ivopts" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c
b/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c
index b9e40e964c1..5c8e7d77f67 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c
@@ -20,8 +20,8 @@ f (unsigned n)
for(k = 5;k <= n;k += 5)
g();
- /* So we need the following loop, instead. */
- for(k = 4;k <= n;k += 5) /* { dg-missed "missed loop optimization: niters
analysis .*" } */
+ /* Ranger can also discharge the assumptions for this loop. */
+ for(k = 4;k <= n;k += 5)
g();
for(k = 15;k >= n;k--) /* { dg-missed "missed loop optimization: niters
analysis .*" } */
diff --git a/gcc/testsuite/gcc.target/i386/kortest_ccz-1.c
b/gcc/testsuite/gcc.target/i386/kortest_ccz-1.c
index b3cf5b803fb..e7a1e035c97 100644
--- a/gcc/testsuite/gcc.target/i386/kortest_ccz-1.c
+++ b/gcc/testsuite/gcc.target/i386/kortest_ccz-1.c
@@ -1,6 +1,6 @@
/* { dg-do compile } */
/* { dg-options "-march=x86-64-v4 -O3" } */
-/* { dg-final { scan-assembler-not "kmov" } } */
+/* { dg-final { scan-assembler-not "kmov" { target { ! ia32 } } } } */
/* { dg-final { scan-assembler "kortest" } } */
int
diff --git a/gcc/tree-affine.cc b/gcc/tree-affine.cc
index 181fd6fb33c..ad2c80ee8e3 100644
--- a/gcc/tree-affine.cc
+++ b/gcc/tree-affine.cc
@@ -32,6 +32,7 @@ along with GCC; see the file COPYING3. If not see
#include "dumpfile.h"
#include "cfgexpand.h"
#include "value-query.h"
+#include "vr-values.h"
/* Extends CST as appropriate for the affine combinations COMB. */
@@ -218,10 +219,10 @@ aff_combination_add (aff_tree *comb1, aff_tree *comb2)
aff_combination_add_elt (comb1, comb2->rest, 1);
}
-/* Converts affine combination COMB to TYPE. */
+/* Converts affine combination COMB to TYPE. AT is the range-query context.
*/
void
-aff_combination_convert (aff_tree *comb, tree type)
+aff_combination_convert (aff_tree *comb, tree type, gimple *at)
{
unsigned i, j;
tree comb_type = comb->type;
@@ -229,7 +230,7 @@ aff_combination_convert (aff_tree *comb, tree type)
if (TYPE_PRECISION (type) > TYPE_PRECISION (comb_type))
{
tree val = fold_convert (type, aff_combination_to_tree (comb));
- tree_to_aff_combination (val, type, comb);
+ tree_to_aff_combination (val, type, comb, at);
return;
}
@@ -260,27 +261,28 @@ aff_combination_convert (aff_tree *comb, tree type)
}
}
-/* Tries to handle OP0 CODE OP1 as affine combination of parts. Returns
- true when that was successful and returns the combination in COMB. */
+/* Tries to handle OP0 CODE OP1 as affine combination of parts. AT is the
+ range-query context. Returns true when that was successful and returns the
+ combination in COMB. */
static bool
expr_to_aff_combination (aff_tree *comb, tree_code code, tree type,
- tree op0, tree op1 = NULL_TREE)
+ tree op0, tree op1 = NULL_TREE, gimple *at = NULL)
{
aff_tree tmp;
switch (code)
{
case POINTER_PLUS_EXPR:
- tree_to_aff_combination (op0, type, comb);
- tree_to_aff_combination (op1, sizetype, &tmp);
+ tree_to_aff_combination (op0, type, comb, at);
+ tree_to_aff_combination (op1, sizetype, &tmp, at);
aff_combination_add (comb, &tmp);
return true;
case PLUS_EXPR:
case MINUS_EXPR:
- tree_to_aff_combination (op0, type, comb);
- tree_to_aff_combination (op1, type, &tmp);
+ tree_to_aff_combination (op0, type, comb, at);
+ tree_to_aff_combination (op1, type, &tmp, at);
if (code == MINUS_EXPR)
aff_combination_scale (&tmp, -1);
aff_combination_add (comb, &tmp);
@@ -289,18 +291,18 @@ expr_to_aff_combination (aff_tree *comb, tree_code code,
tree type,
case MULT_EXPR:
if (TREE_CODE (op1) != INTEGER_CST)
break;
- tree_to_aff_combination (op0, type, comb);
+ tree_to_aff_combination (op0, type, comb, at);
aff_combination_scale (comb, wi::to_widest (op1));
return true;
case NEGATE_EXPR:
- tree_to_aff_combination (op0, type, comb);
+ tree_to_aff_combination (op0, type, comb, at);
aff_combination_scale (comb, -1);
return true;
case BIT_NOT_EXPR:
/* ~x = -x - 1 */
- tree_to_aff_combination (op0, type, comb);
+ tree_to_aff_combination (op0, type, comb, at);
aff_combination_scale (comb, -1);
aff_combination_add_cst (comb, -1);
return true;
@@ -315,15 +317,107 @@ expr_to_aff_combination (aff_tree *comb, tree_code code,
tree type,
/* STRIP_NOPS */
if (tree_nop_conversion_p (otype, itype))
{
- tree_to_aff_combination (op0, type, comb);
+ tree_to_aff_combination (op0, type, comb, at);
return true;
}
+ /* Look through (OTYPE) (ITYPE) IOP. ITYPE and IOTYPE have the
+ same precision and differ at most in signedness. */
+ if (INTEGRAL_NB_TYPE_P (otype)
+ && INTEGRAL_NB_TYPE_P (itype)
+ && TYPE_PRECISION (otype) > TYPE_PRECISION (itype)
+ && CONVERT_EXPR_P (inner))
+ {
+ tree iop = TREE_OPERAND (inner, 0);
+ tree iotype = TREE_TYPE (iop);
+ tree_code wcode = TREE_CODE (iop);
+
+ if (INTEGRAL_NB_TYPE_P (iotype)
+ && tree_nop_conversion_p (itype, iotype))
+ {
+ int_range_max vr;
+ range_query *query = get_range_query (cfun);
+
+ /* Distribute the conversions when the operation fits ITYPE:
+ (OTYPE) (ITYPE) ((IOTYPE) X +- CST)
+ ->
+ (OTYPE) (ITYPE) (IOTYPE) X +- (OTYPE) (ITYPE) CST.
+
+ (OTYPE)(ITYPE) (IOTYPE) X will be further simplified to
+ (OTYPE) X when X fits ITYPE.
+
+ So eventually the simplification is like
+ (OTYPE) (ITYPE) ((IOTYPE) X + CST)
+ ->
+ (OTYPE) X + (OTYPE) (ITYPE) CST.
+ This is used to handle the complicated convert chain which
+ is created by unsigned canonicalization in IVOPTS, the
+ canonicalization itself is used to detect more equality
+ for iv, so handle the redundancy here. */
+
+ if (!TYPE_UNSIGNED (itype)
+ && TYPE_UNSIGNED (iotype)
+ && (wcode == PLUS_EXPR || wcode == MINUS_EXPR)
+ && TREE_CODE (TREE_OPERAND (iop, 1)) == INTEGER_CST)
+ {
+ tree wop0 = fold_convert (itype, TREE_OPERAND (iop, 0));
+ tree wop1 = fold_convert (itype, TREE_OPERAND (iop, 1));
+
+ if (query->range_of_expr (vr, wop0, at)
+ && !vr.varying_p ()
+ && !vr.undefined_p ())
+ {
+ wi::overflow_type ovf1 = wi::OVF_NONE;
+ wi::overflow_type ovf2 = wi::OVF_NONE;
+ wide_int cst = wi::to_wide (wop1);
+
+ /* IOP has wrapping type IOTYPE, so check signed
+ overflow explicitly. */
+ if (wcode == PLUS_EXPR)
+ {
+ wi::add (vr.lower_bound (), cst, SIGNED, &ovf1);
+ wi::add (vr.upper_bound (), cst, SIGNED, &ovf2);
+ }
+ else
+ {
+ wi::sub (vr.lower_bound (), cst, SIGNED, &ovf1);
+ wi::sub (vr.upper_bound (), cst, SIGNED, &ovf2);
+ }
+
+ if (ovf1 == wi::OVF_NONE && ovf2 == wi::OVF_NONE)
+ {
+ wop0 = fold_convert (otype, wop0);
+ wop1 = fold_convert (otype, wop1);
+ return expr_to_aff_combination (comb, wcode, otype,
+ wop0, wop1, at);
+ }
+ }
+ }
+
+ /* Strip the inner conversion when IOP fits ITYPE:
+ (OTYPE) (ITYPE) IOP -> (OTYPE) IOP.
+
+ (unsigned long) (int) (unsigned) k is simplified to
+ (unsigned long) k when we know k >= 0. */
+ if (TYPE_SIGN (itype) == TYPE_SIGN (iotype)
+ || (TREE_CODE (iop) == INTEGER_CST
+ ? int_fits_type_p (iop, itype)
+ : (query->range_of_expr (vr, iop, at)
+ && range_fits_type_p (&vr, TYPE_PRECISION (itype),
+ TYPE_SIGN (itype)))))
+ {
+ tree_to_aff_combination (fold_convert (otype, iop), type,
+ comb, at);
+ return true;
+ }
+ }
+ }
+
/* In principle this is a valid folding, but it isn't necessarily
an optimization, so do it here and not in fold_unary. */
if ((icode == PLUS_EXPR || icode == MINUS_EXPR || icode == MULT_EXPR)
- && TREE_CODE (itype) == INTEGER_TYPE
- && TREE_CODE (otype) == INTEGER_TYPE
+ && INTEGRAL_NB_TYPE_P (itype)
+ && INTEGRAL_NB_TYPE_P (otype)
&& TYPE_PRECISION (otype) > TYPE_PRECISION (itype))
{
tree op0 = TREE_OPERAND (inner, 0), op1 = TREE_OPERAND (inner, 1);
@@ -338,7 +432,8 @@ expr_to_aff_combination (aff_tree *comb, tree_code code,
tree type,
{
op0 = fold_convert (otype, op0);
op1 = fold_convert (otype, op1);
- return expr_to_aff_combination (comb, icode, otype, op0, op1);
+ return expr_to_aff_combination (comb, icode, otype, op0, op1,
+ at);
}
wide_int minv, maxv;
/* If inner type has wrapping overflow behavior, fold conversion
@@ -349,7 +444,7 @@ expr_to_aff_combination (aff_tree *comb, tree_code code,
tree type,
if (TYPE_UNSIGNED (itype)
&& TYPE_OVERFLOW_WRAPS (itype)
&& TREE_CODE (op1) == INTEGER_CST
- && get_range_query (cfun)->range_of_expr (vr, op0)
+ && get_range_query (cfun)->range_of_expr (vr, op0, at)
&& !vr.varying_p ()
&& !vr.undefined_p ())
{
@@ -369,7 +464,26 @@ expr_to_aff_combination (aff_tree *comb, tree_code code,
tree type,
op0 = fold_convert (otype, op0);
op1 = fold_convert (otype, op1);
return expr_to_aff_combination (comb, icode, otype, op0,
- op1);
+ op1, at);
+ }
+ /* A negative offset can be handled as an exact subtraction:
+ (T1) (X + CST) -> (T1) X - (T1) -CST.
+
+ This rewrites (int) ((unsigned int) k + UINT_MAX) to
+ (int) k - 1 when k is known >= 1. */
+ else if (icode == PLUS_EXPR
+ && wi::neg_p (wi::to_wide (op1), SIGNED))
+ {
+ wide_int pos_cst = wi::neg (wi::to_wide (op1));
+
+ if (wi::geu_p (minv, pos_cst))
+ {
+ op0 = fold_convert (otype, op0);
+ op1 = fold_convert (otype,
+ wide_int_to_tree (itype, pos_cst));
+ return expr_to_aff_combination (comb, MINUS_EXPR,
+ otype, op0, op1, at);
+ }
}
}
}
@@ -382,10 +496,11 @@ expr_to_aff_combination (aff_tree *comb, tree_code code,
tree type,
return false;
}
-/* Splits EXPR into an affine combination of parts. */
+/* Splits EXPR into an affine combination of parts. AT is the range-query
+ context. */
void
-tree_to_aff_combination (tree expr, tree type, aff_tree *comb)
+tree_to_aff_combination (tree expr, tree type, aff_tree *comb, gimple *at)
{
aff_tree tmp;
enum tree_code code;
@@ -404,13 +519,14 @@ tree_to_aff_combination (tree expr, tree type, aff_tree
*comb)
case MINUS_EXPR:
case MULT_EXPR:
if (expr_to_aff_combination (comb, code, type, TREE_OPERAND (expr, 0),
- TREE_OPERAND (expr, 1)))
+ TREE_OPERAND (expr, 1), at))
return;
break;
case NEGATE_EXPR:
case BIT_NOT_EXPR:
- if (expr_to_aff_combination (comb, code, type, TREE_OPERAND (expr, 0)))
+ if (expr_to_aff_combination (comb, code, type, TREE_OPERAND (expr, 0),
+ NULL_TREE, at))
return;
break;
@@ -418,9 +534,10 @@ tree_to_aff_combination (tree expr, tree type, aff_tree
*comb)
/* ??? TREE_TYPE (expr) should be equal to type here, but IVOPTS
calls this with not showing an outer widening cast. */
if (expr_to_aff_combination (comb, code,
- TREE_TYPE (expr), TREE_OPERAND (expr, 0)))
+ TREE_TYPE (expr), TREE_OPERAND (expr, 0),
+ NULL_TREE, at))
{
- aff_combination_convert (comb, type);
+ aff_combination_convert (comb, type, at);
return;
}
break;
@@ -430,8 +547,9 @@ tree_to_aff_combination (tree expr, tree type, aff_tree
*comb)
if (TREE_CODE (TREE_OPERAND (expr, 0)) == MEM_REF)
{
expr = TREE_OPERAND (expr, 0);
- tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb);
- tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp);
+ tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb, at);
+ tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp,
+ at);
aff_combination_add (comb, &tmp);
return;
}
@@ -454,12 +572,12 @@ tree_to_aff_combination (tree expr, tree type, aff_tree
*comb)
aff_combination_add_elt (comb, core, 1);
else
{
- tree_to_aff_combination (core, type, &tmp);
+ tree_to_aff_combination (core, type, &tmp, at);
aff_combination_add (comb, &tmp);
}
if (toffset)
{
- tree_to_aff_combination (toffset, type, &tmp);
+ tree_to_aff_combination (toffset, type, &tmp, at);
aff_combination_add (comb, &tmp);
}
return;
@@ -1065,4 +1183,3 @@ aff_comb_cannot_overlap_p (aff_tree *diff, const
poly_widest_int &size1,
return known_le (size1, diff->offset);
}
}
-
diff --git a/gcc/tree-affine.h b/gcc/tree-affine.h
index 38d32ef1b4b..44ed0053209 100644
--- a/gcc/tree-affine.h
+++ b/gcc/tree-affine.h
@@ -73,8 +73,8 @@ void aff_combination_mult (aff_tree *, aff_tree *, aff_tree
*);
void aff_combination_add (aff_tree *, aff_tree *);
void aff_combination_add_elt (aff_tree *, tree, const widest_int &);
void aff_combination_remove_elt (aff_tree *, unsigned);
-void aff_combination_convert (aff_tree *, tree);
-void tree_to_aff_combination (tree, tree, aff_tree *);
+void aff_combination_convert (aff_tree *, tree, gimple * = NULL);
+void tree_to_aff_combination (tree, tree, aff_tree *, gimple * = NULL);
tree aff_combination_to_tree (aff_tree *);
void unshare_aff_combination (aff_tree *);
bool aff_combination_constant_multiple_p (aff_tree *, aff_tree *,
diff --git a/gcc/tree-ssa-loop-ivopts.cc b/gcc/tree-ssa-loop-ivopts.cc
index 5a4254290d8..6b5b9223203 100644
--- a/gcc/tree-ssa-loop-ivopts.cc
+++ b/gcc/tree-ssa-loop-ivopts.cc
@@ -133,6 +133,7 @@ along with GCC; see the file COPYING3. If not see
#include "dbgcnt.h"
#include "cfganal.h"
#include "gimple-fold.h"
+#include "gimple-range.h"
/* For lang_hooks.types.type_for_mode. */
#include "langhooks.h"
@@ -4037,9 +4038,9 @@ get_computation_aff_1 (struct ivopts_data *data, gimple
*at, struct iv_use *use,
common_type = determine_common_wider_type (&ubase, &cbase);
/* use = ubase - ratio * cbase + ratio * var. */
- tree_to_aff_combination (ubase, common_type, aff_inv);
- tree_to_aff_combination (cbase, common_type, &aff_cbase);
- tree_to_aff_combination (var, uutype, aff_var);
+ tree_to_aff_combination (ubase, common_type, aff_inv, at);
+ tree_to_aff_combination (cbase, common_type, &aff_cbase, at);
+ tree_to_aff_combination (var, uutype, aff_var, at);
/* We need to shift the value if we are after the increment. */
if (stmt_after_increment (data->current_loop, cand, at))
@@ -4051,14 +4052,14 @@ get_computation_aff_1 (struct ivopts_data *data, gimple
*at, struct iv_use *use,
else
cstep_common = cstep;
- tree_to_aff_combination (cstep_common, common_type, &cstep_aff);
+ tree_to_aff_combination (cstep_common, common_type, &cstep_aff, at);
aff_combination_add (&aff_cbase, &cstep_aff);
}
aff_combination_scale (&aff_cbase, -rat);
aff_combination_add (aff_inv, &aff_cbase);
if (common_type != uutype)
- aff_combination_convert (aff_inv, uutype);
+ aff_combination_convert (aff_inv, uutype, at);
aff_combination_scale (aff_var, rat);
return true;
@@ -8246,6 +8247,8 @@ tree_ssa_iv_optimize (void)
tree_ssa_iv_optimize_init (&data);
mark_ssa_maybe_undefs ();
+ enable_ranger (cfun, false);
+
/* Optimize the loops starting with the innermost ones. */
for (auto loop : loops_list (cfun, LI_FROM_INNERMOST))
{
@@ -8258,6 +8261,8 @@ tree_ssa_iv_optimize (void)
tree_ssa_iv_optimize_loop (&data, loop, toremove);
}
+ disable_ranger (cfun);
+
/* Remove eliminated IV defs. */
release_defs_bitset (toremove);
--
2.34.1
