https://gcc.gnu.org/g:36e877996936abd8bd08f8b1d983c8d1023a5842
commit r15-312-g36e877996936abd8bd08f8b1d983c8d1023a5842
Author: Aldy Hernandez <al...@redhat.com>
Date: Tue May 7 14:05:50 2024 +0200
Enable prange support.
This throws the switch on prange. After this patch, it is no longer
valid to store a pointer in an irange (or vice versa). Instead, they
must go in prange, which is faster and more memory efficient.
I will push this now, so I have time to do any follow-up bugfixing
before going on paternity leave.
There are various cleanups we plan on doing after this patch (faster
intersect/union, remove range-op-mixed.h, remove value_range in favor
of int_range_max, reclaim the name for the Value_Range temporary,
clean up range-ops, etc etc). But we will hold off on those for now
to make it easier to revert this patch, if for some reason we need to
do so while I'm away.
Tested on x86-64 Linux.
gcc/ChangeLog:
* gimple-range-cache.cc (sbr_sparse_bitmap::sbr_sparse_bitmap):
Change irange to prange.
* gimple-range-fold.cc (fold_using_range::fold_stmt): Same.
(fold_using_range::range_of_address): Same.
* gimple-range-fold.h (range_of_address): Same.
* gimple-range-infer.cc (gimple_infer_range::add_nonzero): Same.
* gimple-range-op.cc (class cfn_strlen): Same.
* gimple-range-path.cc
(path_range_query::adjust_for_non_null_uses): Same.
* gimple-ssa-warn-access.cc (pass_waccess::check_pointer_uses):
Same.
* tree-ssa-structalias.cc (find_what_p_points_to): Same.
* range-op-ptr.cc (range_op_table::initialize_pointer_ops): Remove
hybrid entries in table.
* range-op.cc (range_op_table::range_op_table): Add pointer
entries for bitwise and/or and min/max.
* value-range.cc (irange::verify_range): Add assert.
* value-range.h (irange::varying_compatible_p): Remove check for
error_mark_node.
(irange::supports_p): Remove pointer support.
* ipa-cp.h (ipa_supports_p): Add prange support.
Diff:
---
gcc/gimple-range-cache.cc | 4 ++--
gcc/gimple-range-fold.cc | 4 ++--
gcc/gimple-range-fold.h | 2 +-
gcc/gimple-range-infer.cc | 2 +-
gcc/gimple-range-op.cc | 2 +-
gcc/gimple-range-path.cc | 2 +-
gcc/gimple-ssa-warn-access.cc | 2 +-
gcc/ipa-cp.h | 2 +-
gcc/range-op-ptr.cc | 4 ----
gcc/range-op.cc | 18 ++++--------------
gcc/tree-ssa-structalias.cc | 2 +-
gcc/value-range.cc | 1 +
gcc/value-range.h | 4 ++--
13 files changed, 18 insertions(+), 31 deletions(-)
diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc
index 72ac25523117..bdd2832873aa 100644
--- 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))
{
- int_range<2> nonzero;
+ prange nonzero;
nonzero.set_nonzero (t);
m_range[1] = m_range_allocator->clone (nonzero);
- int_range<2> zero;
+ prange 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 9c4ad1ee7b91..a9c8c4d03e63 100644
--- 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 <irange> (r), s, src);
+ return range_of_address (as_a <prange> (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 (irange &r, gimple *stmt, fur_source &src)
+fold_using_range::range_of_address (prange &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 7cbe15d05e53..c7c599bfc939 100644
--- 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 (irange &r, gimple *s, fur_source &src);
+ bool range_of_address (prange &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 c8e8b9b60ac1..d5e1aa142758 100644
--- 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;
- int_range<2> nz;
+ prange 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 55dfbb23ce22..ddd13ec55942 100644
--- 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 irange &,
+ virtual bool fold_range (irange &r, tree type, const prange &,
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 96c6ac6b6a50..f1a12f76144c 100644
--- 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)
{
- int_range_max r;
+ prange r;
bitmap_iterator bi;
unsigned i;
diff --git a/gcc/gimple-ssa-warn-access.cc b/gcc/gimple-ssa-warn-access.cc
index 2c10d19e7f36..0cd5b6d6ef48 100644
--- 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. */
- value_range vr;
+ prange 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 abeaaa4053e1..e62a09f38af6 100644
--- 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);
+ return irange::supports_p (type) || prange::supports_p (type);
}
#endif /* IPA_CP_H */
diff --git a/gcc/range-op-ptr.cc b/gcc/range-op-ptr.cc
index 466edc6bf746..4d5cbda764ca 100644
--- a/gcc/range-op-ptr.cc
+++ b/gcc/range-op-ptr.cc
@@ -1968,8 +1968,4 @@ 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 65f3843227dc..245385fe4876 100644
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -102,23 +102,13 @@ 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);
-
- // 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);
+ 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 9c63305063c1..bb59c6a7c023 100644
--- 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;
- value_range vr;
+ prange 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 3e1ecf69517c..ada941bf3b5b 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -1518,6 +1518,7 @@ 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 6fe31d675823..6e24874c0a25 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -988,7 +988,7 @@ irange::varying_compatible_p () const
const wide_int &u = m_base[1];
tree t = m_type;
- if (m_kind == VR_VARYING && t == error_mark_node)
+ if (m_kind == VR_VARYING)
return true;
unsigned prec = TYPE_PRECISION (t);
@@ -1033,7 +1033,7 @@ irange::nonzero_p () const
inline bool
irange::supports_p (const_tree type)
{
- return INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type);
+ return INTEGRAL_TYPE_P (type);
}
inline bool
