https://gcc.gnu.org/g:9407e125d4179412b9a0c7aa86ea03cf3437f908

commit r17-5998-g9407e125d4179412b9a0c7aa86ea03cf3437f908
Author: Andrew MacLeod <[email protected]>
Date:   Wed Nov 4 14:52:56 2026 -0500

    Add dyn_ shortcut methods to vrange_storage
    
    Storage objects are more commonly being used, this provides some
    shortcuts which amount to a dynamic cast to a requested range type.
    Each range class has a method (both constant and nonconstant):
      dyn_irange,
      dyn_prange,
      dyn_frange
    
      which will return either a storage obkect of that class or NULL, much like
    the dyn_cast <irange *> (ptr)  idiom used elsewhere.
    
            * value-range-storage.cc (vrange_storage::set_vrange): Use new
            routines.
            (vrange_storage::get_vrange): Likewise.
            (vrange_storage::fits_p): Liekwise.
            (vrange_storage::equal_p): Likewise.
            * value-range-storage.h (vrange::dyn_irange): New.
            (vrange::dyn_prange): New.
            (vrange::dyn_frange): New.

Diff:
---
 gcc/value-range-storage.cc | 73 +++++++++++++---------------------------------
 gcc/value-range-storage.h  | 53 +++++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+), 52 deletions(-)

diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc
index bb2a58788b30..d7df014819d8 100644
--- a/gcc/value-range-storage.cc
+++ b/gcc/value-range-storage.cc
@@ -158,21 +158,18 @@ vrange_storage::alloc (vrange_internal_alloc &allocator, 
const vrange &r,
 void
 vrange_storage::set_vrange (const vrange &r)
 {
-  if (is_a <irange> (r))
+  if (irange_storage *s = dyn_irange ())
     {
-      irange_storage *s = static_cast <irange_storage *> (this);
       gcc_checking_assert (s->fits_p (as_a <irange> (r)));
       s->set_irange (as_a <irange> (r));
     }
-  else if (is_a <prange> (r))
+  else if (prange_storage *s = dyn_prange ())
     {
-      prange_storage *s = static_cast <prange_storage *> (this);
       gcc_checking_assert (s->fits_p (as_a <prange> (r)));
       s->set_prange (as_a <prange> (r));
     }
-  else if (is_a <frange> (r))
+  else if (frange_storage *s = dyn_frange ())
     {
-      frange_storage *s = static_cast <frange_storage *> (this);
       gcc_checking_assert (s->fits_p (as_a <frange> (r)));
       s->set_frange (as_a <frange> (r));
     }
@@ -198,21 +195,12 @@ vrange_storage::set_vrange (const vrange &r)
 void
 vrange_storage::get_vrange (vrange &r, tree type) const
 {
-  if (is_a <irange> (r))
-    {
-      const irange_storage *s = static_cast <const irange_storage *> (this);
-      s->get_irange (as_a <irange> (r), type);
-    }
-  else if (is_a <prange> (r))
-    {
-      const prange_storage *s = static_cast <const prange_storage *> (this);
-      s->get_prange (as_a <prange> (r), type);
-    }
-  else if (is_a <frange> (r))
-    {
-      const frange_storage *s = static_cast <const frange_storage *> (this);
-      s->get_frange (as_a <frange> (r), type);
-    }
+  if (const irange_storage *s = dyn_irange ())
+    s->get_irange (as_a <irange> (r), type);
+  else if (const prange_storage *s = dyn_prange ())
+    s->get_prange (as_a <prange> (r), type);
+  else if (const frange_storage *s = dyn_frange ())
+    s->get_frange (as_a <frange> (r), type);
   else
     gcc_unreachable ();
 }
@@ -222,23 +210,13 @@ vrange_storage::get_vrange (vrange &r, tree type) const
 bool
 vrange_storage::fits_p (const vrange &r) const
 {
-  if (is_a <irange> (r))
-    {
-      const irange_storage *s = static_cast <const irange_storage *> (this);
-      return s->fits_p (as_a <irange> (r));
-    }
-  if (is_a <prange> (r))
-    {
-      const prange_storage *s = static_cast <const prange_storage *> (this);
-      return s->fits_p (as_a <prange> (r));
-    }
-  if (is_a <frange> (r))
-    {
-      const frange_storage *s = static_cast <const frange_storage *> (this);
-      return s->fits_p (as_a <frange> (r));
-    }
+  if (const irange_storage *s = dyn_irange ())
+    return s->fits_p (as_a <irange> (r));
+  if (const prange_storage *s = dyn_prange ())
+    return s->fits_p (as_a <prange> (r));
+  if (const frange_storage *s = dyn_frange ())
+    return s->fits_p (as_a <frange> (r));
   gcc_unreachable ();
-  return false;
 }
 
 // Return TRUE if the range in storage is equal to R.  It is the
@@ -248,21 +226,12 @@ vrange_storage::fits_p (const vrange &r) const
 bool
 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));
