On Wed, Nov 11, 2026 at 9:08 AM Alfie Richards <[email protected]> wrote:
>
> Changes the TARGET_POLY_INT_INDETERMINATE_BOUND to be a macro instead
> of a target hook. This is to lower the cost of this operation in
> poly_int comparisons which can happen very often.
NAK. We should moving towards target hooks from target macros.
>
> Additionally, adds maybe_upper_bound and maybe_lower_bound functions for
> poly_ints, which try to calculate an upper or lower bound.
>
> Then, adds optional flags to poly_int comparisons to
> allow for the bounds of the polyint to be taken into account when
> comparing poly_int values.
>
> Note, that we cannot use the boounds unconditionally, as the comparison
> functions are used for two slightly different purposes in the code base:
>
> 1. To check if the eventual runtime values the poly_ints represent can
> statically be known to be gt or lt eachother.
> 2. To check if all the coefficients of one poly_int are strictly greater
> or less than another. For instance, to check if one unsigned poly_int
> could be subtracted from another, without underflow.
>
> Therefore, this is made an opt-in behaviour with a flag.
>
> This also imposes some type requirements on maybe_lt and related
> to make the types all work.
>
> gcc/ChangeLog:
>
> * config/aarch64/aarch64-modes.def (POLY_INT_INDETERMINATE_BOUND):
> New macro definition.
> * config/aarch64/aarch64.cc (aarch64_poly_int_indeterminate_bound):
> Remove.
> (TARGET_POLY_INT_INDETERMINATE_BOUND): Remove.
> * doc/tm.texi (TARGET_POLY_INT_INDETERMINATE_BOUND): Remove.
> * doc/tm.texi.in (TARGET_POLY_INT_INDETERMINATE_BOUND): Remove.
> * genmodes.cc (POLY_INT_INDETERMINATE_BOUND): Add default value
> of POLY_INT_INDETERMINATE_BOUND macro.
> * poly-int.h (maybe_upper_bound): New function.
> (maybe_lower_bound): Likewise.
> (maybe_le): Update to have extra flag to optionally use bound
> information for comparison.
> (maybe_lt): Likewise.
> (maybe_ge): Likewise.
> (maybe_gt): Likewise.
> (known_le): Likewise.
> (known_lt): Likewise.
> (known_gt): Likewise.
> (known_ge): Likewise.
> (ordered_p): Likewise.
> (ordered_min): Likewise.
> (ordered_max): Likewise.
> * target.def (poly_int_indeterminate_bound): Remove.
> * gimple-fold.cc (gimple_fold_builtin_memory_op): Change types
> of poly_int comparison arguments to be compatible.
> * emit-rtl.cc (widen_memory_access): Likewise.
> * alias.cc (ao_ref_from_mem): Likewise.
> * ipa-modref-tree.cc (modref_access_node::contains): Likewise.
> * tree-ssa-alias.cc (indirect_ref_may_alias_decl_p): Likewise.
> (indirect_refs_may_alias_p): Likewise.
> * tree-ssa-sccvn.cc (vn_reference_lookup_3): Likewise.
> * tree-vect-data-refs.cc (vect_compile_time_alias): Likewise.
> * value-query.cc (range_query::get_tree_range): Likewise.
> ---
> gcc/alias.cc | 3 +-
> gcc/config/aarch64/aarch64-modes.def | 4 +
> gcc/config/aarch64/aarch64.cc | 12 --
> gcc/doc/tm.texi | 8 -
> gcc/doc/tm.texi.in | 2 -
> gcc/emit-rtl.cc | 5 +-
> gcc/genmodes.cc | 22 +++
> gcc/gimple-fold.cc | 8 +-
> gcc/ipa-modref-tree.cc | 5 +-
> gcc/poly-int.h | 285 ++++++++++++++++++++++-----
> gcc/target.def | 10 -
> gcc/tree-ssa-alias.cc | 16 +-
> gcc/tree-ssa-sccvn.cc | 8 +-
> gcc/tree-vect-data-refs.cc | 11 +-
> gcc/value-query.cc | 85 ++------
> 15 files changed, 319 insertions(+), 165 deletions(-)
>
> diff --git a/gcc/alias.cc b/gcc/alias.cc
> index cee61b551d0..1513d2ef9fc 100644
> --- a/gcc/alias.cc
> +++ b/gcc/alias.cc
> @@ -331,7 +331,8 @@ ao_ref_from_mem (ao_ref *ref, const_rtx mem)
> && (DECL_SIZE (ref->base) == NULL_TREE
> || !poly_int_tree_p (DECL_SIZE (ref->base))
> || maybe_lt (wi::to_poly_offset (DECL_SIZE (ref->base)),
> - ref->offset + ref->size)))))
> + poly_offset_int::from (ref->offset + ref->size,
> + SIGNED))))))
> return false;
>
> return true;
> diff --git a/gcc/config/aarch64/aarch64-modes.def
> b/gcc/config/aarch64/aarch64-modes.def
> index fc005542866..06bb0254374 100644
> --- a/gcc/config/aarch64/aarch64-modes.def
> +++ b/gcc/config/aarch64/aarch64-modes.def
> @@ -271,3 +271,7 @@ FLOAT_MODE (TF, 16, ieee_quad_format);
> /* Coefficient 1 is multiplied by the number of 128-bit chunks in an
> SVE vector (referred to as "VQ") minus one. */
> #define NUM_POLY_INT_COEFFS 2
> +
> +#ifndef POLY_INT_INDETERMINATE_BOUND
> +#define POLY_INT_INDETERMINATE_BOUND {0, 15}
> +#endif
> diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc
> index 263c0afd4ab..b961833de02 100644
> --- a/gcc/config/aarch64/aarch64.cc
> +++ b/gcc/config/aarch64/aarch64.cc
> @@ -31838,15 +31838,6 @@ aarch64_estimated_poly_value (poly_int64 val,
> return val.coeffs[0] + val.coeffs[1] * over_128 / 128;
> }
>
> -/* Implement TARGET_POLY_INT_INDETERMINATE_BOUND. */
> -
> -static poly_uint64
> -aarch64_poly_int_indeterminate_bound ()
> -{
> - return poly_uint64 (0, 15);
> -}
> -
> -
> /* Return true for types that could be supported as SIMD return or
> argument types. */
>
> @@ -35246,9 +35237,6 @@ aarch64_libgcc_floating_mode_supported_p
> #undef TARGET_ESTIMATED_POLY_VALUE
> #define TARGET_ESTIMATED_POLY_VALUE aarch64_estimated_poly_value
>
> -#undef TARGET_POLY_INT_INDETERMINATE_BOUND
> -#define TARGET_POLY_INT_INDETERMINATE_BOUND
> aarch64_poly_int_indeterminate_bound
> -
> #undef TARGET_ATTRIBUTE_TABLE
> #define TARGET_ATTRIBUTE_TABLE aarch64_attribute_table
>
> diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
> index 65cf4c640e7..b92443e3d61 100644
> --- a/gcc/doc/tm.texi
> +++ b/gcc/doc/tm.texi
> @@ -7529,14 +7529,6 @@ the @code{POLY_VALUE_MIN}, @code{POLY_VALUE_MAX} and
> implementation returns the lowest possible value of @var{val}.
> @end deftypefn
>
> -@deftypefn {Target Hook} poly_uint64 TARGET_POLY_INT_INDETERMINATE_BOUND
> (void)
> -Return a @code{poly_uint64} whose coefficients give conservative
> -inclusive upper bounds for the corresponding @code{poly_int}
> -indeterminates. The constant coefficient is ignored and should be zero.
> -This hook is used for correctness rather than for costing, so the returned
> -bounds must be safe for all architecturally-valid runtime values.
> -@end deftypefn
> -
> @deftypefn {Target Hook} bool TARGET_AVOID_STORE_FORWARDING_P
> (vec<store_fwd_info>, @var{rtx}, @var{int}, @var{bool})
> Given a list of stores and a load instruction that reads from the location
> of the stores, this hook decides if it's profitable to emit additional code
> diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in
> index 6b8203c5bed..4ea2bb8e1d8 100644
> --- a/gcc/doc/tm.texi.in
> +++ b/gcc/doc/tm.texi.in
> @@ -4806,8 +4806,6 @@ Define this macro if a non-short-circuit operation
> produced by
>
> @hook TARGET_ESTIMATED_POLY_VALUE
>
> -@hook TARGET_POLY_INT_INDETERMINATE_BOUND
> -
> @hook TARGET_AVOID_STORE_FORWARDING_P
>
> @node Scheduling
> diff --git a/gcc/emit-rtl.cc b/gcc/emit-rtl.cc
> index e76e0bbb264..21098da825b 100644
> --- a/gcc/emit-rtl.cc
> +++ b/gcc/emit-rtl.cc
> @@ -2801,7 +2801,8 @@ widen_memory_access (rtx memref, machine_mode mode,
> poly_int64 offset)
> /* Is the field at least as large as the access? If so, ok,
> otherwise strip back to the containing structure. */
> if (poly_int_tree_p (DECL_SIZE_UNIT (field))
> - && known_ge (wi::to_poly_offset (DECL_SIZE_UNIT (field)), size)
> + && known_ge (wi::to_poly_offset (DECL_SIZE_UNIT (field)),
> + poly_offset_int::from (size, UNSIGNED))
> && known_ge (attrs.offset, 0))
> break;
>
> @@ -2822,7 +2823,7 @@ widen_memory_access (rtx memref, machine_mode mode,
> poly_int64 offset)
> && DECL_SIZE_UNIT (attrs.expr)
> && poly_int_tree_p (DECL_SIZE_UNIT (attrs.expr))
> && known_ge (wi::to_poly_offset (DECL_SIZE_UNIT (attrs.expr)),
> - size)
> + poly_offset_int::from (size, UNSIGNED))
> && known_ge (attrs.offset, 0))
> break;
> else
> diff --git a/gcc/genmodes.cc b/gcc/genmodes.cc
> index 7e5e061c2f3..64302be9b5f 100644
> --- a/gcc/genmodes.cc
> +++ b/gcc/genmodes.cc
> @@ -859,6 +859,14 @@ create_modes (void)
> #define NUM_POLY_INT_COEFFS 1
> #endif
>
> +#ifndef POLY_INT_INDETERMINATE_BOUND
> +#if NUM_POLY_INT_COEFFS == 2
> +#define POLY_INT_INDETERMINATE_BOUND {0, (unsigned int) -1}
> +#else
> +#define POLY_INT_INDETERMINATE_BOUND {0}
> +#endif
> +#endif
> +
> /* Processing. */
>
> /* Sort a list of modes into the order needed for the WIDER field:
> @@ -1399,6 +1407,20 @@ enum machine_mode\n{");
>
> printf ("#define NUM_POLY_INT_COEFFS %d\n", NUM_POLY_INT_COEFFS);
>
> + unsigned int indeterminate_bound[NUM_POLY_INT_COEFFS]
> + = POLY_INT_INDETERMINATE_BOUND;
> + printf ("#ifndef POLY_INT_INDETERMINATE_BOUND\n");
> + if (NUM_POLY_INT_COEFFS == 1)
> + printf ("#define POLY_INT_INDETERMINATE_BOUND {%u}\n",
> + indeterminate_bound[0]);
> + else if (NUM_POLY_INT_COEFFS == 2)
> + printf ("#define POLY_INT_INDETERMINATE_BOUND {%u, %u}\n",
> + indeterminate_bound[0], indeterminate_bound[1]);
> + else
> + internal_error ("Unsupported NUM_POLY_INT_COEFFS value '%d'",
> + NUM_POLY_INT_COEFFS);
> + printf ("#endif\n");
> +
> puts ("\
> \n\
> #endif /* insn-modes.h */");
> diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc
> index 9bc88da352b..4fb3d0a38be 100644
> --- a/gcc/gimple-fold.cc
> +++ b/gcc/gimple-fold.cc
> @@ -1127,8 +1127,12 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator
> *gsi,
> = mem_ref_offset (src_base) + src_offset;
> poly_offset_int full_dest_offset
> = mem_ref_offset (dest_base) + dest_offset;
> - if (ranges_maybe_overlap_p (full_src_offset, maxsize,
> - full_dest_offset, maxsize))
> + if (ranges_maybe_overlap_p (full_src_offset,
> + poly_offset_int::from (maxsize,
> +
> UNSIGNED),
> + full_dest_offset,
> + poly_offset_int::from (maxsize,
> +
> UNSIGNED)))
> return false;
> }
> else
> diff --git a/gcc/ipa-modref-tree.cc b/gcc/ipa-modref-tree.cc
> index 73faa919b6c..75b50c62ae9 100644
> --- a/gcc/ipa-modref-tree.cc
> +++ b/gcc/ipa-modref-tree.cc
> @@ -98,9 +98,10 @@ modref_access_node::contains (const modref_access_node &a)
> const
> return false;
> if (known_size_p (max_size))
> return known_subrange_p (poly_offset_int::from (a.offset, SIGNED)
> - + aoffset_adj, a.max_size,
> + + aoffset_adj,
> + poly_offset_int::from (a.max_size, SIGNED),
> poly_offset_int::from (offset, SIGNED),
> - max_size);
> + poly_offset_int::from (max_size, SIGNED));
> else
> return known_le (poly_offset_int::from (offset, SIGNED),
> poly_offset_int::from (a.offset, SIGNED)
> diff --git a/gcc/poly-int.h b/gcc/poly-int.h
> index 01bc5cc5c17..2c93776c3bf 100644
> --- a/gcc/poly-int.h
> +++ b/gcc/poly-int.h
> @@ -1121,6 +1121,90 @@ sext_hwi (const poly_int<N, C> &a, unsigned int
> precision)
> return r;
> }
>
> +template <unsigned int N, typename Ca>
> +inline bool
> +maybe_upper_bound (const poly_int<N, Ca> &a,
> + WI_BINARY_RESULT (Ca, WI_BINARY_RESULT (Ca, unsigned int))
> + * res,
> + signop sgn)
> +{
> + typedef WI_BINARY_RESULT (Ca, unsigned int) C1;
> + typedef WI_BINARY_RESULT (Ca, C1) Cr;
> +
> + if (N > 2)
> + return false;
> +
> + wi::overflow_type ovf = wi::OVF_NONE;
> + if (N < 2 || wi::neg_p (a.coeffs[1], sgn)
> + || wi::eq_p (a.coeffs[1], wi::ints_for<Ca>::zero (a.coeffs[1])))
> + {
> + Cr temp2 = wi::add (a.coeffs[0], wi::ints_for<C1>::zero (a.coeffs[0]),
> + sgn, &ovf);
> + gcc_assert (ovf == wi::OVF_NONE);
> + *res = temp2;
> + return true;
> + }
> +
> + if (N != NUM_POLY_INT_COEFFS)
> + return false;
> + const unsigned int indeterminate_bound[NUM_POLY_INT_COEFFS]
> + = POLY_INT_INDETERMINATE_BOUND;
> +
> + if (indeterminate_bound[1] == (unsigned int) -1)
> + return false;
> +
> + C1 temp1 = wi::mul (a.coeffs[1], indeterminate_bound[1], sgn, &ovf);
> + if (ovf != wi::OVF_NONE)
> + return false;
> + Cr temp2 = wi::add (a.coeffs[0], temp1, sgn, &ovf);
> + if (ovf != wi::OVF_NONE)
> + return false;
> +
> + *res = temp2;
> + return true;
> +}
> +
> +template <unsigned int N, typename Ca>
> +inline bool
> +maybe_lower_bound (const poly_int<N, Ca> &a,
> + WI_BINARY_RESULT (Ca, WI_BINARY_RESULT (Ca, unsigned int))
> + * res,
> + signop sgn)
> +{
> + typedef WI_BINARY_RESULT (Ca, unsigned int) C1;
> + typedef WI_BINARY_RESULT (Ca, C1) Cr;
> +
> + if (N > 2)
> + return false;
> +
> + wi::overflow_type ovf = wi::OVF_NONE;
> + if (N < 2 || !wi::neg_p (a.coeffs[1], sgn))
> + {
> + Cr temp2 = wi::add (a.coeffs[0], wi::ints_for<C1>::zero (a.coeffs[0]),
> + sgn, &ovf);
> + gcc_assert (ovf == wi::OVF_NONE);
> + *res = temp2;
> + return true;
> + }
> +
> + if (N != NUM_POLY_INT_COEFFS)
> + return false;
> + const unsigned int indeterminate_bound[NUM_POLY_INT_COEFFS]
> + = POLY_INT_INDETERMINATE_BOUND;
> +
> + if (indeterminate_bound[1] == (unsigned int) -1)
> + return false;
> +
> + C1 temp1 = wi::mul (a.coeffs[1], indeterminate_bound[1], sgn, &ovf);
> + if (ovf != wi::OVF_NONE)
> + return false;
> + Cr temp2 = wi::add (a.coeffs[0], temp1, sgn, &ovf);
> + if (ovf != wi::OVF_NONE)
> + return false;
> +
> + *res = temp2;
> + return true;
> +}
>
> /* Return true if a0 + a1 * x might equal b0 + b1 * x for some nonnegative
> integer x. */
> @@ -1253,10 +1337,27 @@ maybe_ne (const Ca &a, const Cb &b)
> /* Return true if A might be less than or equal to B for some
> indeterminate values. */
>
> -template<unsigned int N, typename Ca, typename Cb>
> +template <unsigned int N, typename Ca, typename Cb>
> inline bool
> -maybe_le (const poly_int<N, Ca> &a, const poly_int<N, Cb> &b)
> -{
> +maybe_le (const poly_int<N, Ca> &a, const poly_int<N, Cb> &b,
> + bool strict = true)
> +{
> + typedef WI_BINARY_RESULT (Ca, unsigned int) type_a;
> + typedef WI_BINARY_RESULT (Cb, unsigned int) type_b;
> +
> + signop sgn = (poly_coeff_traits<type_a>::signedness == 1
> + || poly_coeff_traits<type_b>::signedness == 1
> + ? SIGNED
> + : UNSIGNED);
> +
> + type_a a_lower_bound = 0;
> + type_b b_upper_bound = 0;
> + if (!strict
> + && maybe_lower_bound (a, &a_lower_bound, sgn)
> + && maybe_upper_bound (b, &b_upper_bound, sgn)
> + && wi::gt_p (a_lower_bound, b_upper_bound, sgn))
> + return false;
> +
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (a.coeffs[i] < b.coeffs[i])
> @@ -1264,10 +1365,20 @@ maybe_le (const poly_int<N, Ca> &a, const poly_int<N,
> Cb> &b)
> return a.coeffs[0] <= b.coeffs[0];
> }
>
> -template<unsigned int N, typename Ca, typename Cb>
> +template <unsigned int N, typename Ca, typename Cb>
> inline typename if_nonpoly<Cb, bool>::type
> -maybe_le (const poly_int<N, Ca> &a, const Cb &b)
> +maybe_le (const poly_int<N, Ca> &a, const Cb &b,
> + bool strict = true)
> {
> + typedef WI_BINARY_RESULT (Ca, unsigned int) type_a;
> + signop sgn = (poly_coeff_traits<type_a>::signedness == 1 ? SIGNED :
> UNSIGNED);
> +
> + type_a a_lower_bound = 0;
> + if (!strict
> + && maybe_lower_bound (a, &a_lower_bound, sgn)
> + && wi::gt_p (a_lower_bound, b, sgn))
> + return false;
> +
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (a.coeffs[i] < 0)
> @@ -1275,10 +1386,20 @@ maybe_le (const poly_int<N, Ca> &a, const Cb &b)
> return a.coeffs[0] <= b;
> }
>
> -template<unsigned int N, typename Ca, typename Cb>
> +template <unsigned int N, typename Ca, typename Cb>
> inline typename if_nonpoly<Ca, bool>::type
> -maybe_le (const Ca &a, const poly_int<N, Cb> &b)
> +maybe_le (const Ca &a, const poly_int<N, Cb> &b,
> + bool strict = true)
> {
> + typedef WI_BINARY_RESULT (Cb, unsigned int) type_b;
> + signop sgn = (poly_coeff_traits<type_b>::signedness == 1 ? SIGNED :
> UNSIGNED);
> +
> + type_b b_upper_bound = 0;
> + if (!strict
> + && maybe_upper_bound (b, &b_upper_bound, sgn)
> + && wi::gt_p (a, b_upper_bound, sgn))
> + return false;
> +
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (b.coeffs[i] > 0)
> @@ -1286,19 +1407,36 @@ maybe_le (const Ca &a, const poly_int<N, Cb> &b)
> return a <= b.coeffs[0];
> }
>
> -template<typename Ca, typename Cb>
> +template <typename Ca, typename Cb>
> inline typename if_nonpoly2<Ca, Cb, bool>::type
> -maybe_le (const Ca &a, const Cb &b)
> +maybe_le (const Ca &a, const Cb &b, bool = true)
> {
> return a <= b;
> }
>
> -/* Return true if A might be less than B for some indeterminate values. */
> +/* Return true if all the coefficients of a A are less than the respective
> + coefficient in B. */
>
> -template<unsigned int N, typename Ca, typename Cb>
> +template <unsigned int N, typename Ca, typename Cb>
> inline bool
> -maybe_lt (const poly_int<N, Ca> &a, const poly_int<N, Cb> &b)
> -{
> +maybe_lt (const poly_int<N, Ca> &a, const poly_int<N, Cb> &b,
> + bool strict = true)
> +{
> + typedef WI_BINARY_RESULT (Ca, unsigned int) type_a;
> + typedef WI_BINARY_RESULT (Cb, unsigned int) type_b;
> + signop sgn = (poly_coeff_traits<type_a>::signedness == 1
> + || poly_coeff_traits<type_b>::signedness == 1
> + ? SIGNED
> + : UNSIGNED);
> +
> + type_a a_lower_bound = 0;
> + type_b b_upper_bound = 0;
> + if (!strict
> + && maybe_lower_bound (a, &a_lower_bound, sgn)
> + && maybe_upper_bound (b, &b_upper_bound, sgn)
> + && wi::ge_p (a_lower_bound, b_upper_bound, sgn))
> + return false;
> +
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (a.coeffs[i] < b.coeffs[i])
> @@ -1306,10 +1444,20 @@ maybe_lt (const poly_int<N, Ca> &a, const poly_int<N,
> Cb> &b)
> return a.coeffs[0] < b.coeffs[0];
> }
>
> -template<unsigned int N, typename Ca, typename Cb>
> +template <unsigned int N, typename Ca, typename Cb>
> inline typename if_nonpoly<Cb, bool>::type
> -maybe_lt (const poly_int<N, Ca> &a, const Cb &b)
> +maybe_lt (const poly_int<N, Ca> &a, const Cb &b,
> + bool strict = true)
> {
> + typedef WI_BINARY_RESULT (Ca, unsigned int) type_a;
> + signop sgn = (poly_coeff_traits<type_a>::signedness == 1 ? SIGNED :
> UNSIGNED);
> +
> + type_a a_lower_bound = 0;
> + if (!strict
> + && maybe_lower_bound (a, &a_lower_bound, sgn)
> + && wi::ge_p (a_lower_bound, b, sgn))
> + return false;
> +
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (a.coeffs[i] < 0)
> @@ -1317,10 +1465,20 @@ maybe_lt (const poly_int<N, Ca> &a, const Cb &b)
> return a.coeffs[0] < b;
> }
>
> -template<unsigned int N, typename Ca, typename Cb>
> +template <unsigned int N, typename Ca, typename Cb>
> inline typename if_nonpoly<Ca, bool>::type
> -maybe_lt (const Ca &a, const poly_int<N, Cb> &b)
> +maybe_lt (const Ca &a, const poly_int<N, Cb> &b,
> + bool strict = true)
> {
> + typedef WI_BINARY_RESULT (Cb, unsigned int) type_b;
> + signop sgn = (poly_coeff_traits<type_b>::signedness == 1 ? SIGNED :
> UNSIGNED);
> +
> + type_b b_upper_bound = 0;
> + if (!strict
> + && maybe_upper_bound (b, &b_upper_bound, sgn)
> + && wi::ge_p (a, b_upper_bound, sgn))
> + return false;
> +
> if (N >= 2)
> for (unsigned int i = 1; i < N; i++)
> if (b.coeffs[i] > 0)
> @@ -1330,39 +1488,70 @@ maybe_lt (const Ca &a, const poly_int<N, Cb> &b)
>
> template<typename Ca, typename Cb>
> inline typename if_nonpoly2<Ca, Cb, bool>::type
> -maybe_lt (const Ca &a, const Cb &b)
> +maybe_lt (const Ca &a, const Cb &b,
> + bool = true)
> {
> return a < b;
> }
>
> /* Return true if A may be greater than or equal to B. */
> -#define maybe_ge(A, B) maybe_le (B, A)
> +template <typename Ca, typename Cb>
> +inline bool
> +maybe_ge (const Ca &a, const Cb &b, bool strict = true)
> +{
> + return maybe_le (b, a, strict);
> +}
>
> /* Return true if A may be greater than B. */
> -#define maybe_gt(A, B) maybe_lt (B, A)
> +template <typename Ca, typename Cb>
> +inline bool
> +maybe_gt (const Ca &a, const Cb &b, bool strict = true)
> +{
> + return maybe_lt (b, a, strict);
> +}
>
> /* Return true if A is known to be less than or equal to B. */
> -#define known_le(A, B) (!maybe_gt (A, B))
> +template <typename Ca, typename Cb>
> +inline bool
> +known_le (const Ca &a, const Cb &b, bool strict = true)
> +{
> + return !maybe_gt (a, b, strict);
> +}
>
> /* Return true if A is known to be less than B. */
> -#define known_lt(A, B) (!maybe_ge (A, B))
> +template <typename Ca, typename Cb>
> +inline bool
> +known_lt (const Ca &a, const Cb &b, bool strict = true)
> +{
> + return !maybe_ge (a, b, strict);
> +}
>
> /* Return true if A is known to be greater than B. */
> -#define known_gt(A, B) (!maybe_le (A, B))
> +template <typename Ca, typename Cb>
> +inline bool
> +known_gt (const Ca &a, const Cb &b, bool strict = true)
> +{
> + return !maybe_le (a, b, strict);
> +}
>
> /* Return true if A is known to be greater than or equal to B. */
> -#define known_ge(A, B) (!maybe_lt (A, B))
> +template <typename Ca, typename Cb>
> +inline bool
> +known_ge (const Ca &a, const Cb &b, bool strict = true)
> +{
> + return !maybe_lt (a, b, strict);
> +}
>
> /* Return true if A and B are ordered by the partial ordering known_le. */
>
> -template<typename T1, typename T2>
> +template <typename T1, typename T2>
> inline bool
> -ordered_p (const T1 &a, const T2 &b)
> +ordered_p (const T1 &a, const T2 &b, bool strict = true)
> {
> return ((poly_int_traits<T1>::num_coeffs == 1
> && poly_int_traits<T2>::num_coeffs == 1)
> - || known_le (a, b)
> - || known_le (b, a));
> + || known_le (a, b, strict)
> + || known_le (b, a, strict));
> }
>
> /* Assert that A and B are known to be ordered and return the minimum
> @@ -1371,44 +1560,45 @@ ordered_p (const T1 &a, const T2 &b)
> NOTE: When using this function, please add a comment above the call
> explaining why we know the values are ordered in that context. */
>
> -template<unsigned int N, typename Ca, typename Cb>
> +template <unsigned int N, typename Ca, typename Cb>
> inline POLY_POLY_RESULT (N, Ca, Cb)
> -ordered_min (const poly_int<N, Ca> &a, const poly_int<N, Cb> &b)
> +ordered_min (const poly_int<N, Ca> &a, const poly_int<N, Cb> &b,
> + bool strict = true)
> {
> - if (known_le (a, b))
> + if (known_le (a, b, strict))
> return a;
> else
> {
> if (N > 1)
> - gcc_checking_assert (known_le (b, a));
> + gcc_checking_assert (known_le (b, a, strict));
> return b;
> }
> }
>
> template<unsigned int N, typename Ca, typename Cb>
> inline CONST_POLY_RESULT (N, Ca, Cb)
> -ordered_min (const Ca &a, const poly_int<N, Cb> &b)
> +ordered_min (const Ca &a, const poly_int<N, Cb> &b, bool strict = true)
> {
> - if (known_le (a, b))
> + if (known_le (a, b, strict))
> return a;
> else
> {
> if (N > 1)
> - gcc_checking_assert (known_le (b, a));
> + gcc_checking_assert (known_le (b, a, strict));
> return b;
> }
> }
>
> template<unsigned int N, typename Ca, typename Cb>
> inline POLY_CONST_RESULT (N, Ca, Cb)
> -ordered_min (const poly_int<N, Ca> &a, const Cb &b)
> +ordered_min (const poly_int<N, Ca> &a, const Cb &b, bool strict = true)
> {
> - if (known_le (a, b))
> + if (known_le (a, b, strict))
> return a;
> else
> {
> if (N > 1)
> - gcc_checking_assert (known_le (b, a));
> + gcc_checking_assert (known_le (b, a, strict));
> return b;
> }
> }
> @@ -1421,42 +1611,43 @@ ordered_min (const poly_int<N, Ca> &a, const Cb &b)
>
> template<unsigned int N, typename Ca, typename Cb>
> inline POLY_POLY_RESULT (N, Ca, Cb)
> -ordered_max (const poly_int<N, Ca> &a, const poly_int<N, Cb> &b)
> +ordered_max (const poly_int<N, Ca> &a, const poly_int<N, Cb> &b,
> + bool strict = true)
> {
> - if (known_le (a, b))
> + if (known_le (a, b, strict))
> return b;
> else
> {
> if (N > 1)
> - gcc_checking_assert (known_le (b, a));
> + gcc_checking_assert (known_le (b, a, strict));
> return a;
> }
> }
>
> template<unsigned int N, typename Ca, typename Cb>
> inline CONST_POLY_RESULT (N, Ca, Cb)
> -ordered_max (const Ca &a, const poly_int<N, Cb> &b)
> +ordered_max (const Ca &a, const poly_int<N, Cb> &b, bool strict = true)
> {
> - if (known_le (a, b))
> + if (known_le (a, b, strict))
> return b;
> else
> {
> if (N > 1)
> - gcc_checking_assert (known_le (b, a));
> + gcc_checking_assert (known_le (b, a, strict));
> return a;
> }
> }
>
> template<unsigned int N, typename Ca, typename Cb>
> inline POLY_CONST_RESULT (N, Ca, Cb)
> -ordered_max (const poly_int<N, Ca> &a, const Cb &b)
> +ordered_max (const poly_int<N, Ca> &a, const Cb &b, bool strict = true)
> {
> - if (known_le (a, b))
> + if (known_le (a, b, strict))
> return b;
> else
> {
> if (N > 1)
> - gcc_checking_assert (known_le (b, a));
> + gcc_checking_assert (known_le (b, a, strict));
> return a;
> }
> }
> diff --git a/gcc/target.def b/gcc/target.def
> index 877bd166b23..b12204a669f 100644
> --- a/gcc/target.def
> +++ b/gcc/target.def
> @@ -4294,16 +4294,6 @@ implementation returns the lowest possible value of
> @var{val}.",
> HOST_WIDE_INT, (poly_int64 val, poly_value_estimate_kind kind),
> default_estimated_poly_value)
>
> -DEFHOOK
> -(poly_int_indeterminate_bound,
> - "Return a @code{poly_uint64} whose coefficients give conservative\n\
> -inclusive upper bounds for the corresponding @code{poly_int}\n\
> -indeterminates. The constant coefficient is ignored and should be zero.\n\
> -This hook is used for correctness rather than for costing, so the returned\n\
> -bounds must be safe for all architecturally-valid runtime values.",
> - poly_uint64, (void),
> - NULL)
> -
> /* Permit speculative instructions in delay slots during delayed-branch
> scheduling. */
> DEFHOOK
> diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc
> index 41072b4d5d9..f87803dd1cd 100644
> --- a/gcc/tree-ssa-alias.cc
> +++ b/gcc/tree-ssa-alias.cc
> @@ -2148,7 +2148,9 @@ indirect_ref_may_alias_decl_p (tree ref1
> ATTRIBUTE_UNUSED, tree base1,
> ??? IVOPTs creates bases that do not honor this restriction,
> so do not apply this optimization for TARGET_MEM_REFs. */
> if (TREE_CODE (base1) != TARGET_MEM_REF
> - && !ranges_maybe_overlap_p (offset1 + moff, -1, offset2, max_size2))
> + && !ranges_maybe_overlap_p (offset1 + moff, poly_offset_int (-1),
> + poly_offset_int::from (offset2, SIGNED),
> + poly_offset_int::from (max_size2, SIGNED)))
> return false;
>
> /* If the pointer based access is bigger than the variable they cannot
> @@ -2249,7 +2251,11 @@ indirect_ref_may_alias_decl_p (tree ref1
> ATTRIBUTE_UNUSED, tree base1,
> && TREE_CODE (TYPE_SIZE (TREE_TYPE (base1)))
> != INTEGER_CST));
> if (!partial_overlap
> - && !ranges_maybe_overlap_p (doffset1, max_size1, doffset2,
> max_size2))
> + && !ranges_maybe_overlap_p (poly_offset_int::from (doffset1,
> SIGNED),
> + poly_offset_int::from (max_size1,
> SIGNED),
> + doffset2,
> + poly_offset_int::from (max_size2,
> + SIGNED)))
> return false;
> if (!ref1 || !ref2
> /* If there is must alias, there is no use disambiguating further.
> */
> @@ -2333,8 +2339,10 @@ indirect_refs_may_alias_p (tree ref1 ATTRIBUTE_UNUSED,
> tree base1,
> {
> poly_offset_int moff1 = mem_ref_offset (base1) << LOG2_BITS_PER_UNIT;
> poly_offset_int moff2 = mem_ref_offset (base2) << LOG2_BITS_PER_UNIT;
> - if (!ranges_maybe_overlap_p (offset1 + moff1, max_size1,
> - offset2 + moff2, max_size2))
> + if (!ranges_maybe_overlap_p (offset1 + moff1,
> + poly_offset_int::from (max_size1, SIGNED),
> + offset2 + moff2,
> + poly_offset_int::from (max_size2, SIGNED)))
> return false;
> /* If there is must alias, there is no use disambiguating further. */
> if (known_eq (size1, max_size1) && known_eq (size2, max_size2))
> diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc
> index f8a68d4e4fd..758c3404bfa 100644
> --- a/gcc/tree-ssa-sccvn.cc
> +++ b/gcc/tree-ssa-sccvn.cc
> @@ -3094,12 +3094,16 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void
> *data_,
> len = SSA_VAL (len);
> /* Sometimes the above trickery is smarter than alias analysis. Take
> advantage of that. */
> - if (!ranges_maybe_overlap_p (offset, maxsize, offset2,
> + if (!ranges_maybe_overlap_p (poly_offset_int::from (offset, SIGNED),
> + poly_offset_int::from (maxsize, SIGNED),
> + poly_offset_int::from (offset2, SIGNED),
> (wi::to_poly_offset (len)
> << LOG2_BITS_PER_UNIT)))
> return NULL;
> if (data->partial_defs.is_empty ()
> - && known_subrange_p (offset, maxsize, offset2,
> + && known_subrange_p (poly_offset_int::from (offset, SIGNED),
> + poly_offset_int::from (maxsize, SIGNED),
> + poly_offset_int::from (offset2, SIGNED),
> wi::to_poly_offset (len) <<
> LOG2_BITS_PER_UNIT))
> {
> tree val;
> diff --git a/gcc/tree-vect-data-refs.cc b/gcc/tree-vect-data-refs.cc
> index 08b94149e7c..e213869af57 100644
> --- a/gcc/tree-vect-data-refs.cc
> +++ b/gcc/tree-vect-data-refs.cc
> @@ -3924,12 +3924,15 @@ vect_compile_time_alias (dr_vec_info *a, dr_vec_info
> *b,
> const_length_a += access_size_a;
> const_length_b += access_size_b;
>
> - if (ranges_known_overlap_p (offset_a, const_length_a,
> - offset_b, const_length_b))
> + if (ranges_known_overlap_p (offset_a,
> + poly_offset_int::from (const_length_a,
> UNSIGNED),
> + offset_b,
> + poly_offset_int::from (const_length_b,
> UNSIGNED)))
> return 1;
>
> - if (!ranges_maybe_overlap_p (offset_a, const_length_a,
> - offset_b, const_length_b))
> + if (!ranges_maybe_overlap_p (
> + offset_a, poly_offset_int::from (const_length_a, UNSIGNED), offset_b,
> + poly_offset_int::from (const_length_b, UNSIGNED)))
> return 0;
>
> return -1;
> diff --git a/gcc/value-query.cc b/gcc/value-query.cc
> index 0a6de62d763..8b3d607f0e0 100644
> --- a/gcc/value-query.cc
> +++ b/gcc/value-query.cc
> @@ -442,86 +442,33 @@ range_query::get_tree_range (vrange &r, tree expr,
> gimple *stmt,
> {
> unsigned int precision = TYPE_PRECISION (type);
> 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 ();
>
> 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.
> -
> - 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] = { val.coeffs[0], val.coeffs[0] };
> - bool ovf[2] = { false, false };
> + wide_int lower_bound = type_min;
> + wide_int upper_bound = type_max;
>
> - for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
> + if (!maybe_lower_bound (val, &lower_bound, sign)
> + || wi::lt_p (lower_bound, type_min, sign)
> + || wi::gt_p (lower_bound, type_max, sign)
> + || !maybe_upper_bound (val, &upper_bound, sign)
> + || wi::lt_p (upper_bound, type_min, sign)
> + || wi::gt_p (upper_bound, type_max, sign))
> {
> - const auto &coeff = val.coeffs[i];
> - 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
> - {
> - auto indeterminate
> - = wi::uhwi (indeterminate_bound.coeffs[i], precision);
> - wi::overflow_type mul_ovf = wi::OVF_NONE;
> - 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
> - || add_ovf != wi::OVF_NONE);
> - }
> -
> - if (TYPE_OVERFLOW_WRAPS (type) && bound_ovf)
> - {
> - r.set_varying (type);
> - r.update_bitmask (irange_bitmask (wi::zero (precision),
> - get_nonzero_bits (expr)));
> - return true;
> - }
> -
> - if (bound_ovf)
> - {
> - if (coeff_neg)
> - bounds[0] = type_min;
> - else
> - bounds[1] = type_max;
> - }
> + /* Overflow risk, so no known bounds. */
> + r.set_varying (type);
> + r.update_bitmask (
> + irange_bitmask (wi::zero (precision), get_nonzero_bits
> (expr)));
> + return true;
> }
>
> /* Check that the target filled in sensible bounds information. */
> - gcc_assert (wi::le_p (bounds[0], bounds[1], sign));
> + gcc_assert (wi::le_p (lower_bound, upper_bound, sign));
>
> - irange &ir = as_a <irange> (r);
> - ir.set (type, bounds[0], bounds[1]);
> + irange &ir = as_a<irange> (r);
> + ir.set (type, lower_bound, upper_bound);
>
> /* Preserve alignment/step information that is not visible in the
> intervals. For example, a poly-int like [8, 8] can
> --
> 2.56.0
>
