[Bug tree-optimization/126486] codesize regression by 17.5% for spec2017 507.catcuBSSN_r caused by r15-6657 with O2

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=126486

--- Comment #7 from Hongtao Liu <liuhongt at gcc dot gnu.org> ---
GCC already support similar simplication in expr_to_aff_combination

           /* If inner type has undefined overflow behavior, fold conversion
 332               for below two cases:
 333                 (T1)(X *+- CST) -> (T1)X *+- (T1)CST
 334                 (T1)(X + X)     -> (T1)X + (T1)X.  */
 335            if (TYPE_OVERFLOW_UNDEFINED (itype)
 336                && (TREE_CODE (op1) == INTEGER_CST
 337                    || (icode == PLUS_EXPR && operand_equal_p (op0, op1,
0))))
 338              {
 339                op0 = fold_convert (otype, op0);
 340                op1 = fold_convert (otype, op1);
 341                return expr_to_aff_combination (comb, icode, otype, op0,
op1);
 342              }
 343            wide_int minv, maxv;
 344            /* If inner type has wrapping overflow behavior, fold
conversion
 345               for below case:
 346                 (T1)(X *+- CST) -> (T1)X *+- (T1)CST
 347               if X *+- CST doesn't overflow by range information.  */
 348            int_range_max vr;
 349            if (TYPE_UNSIGNED (itype)
 350                && TYPE_OVERFLOW_WRAPS (itype)
 351                && TREE_CODE (op1) == INTEGER_CST
 352                && get_range_query (cfun)->range_of_expr (vr, op0)
 353                && !vr.varying_p ()
 354                && !vr.undefined_p ())
 355              {
 356                wide_int minv = vr.lower_bound ();
 357                wide_int maxv = vr.upper_bound ();
 358                wi::overflow_type overflow = wi::OVF_NONE;
 359                signop sign = UNSIGNED;
 360                if (icode == PLUS_EXPR)
 361                  wi::add (maxv, wi::to_wide (op1), sign, &overflow);
 362                else if (icode == MULT_EXPR)
 363                  wi::mul (maxv, wi::to_wide (op1), sign, &overflow);
 364                else
 365                  wi::sub (minv, wi::to_wide (op1), sign, &overflow);
 366
 367                if (overflow == wi::OVF_NONE)
 368                  {
 369                    op0 = fold_convert (otype, op0);
 370                    op1 = fold_convert (otype, op1);
 371                    return expr_to_aff_combination (comb, icode, otype,
op0,


Directly define a new simplication for (T1) (T2) ((U) X + CST) -> (T1) X + (T1)
CST doesn't work since it relies on contextual stmt info for the overflow
guarantee, but in tree-affine.c only global ranger is available.

One possible solution is supporting contextual ranger in ivopts, and passed it
down to tree-affine, simplify (T1) (T2) ((U) X + CST) when it's known there's
no overflow.