https://gcc.gnu.org/g:001042d29189eddcce8b06da0f579973774ed6be

commit r17-6000-g001042d29189eddcce8b06da0f579973774ed6be
Author: Andrew MacLeod <[email protected]>
Date:   Wed Nov 4 16:58:41 2026 -0500

    Rework prange points-to API to be address centric.
    
    Changes the prange local points-to pt_API into an addr_ based one to
    avoid confusion with the pt_solution routines.
    
            * gimple-range-fold.cc (fold_using_range::fold_stmt): Adjust
            pt_ names in prange to addr_ API.
            (fold_using_range::range_of_phi): Likewise.
            * ipa-prop.cc (ipa_set_jfunc_vr): Likewise.
            (ipa_record_return_value_range_1): Likewise.
            * range-op-ptr.cc (pointer_plus_operator::fold_range): Likewise.
            (pointer_plus_operator::op2_range): Likewise.
            (operator_pointer_diff::fold_range): Likewise.
            (operator_cast::fold_range): Likewise.
            (operator_cast::lhs_op1_relation): Likewise
            (operator_equal::fold_range): Likewise.
            (operator_equal::op1_range): Likewise.
            (operator_not_equal::fold_range): Likewise.
            (operator_not_equal::op1_range): Likewise.
            * tree-ssa-threadbackward.cc (find_taken_edge_goto): Likewise.
            * tree-vrp.cc (rvrp_folder::value_of_expr): Likewise.
            (rvrp_folder::value_on_edge): Likewise.
            * value-query.cc (range_query::get_tree_range): Likewise.
            * value-range-pretty-print.cc (vrange_printer::print_addr):
            Rename from print_pt and adjust.
            (vrange_printer::visit): Call print_addr.
            * value-range-pretty-print.h (print_addr): Change prototype name.
            * value-range-storage.cc (prange_storage::alloc): Adjust to
            new API naming convention.
            (prange_storage::prange_storage): Likewise.
            (prange_storage::prange_format): Likewise.
            (prange_storage::set_prange): Likewise.
            (prange_storage::get_prange): Likewise.
            (prange_storage::equal_p): Likewise.
            (prange_storage::set_nonnull): Likewise.
            * value-range-storage.h (prange_storage::m_known_p): Rename.
            (prange_storage::m_addr): Rename.
            * value-range.cc (inchash::add_vrange): Adjust to new API.
            (prange::set_addr): Renamed and adjust.
            (prange::addr_base): Likewise.
            (prange::addr_offset): Likewise.
            (prange::addr_size): Likewise.
            (prange::set): Adjust to new API.
            (prange::union_): Likewise.
            (prange::intersect): Likewise.
            (prange::operator=): Likewise.
            (prange::operator==): Likewise.
            (prange::invert): Likewise.
            (prange::verify_range): Likewise.
            * value-range.h (prange::set_addr): Rename for new API and adjust.
            (prange::set_addr_unknown): Likewise.
            (prange::addr_unknown_p): Likewise.
            (prange::addr_known): Likewise.
            (prange::addr_excluded): Likewise.
            (prange::addr_same_known_p): Likewise.
            (prange::addr_same_excluded_p): Likewise.
            (prange::addr_invert): Likewise.
            (prange::addr_inverted_p): Likewise.
            (prange::addr_base): Likewise.
            (prange::addr_offset): Likewise.
            (prange::addr_size): Likewise.
            (prange::m_addr): Likewise.
            (prange::m_known_p): Likewise.
            (prange::addr_equal_p): Likewise.
            (prange::set_undefined): Adjust to new API.
            (prange::set_varying): Likewise.
            (prange::set_nonzero): Likewise.
            (prange::set_zero): Likewise.
            (prange::varying_compatible_p): Likewise.

Diff:
---
 gcc/gimple-range-fold.cc        |  10 +--
 gcc/ipa-prop.cc                 |  10 +--
 gcc/range-op-ptr.cc             |  30 ++++----
 gcc/tree-ssa-threadbackward.cc  |   2 +-
 gcc/tree-vrp.cc                 |   4 +-
 gcc/value-query.cc              |   2 +-
 gcc/value-range-pretty-print.cc |  30 ++++----
 gcc/value-range-pretty-print.h  |   2 +-
 gcc/value-range-storage.cc      |  26 +++----
 gcc/value-range-storage.h       |   4 +-
 gcc/value-range.cc              |  99 ++++++++++++------------
 gcc/value-range.h               | 161 +++++++++++++++++++++-------------------
 12 files changed, 194 insertions(+), 186 deletions(-)

diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc
index 72a74a737cbd..8a08c10cf905 100644
--- a/gcc/gimple-range-fold.cc
+++ b/gcc/gimple-range-fold.cc
@@ -761,7 +761,7 @@ fold_using_range::fold_stmt (vrange &r, gimple *s, 
fur_source &src, tree name)
     {
       prange &p = as_a <prange> (r);
       // Check to see if points_to should be set.
-      if (p.pt_unknown_p () && name && gimple_code (s) == GIMPLE_ASSIGN)
+      if (p.addr_unknown_p () && name && gimple_code (s) == GIMPLE_ASSIGN)
        {
          tree rhs = gimple_assign_rhs1 (s);
          tree_code code = gimple_assign_rhs_code (s);
@@ -769,7 +769,7 @@ fold_using_range::fold_stmt (vrange &r, gimple *s, 
fur_source &src, tree name)
          if (code != SSA_NAME
              && get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS
              && TREE_CODE (rhs) == ADDR_EXPR)
-           p.set_pt (rhs, true);
+           p.set_addr (rhs, true);
          else
            {
              // If we couldn't find anything, try fold.
@@ -777,7 +777,7 @@ fold_using_range::fold_stmt (vrange &r, gimple *s, 
fur_source &src, tree name)
              rhs = gimple_fold_stmt_to_constant_1 (s, pta_valueize,
                                                    pta_valueize);
              if (rhs && TREE_CODE (rhs) == ADDR_EXPR)
-               p.set_pt (rhs, true);
+               p.set_addr (rhs, true);
            }
        }
     }
@@ -1520,8 +1520,8 @@ fold_using_range::range_of_phi (vrange &r, gphi *phi, 
fur_source &src)
            {
              prange &ptr = as_a <prange> (arg_range);
              // If it doesn't already point at something, set points to.
-             if (ptr.pt_unknown_p () && TREE_CODE (single_arg) == ADDR_EXPR)
-               ptr.set_pt (single_arg, true);
+             if (ptr.addr_unknown_p () && TREE_CODE (single_arg) == ADDR_EXPR)
+               ptr.set_addr (single_arg, true);
              r = ptr;
              return true;
            }
diff --git a/gcc/ipa-prop.cc b/gcc/ipa-prop.cc
index eb220b92eab0..8f7cf8556ba1 100644
--- a/gcc/ipa-prop.cc
+++ b/gcc/ipa-prop.cc
@@ -2403,9 +2403,9 @@ ipa_set_jfunc_vr (ipa_jump_func *jf, const vrange &tmp)
   if (is_a <prange> (tmp))
     {
       const prange &pr = as_a <prange> (tmp);
-      tree t = pr.pt_invariant ();
+      tree t = pr.addr_known ();
       if (!t)
-       t = pr.pt_invariant_away ();
+       t = pr.addr_excluded ();
       if (t && !is_gimple_ip_invariant (t))
        {
          if (dump_file && (dump_flags & TDF_DETAILS))
@@ -2415,7 +2415,7 @@ ipa_set_jfunc_vr (ipa_jump_func *jf, const vrange &tmp)
              fprintf (dump_file, "\n");
            }
          prange stripped = pr;
-         stripped.set_pt_unknown ();
+         stripped.set_addr_unknown ();
          jf->m_vr = ipa_get_value_range (stripped);
          return;
        }