-    }
-  if (is_a <prange> (r))
-    {
-      const prange_storage *s = static_cast <const prange_storage *> (this);
-      return s->equal_p (as_a <prange> (r));
-    }
-  if (is_a <frange> (r))
-    {
-      const frange_storage *s = static_cast <const frange_storage *> (this);
-      return s->equal_p (as_a <frange> (r));
-    }
+  if (const irange_storage *s = dyn_irange ())
+    return s->equal_p (as_a <irange> (r));
+  if (const prange_storage *s = dyn_prange ())
+    return s->equal_p (as_a <prange> (r));
+  if (const frange_storage *s = dyn_frange ())
+    return s->equal_p (as_a <frange> (r));
   gcc_unreachable ();
 }
 
diff --git a/gcc/value-range-storage.h b/gcc/value-range-storage.h
index 803f20526a70..4deda7ef9f10 100644
--- a/gcc/value-range-storage.h
+++ b/gcc/value-range-storage.h
@@ -52,6 +52,12 @@ public:
   bool fits_p (const vrange &r) const;
   bool equal_p (const vrange &r) const;
 
+  class irange_storage *dyn_irange ();
+  class prange_storage *dyn_prange ();
+  class frange_storage *dyn_frange ();
+  const irange_storage *dyn_irange () const;
+  const prange_storage *dyn_prange () const;
+  const frange_storage *dyn_frange () const;
   // Stack initialization disallowed.
   vrange_storage (enum value_range_discriminator d) : m_discriminator (d) { }
   const enum value_range_discriminator m_discriminator : 4;
@@ -211,6 +217,53 @@ class GTY((tag ("VR_FRANGE"))) frange_storage : public 
vrange_storage
   frange_pair m_pairs[1];
 };
 
+inline irange_storage *
+vrange_storage::dyn_irange ()
+{
+  if (m_discriminator == VR_IRANGE)
+    return static_cast <irange_storage *> (this);
+  return NULL;
+}
+
+inline prange_storage *
+vrange_storage::dyn_prange ()
+{
+  if (m_discriminator == VR_PRANGE)
+    return static_cast <prange_storage *> (this);
+  return NULL;
+}
+
+inline frange_storage *
+vrange_storage::dyn_frange ()
+{
+  if (m_discriminator == VR_FRANGE)
+    return static_cast <frange_storage *> (this);
+  return NULL;
+}
+
+inline const irange_storage *
+vrange_storage::dyn_irange () const
+{
+  if (m_discriminator == VR_IRANGE)
+    return static_cast <const irange_storage *> (this);
+  return NULL;
+}
+
+inline const prange_storage *
+vrange_storage::dyn_prange () const
+{
+  if (m_discriminator == VR_PRANGE)
+    return static_cast <const prange_storage *> (this);
+  return NULL;
+}
+
+inline const frange_storage *
+vrange_storage::dyn_frange () const
+{
+  if (m_discriminator == VR_FRANGE)
+    return static_cast <const frange_storage *> (this);
+  return NULL;
+}
 extern vrange_storage *ggc_alloc_vrange_storage (tree type);
 extern vrange_storage *ggc_alloc_vrange_storage (const vrange &,
                                                 bool shared_p = true);

Reply via email to