RE: [patch v3]middle-end: Teach ranger about POLY_INT_CST ranges for VRP.

> -----Original Message-----
> From: Richard Sandiford <[email protected]>
> Sent: 20 August 2026 11:52
> To: Tamar Christina <[email protected]>
> Cc: [email protected]; nd <[email protected]>; [email protected];
> [email protected]; [email protected]; [email protected]
> Subject: Re: [patch v3]middle-end: Teach ranger about POLY_INT_CST ranges
> for VRP.
> 
> Sorry for the slow reply.
> 
> Tamar Christina <[email protected]> writes:
> > A an area where LLVM generates much better code than GCC today is in
> > optimization of VLA branches guarded by VLA constants.
> >
> > Normally in GIMPLE POLY_INT_CSTs have no upport and lower bound
> because well,
> > they're poly.  However SVE has defined minimum and maximum vector sizes
> in
> > the architecture[1] and so for us we do have bounds on these constants.
> >
> > [1] https://developer.arm.com/documentation/102476/0101/Introducing-
> SVE
> >
> > Today LLVM optimizes these simple expressions
> >
> > #include <arm_sve.h>
> >
> > int g (void)
> > {
> >   unsigned int vl = svcntb ();
> >   return vl < 257;
> > }
> >
> > int h (void)
> > {
> >   return svcntw () <= 64;
> > }
> >
> > away to
> >
> > g():
> >         mov     w0, #1
> >         ret
> >
> > h():
> >         mov     w0, #1
> >         ret
> >
> > which is right because both are always true for any SVE vector length.
> >
> > while GCC generates:
> >
> > g():
> >         cntb    x0
> >         cmp     w0, 257
> >         cset    w0, cc
> >         ret
> > h():
> >         cntw    x0
> >         cmp     x0, 65
> >         cset    w0, cc
> >         ret
> >
> > This patch extends ranger with a target hook poly_int_indeterminate_bound
> which
> > is different from the current costing only hooks used in the vectorizer
> because
> > those hooks can't be relied upon for correctness.
> >
> > This new hook allows us specify the minimum and maximum bounds of a
> POLY_INT_CST
> > and have ranger use it in range_query::get_tree_range though specifying the
> > indeterminate bound of a POLY target.
> >
> > This gets GCC to fold away many known true or known false comparisons in
> > codegen today and we generate much simpler loop pre-headers.
> >
> > I have kept the AArch64 parts in this patch to get some extra eyes on it, but
> > will split them out on commit.
> >
> > Bootstrapped Regtested on aarch64-none-linux-gnu,
> > arm-none-linux-gnueabihf, x86_64-pc-linux-gnu
> > -m32, -m64 and no issues.
> >
> > Ok for master?
> >
> > Thanks,
> > Tamar
> >
> > gcc/ChangeLog:
> >
> > 	* config/aarch64/aarch64.cc
> (aarch64_poly_int_indeterminate_bound): New.
> > 	(TARGET_POLY_INT_INDETERMINATE_BOUND ): Implement hook
> using it.
> > 	* target.def (poly_int_indeterminate_bound): New.
> > 	* doc/tm.texi.in: Document it.
> > 	* doc/tm.texi: Regenerate.
> > 	* value-query.cc (range_query::get_tree_range): Use it.
> >
> > gcc/testsuite/ChangeLog:
> >
> > 	* gcc.target/aarch64/sve/slp_12.c: Update testcases
> > 	* gcc.target/aarch64/sve/cnt_fold_7.c: New test.
> > 	* gcc.target/aarch64/sve/cnt_fold_7_run.c: New test.
> 
> This mostly LGTM, but some comments about the wide_int usage below.
> 
> > @@ -404,8 +406,98 @@ range_query::get_tree_range (vrange &r, tree expr,
> gimple *stmt,
> >        if (POLY_INT_CST_P (expr))
> >  	{
> >  	  unsigned int precision = TYPE_PRECISION (type);
> > -	  r.set_varying (type);
> > -	  r.update_bitmask ({ wi::zero (precision), get_nonzero_bits (expr) });
> > +	  signop sign = TYPE_SIGN (type);
> > +	  bool have_poly_bound = targetm.poly_int_indeterminate_bound;
> > +	  poly_uint64 indeterminate_bound;
> > +
> > +	  if (have_poly_bound)
> > +	    indeterminate_bound = targetm.poly_int_indeterminate_bound ();
> > +
> > +	  poly_wide_int val = wi::to_poly_wide (expr);
> > +	  wide_int type_min = wi::to_wide (TYPE_MIN_VALUE (type));
> > +	  wide_int type_max = wi::to_wide (TYPE_MAX_VALUE (type));
> 
> Variables should usually only be declared as "wide_int" if they specifically
> need to be written to later.  Otherwise it's best to use "auto".  The types
> returned by wi::to_wide and the like are more efficient than temporary
> wide_ints.
> 
> One of the requirements for wide_int being accepted was that using trees
> and rtxes as "wide_int-like" should have low overhead.  We tend to lose
> that in practice by using wide_int temporaries where they aren't needed.
> 

Ah I see. I always get confused here when looking at the comment in wide-int.h
but this makes sense.  Thanks.

> I know this isn't exactly hot code, but I'm going to make this point
> whenever I review wide_int stuff, since the idiom might be copied
> elsewhere.
> 

Ack.

> > +
> > +	  /* Start with the invariant part of the poly-int, then account
> > +	     for each coefficient below.
> > +
> > +	     The target hook gives a per-coefficient upper bound for the
> > +	     indeterminate.  Since those indeterminates are unsigned and
> > +	     nonnegative, a positive coefficient can only increase the upper
> > +	     bound and a negative coefficient can only decrease the lower
> > +	     bound.  The opposite bound is unaffected by that coefficient:
> > +
> > +		[A, +C] with C >= 0  => max += C * bound
> > +		[A, -C] with C >= 0  => min -= C * bound.  */
> > +	  wide_int bounds[2]
> > +	    = { wide_int::from (val.coeffs[0], precision, sign),
> > +		wide_int::from (val.coeffs[0], precision, sign) };
> 
> These wide_int::froms seem unnecessary.  val.coeffs[0] is already a
> wide_int of the right precision.
> 
> > +	  bool ovf[2] = { false, false };
> > +
> > +	  for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
> > +	    {
> > +	      wide_int coeff = wide_int::from (val.coeffs[i], precision, sign);
> 
> Similarly here.
> 
> > +	      if (wi::eq_p (coeff, 0))
> > +		continue;
> > +
> > +	      /* Select the only bound affected by this coefficient.  A
> > +		 negative coefficient contributes to the minimum and a
> positive
> > +		 coefficient contributes to the maximum.  */
> > +	      bool coeff_neg = wi::neg_p (coeff, sign);
> > +	      wide_int &bound = bounds[coeff_neg ? 0 : 1];
> > +	      bool &bound_ovf = ovf[coeff_neg ? 0 : 1];
> > +
> > +	      if (bound_ovf)
> > +		continue;
> > +
> > +	      /* A missing hook, or a -1 bound for this coefficient, means the
> > +		 indeterminate has no finite target-specific limit.  Treat that
> > +		 like an overflow of the affected bound.  */
> > +	      if (!have_poly_bound
> > +		  || indeterminate_bound.coeffs[i] == HOST_WIDE_INT_M1U)
> > +		bound_ovf = true;
> > +	      else
> > +		{
> > +		  wide_int indeterminate
> > +		    = wi::uhwi (indeterminate_bound.coeffs[i], precision);
> 
> Similarly here about not using wide_int.
> 
> > +		  wi::overflow_type mul_ovf = wi::OVF_NONE;
> > +		  wide_int term = wi::mul (coeff, indeterminate, sign,
> > +					   &mul_ovf);
> > +		  wi::overflow_type add_ovf = wi::OVF_NONE;
> > +		  bound = wi::add (bound, term, sign, &add_ovf);
> > +		  bound_ovf = (mul_ovf != wi::OVF_NONE
> > +			       || add_ovf != wi::OVF_NONE);
> > +		}
> > +
> > +	      if (TYPE_OVERFLOW_WRAPS (type) && bound_ovf)
> > +		{
> > +		  r.set_varying (type);
> > +		  return true;
> > +		}
> > +
> > +	      if (bound_ovf)
> > +		{
> > +		  if (coeff_neg)
> > +		    bounds[0] = type_min;
> > +		  else
> > +		    bounds[1] = type_max;
> > +		}
> > +	    }
> 
> I've attached the comments above in patch form since I wanted to check
> that they worked.  It's trivial stuff, so doesn't count as co-authorship.
> 

Thanks!

> > +
> > +	  if (!wi::le_p (bounds[0], bounds[1], sign))
> > +	    {
> > +	      r.set_varying (type);
> > +	      return true;
> > +	    }
> 
> Is this possible after the above?  I would hope that we could either drop
> this or turn it into an assert.  Either way is ok with me.

You're right, this is mostly a defensive check for a broken target bounds.
but an assert is 100% more appropriate.

> 
> OK with those changes, thanks.  I think the patch has been around long
> enough that more active folks would have commented by now if they wanted
> to.
> But please say if you think the above le_p is still needed.

No I think it can be an assert.  OK with you to make it that, apply your patch and
push or do you want to see the final version?

Thanks,
Tamar

> 
> Richard
> 
> > +
> > +	  irange &ir = as_a <irange> (r);
> > +	  ir.set (type, bounds[0], bounds[1]);
> > +
> > +	  /* Preserve alignment/step information that is not visible in the
> > +	     intervals.  For example, a poly-int like [8, 8] can
> > +	     only produce multiples of 8, but the interval range might be
> > +	     [8, 136], which also contains values with low bits set.  */
> > +	  ir.update_bitmask (irange_bitmask (wi::zero (precision),
> > +					     get_nonzero_bits (expr)));
> >  	  return true;
> >  	}
> >        break;
> 
> 
> diff --git a/gcc/value-query.cc b/gcc/value-query.cc
> index 53728addefc..da93aea4a14 100644
> --- a/gcc/value-query.cc
> +++ b/gcc/value-query.cc
> @@ -413,9 +413,9 @@ range_query::get_tree_range (vrange &r, tree expr,
> gimple *stmt,
>  	  if (have_poly_bound)
>  	    indeterminate_bound = targetm.poly_int_indeterminate_bound ();
> 
> -	  poly_wide_int val = wi::to_poly_wide (expr);
> -	  wide_int type_min = wi::to_wide (TYPE_MIN_VALUE (type));
> -	  wide_int type_max = wi::to_wide (TYPE_MAX_VALUE (type));
> +	  auto val = wi::to_poly_wide (expr);
> +	  auto type_min = wi::to_wide (TYPE_MIN_VALUE (type));
> +	  auto type_max = wi::to_wide (TYPE_MAX_VALUE (type));
> 
>  	  /* Start with the invariant part of the poly-int, then account
>  	     for each coefficient below.
> @@ -428,14 +428,12 @@ range_query::get_tree_range (vrange &r, tree expr,
> gimple *stmt,
> 
>  		[A, +C] with C >= 0  => max += C * bound
>  		[A, -C] with C >= 0  => min -= C * bound.  */
> -	  wide_int bounds[2]
> -	    = { wide_int::from (val.coeffs[0], precision, sign),
> -		wide_int::from (val.coeffs[0], precision, sign) };
> +	  wide_int bounds[2] = { val.coeffs[0], val.coeffs[0] };
>  	  bool ovf[2] = { false, false };
> 
>  	  for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
>  	    {
> -	      wide_int coeff = wide_int::from (val.coeffs[i], precision, sign);
> +	      const auto &coeff = val.coeffs[i];
>  	      if (wi::eq_p (coeff, 0))
>  		continue;
> 
> @@ -457,11 +455,10 @@ range_query::get_tree_range (vrange &r, tree expr,
> gimple *stmt,
>  		bound_ovf = true;
>  	      else
>  		{
> -		  wide_int indeterminate
> +		  auto indeterminate
>  		    = wi::uhwi (indeterminate_bound.coeffs[i], precision);
>  		  wi::overflow_type mul_ovf = wi::OVF_NONE;
> -		  wide_int term = wi::mul (coeff, indeterminate, sign,
> -					   &mul_ovf);
> +		  auto term = wi::mul (coeff, indeterminate, sign, &mul_ovf);
>  		  wi::overflow_type add_ovf = wi::OVF_NONE;
>  		  bound = wi::add (bound, term, sign, &add_ovf);
>  		  bound_ovf = (mul_ovf != wi::OVF_NONE