@@ -6038,9 +6038,9 @@ ipa_record_return_value_range_1 (cgraph_node *n, 
value_range val)
   if (is_a<prange> (val))
     {
       const prange &pr = as_a <prange> (val);
-      tree t = pr.pt_invariant ();
+      tree t = pr.addr_known ();
       if (!t)
-       t = pr.pt_invariant_away ();
+       t = pr.addr_excluded ();
       if (t && !is_gimple_ip_invariant (t))
         {
          if (dump_file && (dump_flags & TDF_DETAILS))
diff --git a/gcc/range-op-ptr.cc b/gcc/range-op-ptr.cc
index 8dfcceb64fa9..e2c0273489bb 100644
--- a/gcc/range-op-ptr.cc
+++ b/gcc/range-op-ptr.cc
@@ -372,7 +372,7 @@ pointer_plus_operator::fold_range (prange &r, tree type,
 
   // If op1 refers to an object, op1 + 0 will also refer to the object.
   if (rh_lb == rh_ub && rh_lb == 0)
-    r.set_pt (op1);
+    r.set_addr (op1);
 
   update_known_bitmask (r, POINTER_PLUS_EXPR, op1, op2);
   return true;
@@ -388,11 +388,11 @@ pointer_plus_operator::op2_range (irange &r, tree type,
   r.set_varying (type);
 
   // If the LHS and OP1 are equal, the op2 must be zero.
-  if (rel == VREL_EQ || lhs.pt_invariant_p (op1))
+  if (rel == VREL_EQ || lhs.addr_same_known_p (op1))
     r.set_zero (type);
   // If the LHS and OP1 are not equal, the offset must be non-zero.
   // AWM: Check if aliasing may mean we can't do the not_equal check.
-  else if (rel == VREL_NE || lhs.pt_inverted_p (op1))
+  else if (rel == VREL_NE || lhs.addr_inverted_p (op1))
     r.set_nonzero (type);
   else
     return false;
@@ -496,7 +496,7 @@ operator_pointer_diff::fold_range (irange &r, tree type,
   relation_kind rel = trio.op1_op2 ();
   op1_op2_relation_effect (r, type, op1, op2, rel);
   // if op1 and op2 point to the same object, the diff is 0.
-  if (op1.pt_invariant_p (op2))
+  if (op1.addr_same_known_p (op2))
     r.set_zero (type);
   update_bitmask (r, op1, op2);
   return true;
@@ -574,7 +574,7 @@ operator_cast::fold_range (prange &r, tree type,
   r.set (type, inner.lower_bound (), inner.upper_bound ());
 
   // The resulting pointer still points to the same object.
-  r.set_pt (inner);
+  r.set_addr (inner);
 
   r.update_bitmask (inner.get_bitmask ());
   return true;
@@ -741,9 +741,9 @@ operator_cast::lhs_op1_relation (const prange &lhs,
   // inequality in the points to fields.
   if (lhs_prec == op1_prec)
     {
-      if (lhs.pt_invariant_p (op1))
+      if (lhs.addr_same_known_p (op1))
        return VREL_EQ;
-      if (lhs.pt_inverted_p (op1))
+      if (lhs.addr_inverted_p (op1))
        return VREL_NE;
     }
   unsigned prec = MIN (lhs_prec, op1_prec);
@@ -900,9 +900,9 @@ operator_equal::fold_range (irange &r, tree type,
   bool op1_const = wi::eq_p (op1.lower_bound (), op1.upper_bound ());
   bool op2_const = wi::eq_p (op2.lower_bound (), op2.upper_bound ());
   // Check for points to equality and inequality first.
-  if (op1.pt_invariant_p (op2))
+  if (op1.addr_same_known_p (op2))
     r = range_true (type);
-  else if (op1.pt_inverted_p (op2))
+  else if (op1.addr_inverted_p (op2))
     r = range_false (type);
   else if (op1_const && op2_const)
     {
@@ -959,8 +959,8 @@ operator_equal::op1_range (prange &r, tree type,
        {
          r.set_varying (type);
          // OP2 refers to OBJ, so OP1 does not refer to OBJ.
-         if (tree obj = op2.pt_invariant ())
-           r.set_pt (obj, false);
+         if (tree obj = op2.addr_known ())
+           r.set_addr (obj, false);
        }
       break;
 
@@ -1010,9 +1010,9 @@ operator_not_equal::fold_range (irange &r, tree type,
   bool op1_const = wi::eq_p (op1.lower_bound (), op1.upper_bound ());
   bool op2_const = wi::eq_p (op2.lower_bound (), op2.upper_bound ());
   // Check for points to equality and inequality first.
-  if (op1.pt_inverted_p (op2))
+  if (op1.addr_inverted_p (op2))
     r = range_true (type);
-  else if (op1.pt_invariant_p (op2))
+  else if (op1.addr_same_known_p (op2))
     r = range_false (type);
   else if (op1_const && op2_const)
     {
@@ -1064,8 +1064,8 @@ operator_not_equal::op1_range (prange &r, tree type,
        {
          r.set_varying (type);
          // Check if op1 is known not to refer to op2 points to object.
-         if (tree obj = op2.pt_invariant ())
-           r.set_pt (obj, false);
+         if (tree obj = op2.addr_known ())
+           r.set_addr (obj, false);
        }
       break;
 
diff --git a/gcc/tree-ssa-threadbackward.cc b/gcc/tree-ssa-threadbackward.cc
index c9902d0dc687..ce086a55190e 100644
--- a/gcc/tree-ssa-threadbackward.cc
+++ b/gcc/tree-ssa-threadbackward.cc
@@ -352,7 +352,7 @@ back_threader::find_taken_edge_goto (const vec<basic_block> 
&path,
       if (r.undefined_p ())
        return UNREACHABLE_EDGE;
 
-      dest = r.pt_invariant ();
+      dest = r.addr_known ();
       if (!dest)
        return NULL;
     }
diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc
index 159bf22729e1..a7377d7dd3a8 100644
--- a/gcc/tree-vrp.cc
+++ b/gcc/tree-vrp.cc
@@ -981,7 +981,7 @@ public:
     if (is_a <prange> (r))
       {
        prange &p = as_a <prange> (r);
-       ret = p.pt_invariant ();
+       ret = p.addr_known ();
        // A const points has to be gimple_min_invariant.
        gcc_checking_assert (!ret || is_gimple_min_invariant (ret));
       }
@@ -1014,7 +1014,7 @@ public:
     if (is_a <prange> (r))
       {
        prange &p = as_a <prange> (r);
-       ret = p.pt_invariant ();
+       ret = p.addr_known ();
        // A const points has to be gimple_min_invariant.
        gcc_checking_assert (!ret || is_gimple_min_invariant (ret));
       }
diff --git a/gcc/value-query.cc b/gcc/value-query.cc
index a35029237ec2..0a6de62d7638 100644
--- a/gcc/value-query.cc
+++ b/gcc/value-query.cc
@@ -433,7 +433,7 @@ range_query::get_tree_range (vrange &r, tree expr, gimple 
*stmt,
        // Set points to field.
        gcc_checking_assert (is_a <prange> (r));
        prange &ptr = as_a <prange> (r);
-       ptr.set_pt (expr, true);
+       ptr.set_addr (expr, true);
        return true;
       }
 
diff --git a/gcc/value-range-pretty-print.cc b/gcc/value-range-pretty-print.cc
index 8b857b1d59a9..3335f2335288 100644
--- a/gcc/value-range-pretty-print.cc
+++ b/gcc/value-range-pretty-print.cc
@@ -113,30 +113,30 @@ vrange_printer::visit (const irange &r) const
 }
 
 void
-vrange_printer::print_pt (const prange &r) const
+vrange_printer::print_addr (const prange &r) const
 {
-  bool points_to_p = false;
-  tree pt = r.pt_invariant ();
-  if (pt)
-    points_to_p = true;
+  bool known_p = false;
+  tree addr = r.addr_known ();
+  if (addr)
+    known_p = true;
   else
-    pt = r.pt_invariant_away ();
+    addr = r.addr_excluded ();
 
-  if (pt)
+  if (addr)
     {
-      if (points_to_p)
+      if (known_p)
        pp_string (pp, " -> ");
       else
        pp_string (pp, " ! -> ");
-      dump_generic_node (pp, pt, 0, TDF_NONE | TDF_NOUID, false);
-      if (points_to_p)
+      dump_generic_node (pp, addr, 0, TDF_NONE | TDF_NOUID, false);
+      if (known_p)
        {
          int_range_max sz;
          int_range_max off;
          tree b;
-         b = r.pt_base ();
-         r.pt_offset(off);
-         r.pt_size (sz);
+         b = r.addr_base ();
+         r.addr_offset(off);
+         r.addr_size (sz);
          pp_string (pp, " { Base: ");
          dump_generic_node (pp, b, 0, TDF_NONE | TDF_NOUID, false);
          if (!off.varying_p () && !off.undefined_p () && !off.zero_p ())
@@ -178,8 +178,8 @@ vrange_printer::visit (const prange &r) const
   print_int_bound (pp, r.upper_bound (), r.type ());
   pp_character (pp, ']');
   print_irange_bitmasks (pp, r.m_bitmask);
-  // Dump the points to field if there is one.
-  print_pt (r);
+  // Dump the address field if there is one.
+  print_addr (r);
 }
 
 void
diff --git a/gcc/value-range-pretty-print.h b/gcc/value-range-pretty-print.h
index b6e6a4887827..6bcbd4ff7b1f 100644
--- a/gcc/value-range-pretty-print.h
+++ b/gcc/value-range-pretty-print.h
@@ -30,7 +30,7 @@ public:
   void visit (const prange &) const override;
   void visit (const frange &) const override;
 private:
-  void print_pt (const prange &) const;
+  void print_addr (const prange &) const;
   void print_frange_nan (const frange &) const;
   void print_real_value (tree type, const REAL_VALUE_TYPE &r) const;
 
diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc
index d7df014819d8..ce203e67c36c 100644
--- a/gcc/value-range-storage.cc
+++ b/gcc/value-range-storage.cc
@@ -597,8 +597,8 @@ prange_storage::alloc (vrange_internal_alloc &allocator, 
const prange &r,
   size_t size = sizeof (prange_storage) + extra_size;
   prange_storage *p = static_cast <prange_storage *> (allocator.alloc (size));
   new (p) prange_storage (r);
-  if (p->m_pt && !shared_p)
-    p->m_pt = unshare_expr_without_location (p->m_pt);
+  if (p->m_addr && !shared_p)
+    p->m_addr = unshare_expr_without_location (p->m_addr);
 
   return p;
 }
@@ -626,7 +626,7 @@ prange_storage::prange_storage (const prange &r) : 
vrange_storage (VR_PRANGE)
 //
 // Compare the bounds against a fresh set_nonzero () rather than using
 // prange::operator==, because operator== also compares the bitmask and
-// points-to info, which are stored separately here, so a non-null pointer that
+// address info, which are stored separately here, so a non-null pointer that
 // also carries e.g. an alignment bitmask still belongs in PR_NONZERO.
 
 static inline bool
@@ -674,9 +674,9 @@ prange_storage::prange_format (const prange &r, unsigned 
&num_words)
   if (!r.get_bitmask ().unknown_p ())
     num_words += 2;
 
-  // PR_FULL must have a bitmask or points to, or it should be PR_VARYING.
+  // PR_FULL must have a bitmask or an address, or it should be PR_VARYING.
   gcc_checking_assert (kind != PR_FULL || !r.get_bitmask ().unknown_p ()
-                      || r.m_pt != NULL_TREE);
+                      || r.m_addr != NULL_TREE);
   return kind;
 }
 
@@ -686,8 +686,8 @@ prange_storage::set_prange (const prange &r)
   unsigned num_words;
   m_kind = prange_format (r, num_words);
   m_has_bitmask = false;
-  m_points_to_p = false;
-  m_pt = r.m_pt;
+  m_known_p = false;
+  m_addr = r.m_addr;
 
   unsigned index = 0;
 
@@ -709,7 +709,7 @@ prange_storage::set_prange (const prange &r)
     }
 
   m_has_bitmask = !r.get_bitmask ().unknown_p ();
-  m_points_to_p = r.m_points_to_p;
+  m_known_p = r.m_known_p;
 
   if (m_has_bitmask)
     {
@@ -775,8 +775,8 @@ prange_storage::get_prange (prange &r, tree type) const
   else
     r.m_bitmask.set_unknown (TYPE_PRECISION (type));
 
-  r.m_points_to_p = m_points_to_p;
-  r.m_pt = m_pt;
+  r.m_known_p = m_known_p;
+  r.m_addr = m_addr;
 
   if (flag_checking)
     r.verify_range ();
@@ -830,10 +830,10 @@ prange_storage::equal_p (const prange &r) const
     if (!r.m_bitmask.unknown_p ())
       return false;
 
-  if (m_pt != r.m_pt)
+  if (m_addr != r.m_addr)
     return false;
   // Storage objects are only equal If they point to the same memory.
-  if (m_points_to_p != r.m_points_to_p)
+  if (m_known_p != r.m_known_p)
     return false;
 
   return true;
@@ -882,7 +882,7 @@ prange_storage::set_nonnull (tree type)
        else
          {
            // This is very uncoomon, and rather than trying to cover
-           // the edge cases (ie, bitmask present, points to)
+           // the edge cases (ie, bitmask present, address present)
            // simply load the range, remove zero, and resave it.
            prange pr;
            this->get_vrange (pr, type);
diff --git a/gcc/value-range-storage.h b/gcc/value-range-storage.h
index 4deda7ef9f10..a33054b805c6 100644
--- a/gcc/value-range-storage.h
+++ b/gcc/value-range-storage.h
@@ -124,7 +124,7 @@ private:
   // needs eight-byte alignment, so there is a four-byte hole.
   enum prange_kind m_kind : 4;
   unsigned int m_has_bitmask : 1;
-  unsigned int m_points_to_p : 1;
+  unsigned int m_known_p : 1;
 
 public:
   friend void gt_ggc_mx_vrange_storage(void *);
@@ -158,7 +158,7 @@ private:
   prange_storage (const prange &r);
   static enum prange_kind prange_format (const prange &r, unsigned &num_words);
 
-  tree m_pt;
+  tree m_addr;
 
   // We don't use TRAILING_WIDE_INT_ACCESSOR because the getters here
   // must be const.  Perhaps TRAILING_WIDE_INT_ACCESSOR could be made
diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 4a76c91db9b6..8df26d8bff3a 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -464,11 +464,11 @@ add_vrange (const vrange &v, inchash::hash &hstate,
          hstate.add_wide_int (bm.value ());
          hstate.add_wide_int (bm.mask ());
          bool flag = false;
-         tree tmp = r.pt_invariant ();
+         tree tmp = r.addr_known ();
          if (tmp)
            flag = true;
          else
-           tmp = r.pt_invariant_away ();
+           tmp = r.addr_excluded ();
          hstate.add_ptr (tmp);
          hstate.add_flag (flag);
        }
@@ -530,23 +530,23 @@ irange::set_nonnegative (tree type)
 }
 
 
-// Set the points to info for EXPR if possible.  POINTS_TO_P is true if it
-// points to EXPR, and FALSE if it points away.
+// Set the address info to EXPR if possible.  KNOWN_P is TRUE if this range
+// is known to be EXPR, and FALSE if it is known to exclude EXPR.
 
 void
-prange::set_pt (tree expr, bool points_to_p)
+prange::set_addr (tree expr, bool known_p)
 {
   gcc_checking_assert (m_kind != VR_UNDEFINED);
   gcc_checking_assert (!expr || TREE_CODE (expr) != SSA_NAME);
 
-  m_pt = NULL_TREE;
-  m_points_to_p = false;
+  m_addr = NULL_TREE;
+  m_known_p = false;
 
-  // A zero range means no points-to info.
+  // A zero range means no address info.
   if (zero_p ())
     return;
 
-  // No points to initially may make this VARYING.
+  // No address initially may make this VARYING.
   if (varying_compatible_p ())
     set_varying (type ());
   else
@@ -573,37 +573,38 @@ prange::set_pt (tree expr, bool points_to_p)
   if (!size.is_constant ())
     return;
 
-  m_pt = expr;
-  m_points_to_p = points_to_p;
+  m_addr = expr;
+  m_known_p = known_p;
   m_kind = VR_RANGE;
 }
 
 // Return object/allocation the pointer refers into, otherwise NULL_TREE.
 
 tree
-prange::pt_base () const
+prange::addr_base () const
 {
-  if (!m_pt)
+  if (!m_addr || !m_known_p)
     return NULL_TREE;
 
   aff_tree off;
   poly_widest_int sz;
 
-  gcc_checking_assert (m_pt);
-  return get_inner_reference_aff (m_pt, &off, &sz);
+  gcc_checking_assert (m_addr);
+  return get_inner_reference_aff (m_addr, &off, &sz);
 }
 
 // Return possible byte offset range from BASE.
 
 void
-prange::pt_offset (irange &r) const
+prange::addr_offset (irange &r) const
 {
   aff_tree off;
   poly_widest_int sz;
 
-  gcc_checking_assert (m_pt);
+  gcc_checking_assert (m_addr);
+  gcc_checking_assert (m_known_p);
 
-  get_inner_reference_aff (m_pt, &off, &sz);
+  get_inner_reference_aff (m_addr, &off, &sz);
   gcc_checking_assert (off.offset.is_constant ());
 
   widest_int w = off.offset.coeffs[0];
@@ -614,14 +615,15 @@ prange::pt_offset (irange &r) const
 // Return possible size range of the referenced object.
 
 void
-prange::pt_size (irange &r) const
+prange::addr_size (irange &r) const
 {
   aff_tree off;
   poly_widest_int sz;
 
-  gcc_checking_assert (m_pt);
+  gcc_checking_assert (m_addr);
+  gcc_checking_assert (m_known_p);
 
-  get_inner_reference_aff (m_pt, &off, &sz);
+  get_inner_reference_aff (m_addr, &off, &sz);
   gcc_checking_assert (sz.is_constant ());
 
   widest_int w = sz.coeffs[0];
@@ -678,7 +680,7 @@ prange::set (tree type, const wide_int &min, const wide_int 
&max,
     {
       m_kind = VR_VARYING;
       m_bitmask.set_unknown (TYPE_PRECISION (type));
-      set_pt_unknown ();
+      set_addr_unknown ();
       if (flag_checking)
        verify_range ();
       return;
@@ -686,7 +688,7 @@ prange::set (tree type, const wide_int &min, const wide_int 
&max,
 
   m_kind = VR_RANGE;
   m_bitmask = irange_bitmask (type, min, max);
-  set_pt_unknown ();
+  set_addr_unknown ();
   if (flag_checking)
     verify_range ();
 }
@@ -756,10 +758,10 @@ prange::union_ (const vrange &v)
   new_range.m_bitmask.union_ (m_bitmask);
   new_range.m_bitmask.union_ (r.m_bitmask);
 
-  // Keep it simple, either both point to the same thing or both
-  // do not point to the same thing, or we drop the points to info.
-  if (pt_equal_p (r))
-    new_range.set_pt (*this);
+  // Keep it simple, either both name the same address or both do not,
+  // or we drop the address info.
+  if (addr_equal_p (r))
+    new_range.set_addr (*this);
 
   if (new_range.varying_compatible_p ())
     {
@@ -796,8 +798,9 @@ prange::intersect (const vrange &v)
       return true;
     }
 
-  // If this points to and away, results are undefined,
-  if (pt_inverted_p (r))
+  // If one knows the address and the other excludes it, the result is
+  // undefined.
+  if (addr_inverted_p (r))
     {
       set_undefined ();
       return true;
@@ -818,24 +821,24 @@ prange::intersect (const vrange &v)
     set_undefined ();
   else if (!m_bitmask.intersect (r.m_bitmask))
     set_undefined ();
-  // If only one object points to something, that is the intersection.
-  else if (pt_unknown_p () && !r.pt_unknown_p ())
-    set_pt (r);
-  else if (!pt_unknown_p () && !r.pt_unknown_p ())
+  // If only one has an address, that is the intersection.
+  else if (addr_unknown_p () && !r.addr_unknown_p ())
+    set_addr (r);
+  else if (!addr_unknown_p () && !r.addr_unknown_p ())
     {
-      // If both point to something, we want to be careful.  Without aliasing
-      // 2 different values can point to the same thing, so UNDEFINED is
+      // If both have an address, we want to be careful.  Without aliasing
+      // 2 different values can name the same address, so UNDEFINED is
       // not appropriate, but we want to keep the rule that intersection
       // never becomes larger.
-      // If the other object points to something specific, and this one does
-      // not, use the specific one. Otherwise leave the range as is.
-      if (pt_invariant_away () && r.pt_invariant ())
-       set_pt (r);
+      // If the other operand knows an address and this one only excludes
+      // one, use the known one.  Otherwise leave the range as is.
+      if (addr_excluded () && r.addr_known ())
+       set_addr (r);
     }
 
-  //  If this evolves to zero, clear all points-to info.
-  if (zero_p () && !pt_unknown_p ())
-    set_pt_unknown ();
+  //  If this evolves to zero, clear all address info.
+  if (zero_p () && !addr_unknown_p ())
+    set_addr_unknown ();
 
   if (varying_compatible_p ())
     {
@@ -858,7 +861,7 @@ prange::operator= (const prange &src)
   m_min = src.m_min;
   m_max = src.m_max;
   m_bitmask = src.m_bitmask;
-  set_pt (src);
+  set_addr (src);
   if (flag_checking)
     verify_range ();
   return *this;
@@ -875,7 +878,7 @@ prange::operator== (const prange &src) const
       if (varying_p ())
        return types_compatible_p (type (), src.type ());
 
-      if (!pt_equal_p (src))
+      if (!addr_equal_p (src))
        return false;
 
       return (m_min == src.m_min && m_max == src.m_max
@@ -895,10 +898,10 @@ prange::invert ()
     return false;
 
   // Invert the points_to object. If that worked, this is done.
-  if (pt_invert ())
+  if (addr_invert ())
     return true;
   else
-    set_pt_unknown ();
+    set_addr_unknown ();
 
   wide_int new_lb, new_ub;
   unsigned prec = TYPE_PRECISION (type ());
@@ -935,7 +938,7 @@ prange::verify_range () const
 
   if (m_kind == VR_UNDEFINED)
     {
-      gcc_checking_assert (pt_unknown_p ());
+      gcc_checking_assert (addr_unknown_p ());
       return;
     }
 
@@ -948,7 +951,7 @@ prange::verify_range () const
     }
   gcc_checking_assert (!varying_compatible_p ());
   gcc_checking_assert (m_kind == VR_RANGE);
-  if (!pt_unknown_p ())
+  if (!addr_unknown_p ())
     {
       gcc_checking_assert (!varying_p ());
       gcc_checking_assert (!undefined_p ());
diff --git a/gcc/value-range.h b/gcc/value-range.h
index 0b88b46ebc52..6762e60a6625 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -443,43 +443,48 @@ public:
   irange_bitmask get_bitmask () const final override;
   void update_bitmask (const irange_bitmask &) final override;
 
-  // prange interface to points to information.
-  // It can point_to or point_away from an object.  This represents both
-  // sides of a conditional. ie:
+  // prange interface to address information.
+  // It can be known to be a particular address, or exclude that address.
+  // This represents both sides of a conditional. ie:
   //   if (p == &foo)
-  //     // p points to foo.
+  //     // p known to be foo.
   //   else
-  //     // p points away from foo.
-  // pt_invariant () and pt_invariant_away () - Return pt if this is invariant.
-  void set_pt (const prange &r);
-  void set_pt (tree ptr, bool points_to_p = true);
-
-  // unknown_p () is true if no object is pointed to.
-  void set_pt_unknown ();
-  bool pt_unknown_p () const;
-
-  // Invariant points-to are is_gimple_min_invariant_p ().
-  // Return expression or NULL_TREE for points-to or away
-  tree pt_invariant () const;
-  tree pt_invariant_away () const;
-
-  // Return true if THIS and R both point to the same object.
-  bool pt_invariant_p (const prange &r) const;
-  // Return true if THIS and R both point away from the same object.
-  bool pt_invariant_away_p (const prange &r) const;
-  // Return true if THIS and R refer to the same object, and one is inverted
-  // from the other,  Ie, both to and away.
-  bool pt_inverted_p (const prange &r) const;
-
-  // Invert THIS if it points either to or away from an object.
-  bool pt_invert ();
-
-  // pt_base () - object/allocation the pointer refers into.
-  tree pt_base () const;
-  // pt_offset () - possible byte offset range from BASE.
-  void pt_offset (irange &) const;
-  // pt_size () - possible size range of the referenced object.
-  void pt_size (irange &) const;
+  //     // p excludes foo.
+
+  // The address is is_gimple_min_invariant, which is relative to the
+  // current function -- it is NOT is_gimple_ip_invariant, and may name a
+  // local.  Any consumer crossing a function boundary must re-check.
+
+  // Set this address to the same as R, if any.
+  void set_addr (const prange &r);
+  void set_addr (tree addr, bool known_p = true);
+
+  void set_addr_unknown ();
+  bool addr_unknown_p () const;
+
+  // Return expression or NULL_TREE for known or excluded.
+  tree addr_known () const;
+  tree addr_excluded () const;
+
+  // Return true if THIS and R are known to be the same address.
+  bool addr_same_known_p (const prange &r) const;
+  // Return true if THIS and R both exclude the same address.
+  bool addr_same_excluded_p (const prange &r) const;
+
+  // If either known or excluded, invert and return TRUE.
+  bool addr_invert ();
+  // Return true if THIS and R refer to the same address, and one is inverted
+  // from the other,  Ie, both known and excluded
+  bool addr_inverted_p (const prange &r) const;
+
+  // These routines decompose addr to its component parts for a known address.
+
+  // addr_base () - object/allocation the pointer refers into.
+  tree addr_base () const;
+  // addr_offset () - possible byte offset range from BASE.
+  void addr_offset (irange &) const;
+  // addr_size () - possible size range of the referenced object.
+  void addr_size (irange &) const;
 
 protected:
   bool varying_compatible_p () const;
@@ -489,11 +494,12 @@ protected:
   wide_int m_max;
   irange_bitmask m_bitmask;
 
-   // A prange can point to an object, or NOT point to an object.
-  tree m_pt;           // object points-to refers to.
-  bool m_points_to_p;  // Does it point to it (TRUE), or not (FALSE).
-  // If P has the same points to fields as THIS.
-  bool pt_equal_p (const class prange &p) const;
+  // A prange can be known to be a particular address, or known to exclude
+  // one.
+  tree m_addr;         // Address referred to.
+  bool m_known_p;      // Is it known (TRUE), or excluded (FALSE).
+  // Return TRUE if P has the same address fields as THIS.
+  bool addr_equal_p (const class prange &p) const;
 };
 
 // Unsupported temporaries may be created by ranger before it's known
@@ -1400,7 +1406,7 @@ inline void
 prange::set_undefined ()
 {
   m_kind = VR_UNDEFINED;
-  set_pt_unknown ();
+  set_addr_unknown ();
 }
 
 inline void
@@ -1411,7 +1417,7 @@ prange::set_varying (tree type)
   m_min = wi::zero (TYPE_PRECISION (type));
   m_max = wi::max_value (TYPE_PRECISION (type), UNSIGNED);
   m_bitmask.set_unknown (TYPE_PRECISION (type));
-  set_pt_unknown ();
+  set_addr_unknown ();
 
   if (flag_checking)
     verify_range ();
@@ -1425,7 +1431,7 @@ prange::set_nonzero (tree type)
   m_min = wi::one (TYPE_PRECISION (type));
   m_max = wi::max_value (TYPE_PRECISION (type), UNSIGNED);
   m_bitmask.set_unknown (TYPE_PRECISION (type));
-  set_pt_unknown ();
+  set_addr_unknown ();
 
   if (flag_checking)
     verify_range ();
@@ -1439,7 +1445,7 @@ prange::set_zero (tree type)
   wide_int zero = wi::zero (TYPE_PRECISION (type));
   m_min = m_max = zero;
   m_bitmask = irange_bitmask (zero, zero);
-  set_pt_unknown ();
+  set_addr_unknown ();
 
   if (flag_checking)
     verify_range ();
@@ -1493,7 +1499,7 @@ inline bool
 prange::varying_compatible_p () const
 {
   return (!undefined_p () && m_min == 0 && m_max == -1
-         && get_bitmask ().unknown_p () && pt_unknown_p ());
+         && get_bitmask ().unknown_p () && addr_unknown_p ());
 }
 
 inline irange_bitmask
@@ -1508,18 +1514,17 @@ prange::fits_p (const vrange &) const
   return true;
 }
 
-// Set this range's point-to object to PTR, and POINTS_TO_P is TRUE if it
-// does point to it, and FALSE if it does not point to it.
+// Copy the address information from R, if it has any.
 
 inline void
-prange::set_pt (const prange &r)
+prange::set_addr (const prange &r)
 {
-  // Do not set points-to info if this is zero or undefined.
-  if (!r.pt_unknown_p () && (undefined_p () || zero_p()))
+  // Do not set address info if this is zero or undefined.
+  if (!r.addr_unknown_p () && (undefined_p () || zero_p()))
     return;
 
-  m_pt = r.m_pt;
-  m_points_to_p = r.m_points_to_p;
+  m_addr = r.m_addr;
+  m_known_p = r.m_known_p;
 
   if (r.undefined_p ())
     return;
@@ -1534,79 +1539,79 @@ prange::set_pt (const prange &r)
 // ------------------------------------------------------------------
 
 inline void
-prange::set_pt_unknown ()
+prange::set_addr_unknown ()
 {
-  m_pt = NULL_TREE;
-  m_points_to_p = false;
+  m_addr = NULL_TREE;
+  m_known_p = false;
   // If this is a transition from a range, check for varying compatibility.
   if (m_kind == VR_RANGE && varying_compatible_p ())
     m_kind = VR_VARYING;
 }
 
 inline bool
-prange::pt_unknown_p () const
+prange::addr_unknown_p () const
 {
-  return (m_pt == NULL_TREE);
+  return (m_addr == NULL_TREE);
 }
 
 inline bool
-prange::pt_equal_p (const prange &p) const
+prange::addr_equal_p (const prange &p) const
 {
   // A prange object invokes vrp_operand_equal_p as we want ranges to compare
   // equal to each other if they refer to the same object, even if the
   // tree has become unshared.
-  return (m_points_to_p == p.m_points_to_p
-         && vrp_operand_equal_p (m_pt, p.m_pt));
+  return (m_known_p == p.m_known_p
+         && vrp_operand_equal_p (m_addr, p.m_addr));
 }
 
 inline bool
-prange::pt_inverted_p (const prange &r) const
+prange::addr_inverted_p (const prange &r) const
 {
-  return m_pt && vrp_operand_equal_p (m_pt, r.m_pt)
-        && m_points_to_p != r.m_points_to_p;
+  return m_addr && vrp_operand_equal_p (m_addr, r.m_addr)
+        && m_known_p != r.m_known_p;
 }
 
 inline bool
-prange::pt_invert ()
+prange::addr_invert ()
 {
-  if (m_pt)
+  if (m_addr)
     {
-      m_points_to_p = !m_points_to_p;
+      m_known_p = !m_known_p;
       return true;
     }
   return false;
 }
 
 inline tree
-prange::pt_invariant () const
+prange::addr_known () const
 {
-  if (m_pt && m_points_to_p)
-    return m_pt;
+  if (m_addr && m_known_p)
+    return m_addr;
   return NULL_TREE;
 }
 
 inline tree
-prange::pt_invariant_away () const
+prange::addr_excluded () const
 {
-  if (m_pt && !m_points_to_p)
-    return m_pt;
+  if (m_addr && !m_known_p)
+    return m_addr;
   return NULL_TREE;
 }
 
 inline bool
-prange::pt_invariant_p (const prange &r) const
+prange::addr_same_known_p (const prange &r) const
 {
-  if (m_pt && m_points_to_p && vrp_operand_equal_p (r.m_pt, m_pt)
-      && m_points_to_p == r.m_points_to_p)
+  if (m_addr && m_known_p && vrp_operand_equal_p (r.m_addr, m_addr)
+      && m_known_p == r.m_known_p)
     return true;
   return false;
 }
 
 inline bool
-prange::pt_invariant_away_p (const prange &r) const
+prange::addr_same_excluded_p (const prange &r) const
 {
-  if (m_pt && !m_points_to_p && vrp_operand_equal_p (r.m_pt, m_pt)
-      && m_points_to_p == r.m_points_to_p)
+  if (m_addr && !m_known_p && vrp_operand_equal_p (r.m_addr, m_addr)
+      && m_known_p == r.m_known_p)
     return true;
   return false;
 }

Reply via email to