Revert: "Enable prange support." [PR114985]

This reverts commit 36e877996936abd8bd08f8b1d983c8d1023a5842 until the IPA
pass is fixed with regards to POINTER = POINTER <RELOP> POINTER.

diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc
index bdd2832873aa973ed028f22267929cdab2a7d52c..72ac255231172c903f573758bfb0a4056768b95a 100644 (file)
--- a/gcc/gimple-range-cache.cc
+++ b/gcc/gimple-range-cache.cc
@@ -274,10 +274,10 @@ sbr_sparse_bitmap::sbr_sparse_bitmap (tree t, vrange_allocator *allocator,
   // Pre-cache zero and non-zero values for pointers.
   if (POINTER_TYPE_P (t))
     {
-      prange nonzero;
+      int_range<2> nonzero;
       nonzero.set_nonzero (t);
       m_range[1] = m_range_allocator->clone (nonzero);
-      prange zero;
+      int_range<2> zero;
       zero.set_zero (t);
       m_range[2] = m_range_allocator->clone (zero);
     }

diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc
index a9c8c4d03e631d963c100637149287921cdc45b0..9c4ad1ee7b910153f36b6b765e9f8e1435ffc952 100644 (file)
--- a/gcc/gimple-range-fold.cc
+++ b/gcc/gimple-range-fold.cc
@@ -597,7 +597,7 @@ fold_using_range::fold_stmt (vrange &r, gimple *s, fur_source &src, tree name)
   // Process addresses.
   if (gimple_code (s) == GIMPLE_ASSIGN
       && gimple_assign_rhs_code (s) == ADDR_EXPR)
-    return range_of_address (as_a <prange> (r), s, src);
+    return range_of_address (as_a <irange> (r), s, src);
 
   gimple_range_op_handler handler (s);
   if (handler)
@@ -757,7 +757,7 @@ fold_using_range::range_of_range_op (vrange &r,
 // If a range cannot be calculated, set it to VARYING and return true.
 
 bool
-fold_using_range::range_of_address (prange &r, gimple *stmt, fur_source &src)
+fold_using_range::range_of_address (irange &r, gimple *stmt, fur_source &src)
 {
   gcc_checking_assert (gimple_code (stmt) == GIMPLE_ASSIGN);
   gcc_checking_assert (gimple_assign_rhs_code (stmt) == ADDR_EXPR);

diff --git a/gcc/gimple-range-fold.h b/gcc/gimple-range-fold.h
index c7c599bfc939171d31c65e25aa5459ec6abd2926..7cbe15d05e5310e1ac3c5633a378f4058783fc7d 100644 (file)
--- a/gcc/gimple-range-fold.h
+++ b/gcc/gimple-range-fold.h
@@ -157,7 +157,7 @@ protected:
                          fur_source &src);
   bool range_of_call (vrange &r, gcall *call, fur_source &src);
   bool range_of_cond_expr (vrange &r, gassign* cond, fur_source &src);
-  bool range_of_address (prange &r, gimple *s, fur_source &src);
+  bool range_of_address (irange &r, gimple *s, fur_source &src);
   bool range_of_phi (vrange &r, gphi *phi, fur_source &src);
   void range_of_ssa_name_with_loop_info (vrange &, tree, class loop *, gphi *,
                                         fur_source &src);

diff --git a/gcc/gimple-range-infer.cc b/gcc/gimple-range-infer.cc
index d5e1aa142758a9bc539d22c38c2535a0a71e8f49..c8e8b9b60ac1bb69accd10e6aec8453f6dadef66 100644 (file)
--- a/gcc/gimple-range-infer.cc
+++ b/gcc/gimple-range-infer.cc
@@ -123,7 +123,7 @@ gimple_infer_range::add_nonzero (tree name)
 {
   if (!gimple_range_ssa_p (name))
     return;
-  prange nz;
+  int_range<2> nz;
   nz.set_nonzero (TREE_TYPE (name));
   add_range (name, nz);
 }

diff --git a/gcc/gimple-range-op.cc b/gcc/gimple-range-op.cc
index ddd13ec559426fc7c4744170daa644fc04cd62b5..55dfbb23ce22c80e79626d63257a9f675f6f1e01 100644 (file)
--- a/gcc/gimple-range-op.cc
+++ b/gcc/gimple-range-op.cc
@@ -1120,7 +1120,7 @@ class cfn_strlen : public range_operator
 {
 public:
   using range_operator::fold_range;
-  virtual bool fold_range (irange &r, tree type, const prange &,
+  virtual bool fold_range (irange &r, tree type, const irange &,
                           const irange &, relation_trio) const
   {
     wide_int max = irange_val_max (ptrdiff_type_node);

diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc
index f1a12f76144cc4c89d5690b2f7574545e6aea25e..96c6ac6b6a5020107a7194ad9fd855d291f4bb7e 100644 (file)
--- a/gcc/gimple-range-path.cc
+++ b/gcc/gimple-range-path.cc
@@ -443,7 +443,7 @@ path_range_query::compute_ranges_in_block (basic_block bb)
 void
 path_range_query::adjust_for_non_null_uses (basic_block bb)
 {
-  prange r;
+  int_range_max r;
   bitmap_iterator bi;
   unsigned i;
 

diff --git a/gcc/gimple-ssa-warn-access.cc b/gcc/gimple-ssa-warn-access.cc
index 0cd5b6d6ef48532b4957333c186b3145d6e2e362..2c10d19e7f36ec030eab3d22151eb62659d2be56 100644 (file)
--- a/gcc/gimple-ssa-warn-access.cc
+++ b/gcc/gimple-ssa-warn-access.cc
@@ -4213,7 +4213,7 @@ pass_waccess::check_pointer_uses (gimple *stmt, tree ptr,
                 where the realloc call is known to have failed are valid.
                 Ignore pointers that nothing is known about.  Those could
                 have escaped along with their nullness.  */
-             prange vr;
+             value_range vr;
              if (m_ptr_qry.rvals->range_of_expr (vr, realloc_lhs, use_stmt))
                {
                  if (vr.zero_p ())

diff --git a/gcc/ipa-cp.h b/gcc/ipa-cp.h
index e62a09f38af6d46e7577c81074e6e0bd1955ccbf..abeaaa4053e190cf8645a8be27607115a34555bb 100644 (file)
--- a/gcc/ipa-cp.h
+++ b/gcc/ipa-cp.h
@@ -296,7 +296,7 @@ bool values_equal_for_ipcp_p (tree x, tree y);
 static inline bool
 ipa_supports_p (tree type)
 {
-  return irange::supports_p (type) || prange::supports_p (type);
+  return irange::supports_p (type);
 }
 
 #endif /* IPA_CP_H */

diff --git a/gcc/range-op-ptr.cc b/gcc/range-op-ptr.cc
index 4d5cbda764cafce28f013cfce4f6f6f2b09d1a27..466edc6bf7460cae4d363afeca7d8cbf14419f68 100644 (file)
--- a/gcc/range-op-ptr.cc
+++ b/gcc/range-op-ptr.cc
@@ -1968,4 +1968,8 @@ range_op_table::initialize_pointer_ops ()
 {
   set (POINTER_PLUS_EXPR, op_pointer_plus);
   set (POINTER_DIFF_EXPR, op_pointer_diff);
+  set (BIT_AND_EXPR, op_hybrid_and);
+  set (BIT_IOR_EXPR, op_hybrid_or);
+  set (MIN_EXPR, op_hybrid_min);
+  set (MAX_EXPR, op_hybrid_max);
 }

diff --git a/gcc/range-op.cc b/gcc/range-op.cc
index e00136479a6db98784fecd9cb7b7dd02a17cdec7..a134af68141e0502d6b44dab36e2c9fbaf404246 100644 (file)
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -102,13 +102,23 @@ range_op_table::range_op_table ()
   set (MINUS_EXPR, op_minus);
   set (NEGATE_EXPR, op_negate);
   set (MULT_EXPR, op_mult);
+
+  // Occur in both integer and pointer tables, but currently share
+  // integral implementation.
   set (ADDR_EXPR, op_addr);
   set (BIT_NOT_EXPR, op_bitwise_not);
   set (BIT_XOR_EXPR, op_bitwise_xor);
-  set (BIT_AND_EXPR, op_bitwise_and);
-  set (BIT_IOR_EXPR, op_bitwise_or);
-  set (MIN_EXPR, op_min);
-  set (MAX_EXPR, op_max);
+
+  // These are in both integer and pointer tables, but pointer has a different
+  // implementation.
+  // If commented out, there is a hybrid version in range-op-ptr.cc which
+  // is used until there is a pointer range class.  Then we can simply
+  // uncomment the operator here and use the unified version.
+
+  // set (BIT_AND_EXPR, op_bitwise_and);
+  // set (BIT_IOR_EXPR, op_bitwise_or);
+  // set (MIN_EXPR, op_min);
+  // set (MAX_EXPR, op_max);
 }
 
 // Instantiate a default range operator for opcodes with no entry.

diff --git a/gcc/tree-ssa-structalias.cc b/gcc/tree-ssa-structalias.cc
index bb59c6a7c0236267b1f3ca05c9dde081156dd855..9c63305063c11753e952d164276572831219dbc6 100644 (file)
--- a/gcc/tree-ssa-structalias.cc
+++ b/gcc/tree-ssa-structalias.cc
@@ -6833,7 +6833,7 @@ find_what_p_points_to (tree fndecl, tree p)
   struct ptr_info_def *pi;
   tree lookup_p = p;
   varinfo_t vi;
-  prange vr;
+  value_range vr;
   get_range_query (DECL_STRUCT_FUNCTION (fndecl))->range_of_expr (vr, p);
   bool nonnull = vr.nonzero_p ();
 

diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index ada941bf3b5bfb78d78074b846b124cb9a449f7d..3e1ecf69517cdba92995b18930e1420b6034fe8a 100644 (file)
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -1518,7 +1518,6 @@ irange::verify_range ()
       gcc_checking_assert (m_num_ranges == 0);
       return;
     }
-  gcc_checking_assert (supports_p (type ()));
   gcc_checking_assert (m_num_ranges <= m_max_ranges);
 
   // Legacy allowed these to represent VARYING for unknown types.

diff --git a/gcc/value-range.h b/gcc/value-range.h
index 44cdbd717f4c5f38e5f51924351ce125d18dedf6..37ce91dc52d1c10297a19cf9b0293c0eb9309f87 100644 (file)
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -994,7 +994,7 @@ irange::varying_compatible_p () const
   const wide_int &u = m_base[1];
   tree t = m_type;
 
-  if (m_kind == VR_VARYING)
+  if (m_kind == VR_VARYING && t == error_mark_node)
     return true;
 
   unsigned prec = TYPE_PRECISION (t);
@@ -1039,7 +1039,7 @@ irange::nonzero_p () const
 inline bool
 irange::supports_p (const_tree type)
 {
-  return INTEGRAL_TYPE_P (type);
+  return INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type);
 }
 
 inline bool