From 143e6695b20d3522e11f6e74b587993f9f619ccb Mon Sep 17 00:00:00 2001
From: Aldy Hernandez <aldyh@redhat.com>
Date: Wed, 3 May 2023 10:48:41 +0200
Subject: [PATCH] Remove type from vrange_storage::equal_p.

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 92622fc50005..07c69ef858a6 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 14bec500dbc6..2f82739680cc 100644
--- a/gcc/value-range-storage.cc
+++ b/gcc/value-range-storage.cc
@@ -205,20 +205,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 ();
 }
@@ -374,21 +376,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;
 }
 
@@ -525,17 +523,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 a90b64b2bf0b..99fb815cdc29 100644
--- a/gcc/value-range-storage.h
+++ b/gcc/value-range-storage.h
@@ -53,7 +53,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 () { }
@@ -67,7 +67,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:
@@ -110,7 +110,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); }
-- 
2.47.2