Re: [PATCH] Remove type from vrange_storage::equal_p.

[Aldy Hernandez via Gcc-patches]

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); }