Remove type from vrange_storage::equal_p.

[Andrew, since you suggested this, is this what you had in mind?].

The equal_p method in vrange_storage is only used to compare ranges
that are the same type.  No sense passing the type if it can be
determined from the range being compared.

gcc/ChangeLog:

	* gimple-range-cache.cc (sbr_sparse_bitmap::set_bb_range): Do not
	pass type to vrange_storage::equal_p.
	* value-range-storage.cc (vrange_storage::equal_p): Remove type.
	(irange_storage::equal_p): Same.
	(frange_storage::equal_p): Same.
	* value-range-storage.h (class frange_storage): Same.
---
 gcc/gimple-range-cache.cc  |  2 +-
 gcc/value-range-storage.cc | 28 +++++++++++-----------------
 gcc/value-range-storage.h  |  6 +++---
 3 files changed, 15 insertions(+), 21 deletions(-)

On 5/3/23 13:41, Aldy Hernandez wrote:
> [Andrew, since you suggested this, is this what you had in mind?].

Pushed.  You can comment when you're back from vacation :).

Aldy
> 
> The equal_p method in vrange_storage is only used to compare ranges
> that are the same type.  No sense passing the type if it can be
> determined from the range being compared.
> 
> gcc/ChangeLog:
> 
> 	* gimple-range-cache.cc (sbr_sparse_bitmap::set_bb_range): Do not
> 	pass type to vrange_storage::equal_p.
> 	* value-range-storage.cc (vrange_storage::equal_p): Remove type.
> 	(irange_storage::equal_p): Same.
> 	(frange_storage::equal_p): Same.
> 	* value-range-storage.h (class frange_storage): Same.
> ---
>   gcc/gimple-range-cache.cc  |  2 +-
>   gcc/value-range-storage.cc | 28 +++++++++++-----------------
>   gcc/value-range-storage.h  |  6 +++---
>   3 files changed, 15 insertions(+), 21 deletions(-)
> 
> diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc
> index 92622fc5000..07c69ef858a 100644
> --- a/gcc/gimple-range-cache.cc
> +++ b/gcc/gimple-range-cache.cc
> @@ -320,7 +320,7 @@ sbr_sparse_bitmap::set_bb_range (const_basic_block bb, const vrange &r)
>   
>     // Loop thru the values to see if R is already present.
>     for (int x = 0; x < SBR_NUM; x++)
> -    if (!m_range[x] || m_range[x]->equal_p (r, m_type))
> +    if (!m_range[x] || m_range[x]->equal_p (r))
>         {
>   	if (!m_range[x])
>   	  m_range[x] = m_range_allocator->clone (r);
> diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc
> index 7d2de5e8384..1e06a7acc8d 100644
> --- a/gcc/value-range-storage.cc
> +++ b/gcc/value-range-storage.cc
> @@ -206,20 +206,22 @@ vrange_storage::fits_p (const vrange &r) const
>     return false;
>   }
>   
> -// Return TRUE if the range in storage is equal to R.
> +// Return TRUE if the range in storage is equal to R.  It is the
> +// caller's responsibility to verify that the type of the range in
> +// storage matches that of R.
>   
>   bool
> -vrange_storage::equal_p (const vrange &r, tree type) const
> +vrange_storage::equal_p (const vrange &r) const
>   {
>     if (is_a <irange> (r))
>       {
>         const irange_storage *s = static_cast <const irange_storage *> (this);
> -      return s->equal_p (as_a <irange> (r), type);
> +      return s->equal_p (as_a <irange> (r));
>       }
>     if (is_a <frange> (r))
>       {
>         const frange_storage *s = static_cast <const frange_storage *> (this);
> -      return s->equal_p (as_a <frange> (r), type);
> +      return s->equal_p (as_a <frange> (r));
>       }
>     gcc_unreachable ();
>   }
> @@ -375,21 +377,17 @@ irange_storage::get_irange (irange &r, tree type) const
>   }
>   
>   bool
> -irange_storage::equal_p (const irange &r, tree type) const
> +irange_storage::equal_p (const irange &r) const
>   {
>     if (m_kind == VR_UNDEFINED || r.undefined_p ())
>       return m_kind == r.m_kind;
>     if (m_kind == VR_VARYING || r.varying_p ())
> -    return m_kind == r.m_kind && types_compatible_p (r.type (), type);
> -
> -  tree rtype = r.type ();
> -  if (!types_compatible_p (rtype, type))
> -    return false;
> +    return m_kind == r.m_kind;
>   
>     // ?? We could make this faster by doing the comparison in place,
>     // without going through get_irange.
>     int_range_max tmp;
> -  get_irange (tmp, rtype);
> +  get_irange (tmp, r.type ());
>     return tmp == r;
>   }
>   
> @@ -526,17 +524,13 @@ frange_storage::get_frange (frange &r, tree type) const
>   }
>   
>   bool
> -frange_storage::equal_p (const frange &r, tree type) const
> +frange_storage::equal_p (const frange &r) const
>   {
>     if (r.undefined_p ())
>       return m_kind == VR_UNDEFINED;
>   
> -  tree rtype = type;
> -  if (!types_compatible_p (rtype, type))
> -    return false;
> -
>     frange tmp;
> -  get_frange (tmp, rtype);
> +  get_frange (tmp, r.type ());
>     return tmp == r;
>   }
>   
> diff --git a/gcc/value-range-storage.h b/gcc/value-range-storage.h
> index 4ec0da73059..f25489f32c1 100644
> --- a/gcc/value-range-storage.h
> +++ b/gcc/value-range-storage.h
> @@ -54,7 +54,7 @@ public:
>     void get_vrange (vrange &r, tree type) const;
>     void set_vrange (const vrange &r);
>     bool fits_p (const vrange &r) const;
> -  bool equal_p (const vrange &r, tree type) const;
> +  bool equal_p (const vrange &r) const;
>   protected:
>     // Stack initialization disallowed.
>     vrange_storage () { }
> @@ -68,7 +68,7 @@ public:
>     static irange_storage *alloc (vrange_internal_alloc &, const irange &);
>     void set_irange (const irange &r);
>     void get_irange (irange &r, tree type) const;
> -  bool equal_p (const irange &r, tree type) const;
> +  bool equal_p (const irange &r) const;
>     bool fits_p (const irange &r) const;
>     void dump () const;
>   private:
> @@ -111,7 +111,7 @@ class frange_storage : public vrange_storage
>     static frange_storage *alloc (vrange_internal_alloc &, const frange &r);
>     void set_frange (const frange &r);
>     void get_frange (frange &r, tree type) const;
> -  bool equal_p (const frange &r, tree type) const;
> +  bool equal_p (const frange &r) const;
>     bool fits_p (const frange &) const;
>    private:
>     frange_storage (const frange &r) { set_frange (r); }