* [COMMITTED] Add an frange::set_nan() variant that takes a nan_state.
@ 2023-05-25 5:35 Aldy Hernandez
2023-05-25 5:35 ` [COMMITTED] Hash known NANs correctly for franges Aldy Hernandez
` (2 more replies)
0 siblings, 3 replies; 4+ messages in thread
From: Aldy Hernandez @ 2023-05-25 5:35 UTC (permalink / raw)
To: GCC patches; +Cc: Andrew MacLeod, Aldy Hernandez
Generalize frange::set_nan() to take a nan_state and make current
set_nan() methods syntactic sugar.
This is in preparation for better streaming of NANs for LTO/IPA.
gcc/ChangeLog:
* value-range.h (frange::set_nan): New.
---
gcc/value-range.h | 32 +++++++++++++++++---------------
1 file changed, 17 insertions(+), 15 deletions(-)
diff --git a/gcc/value-range.h b/gcc/value-range.h
index b8cc2a0e76a..39023e7b5eb 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -327,6 +327,7 @@ public:
const nan_state &, value_range_kind = VR_RANGE);
void set_nan (tree type);
void set_nan (tree type, bool sign);
+ void set_nan (tree type, const nan_state &);
virtual void set_varying (tree type) override;
virtual void set_undefined () override;
virtual bool union_ (const vrange &) override;
@@ -1219,17 +1220,18 @@ frange_val_is_max (const REAL_VALUE_TYPE &r, const_tree type)
return real_identical (&max, &r);
}
-// Build a signless NAN of type TYPE.
+// Build a NAN with a state of NAN.
inline void
-frange::set_nan (tree type)
+frange::set_nan (tree type, const nan_state &nan)
{
+ gcc_checking_assert (nan.pos_p () || nan.neg_p ());
if (HONOR_NANS (type))
{
m_kind = VR_NAN;
m_type = type;
- m_pos_nan = true;
- m_neg_nan = true;
+ m_neg_nan = nan.neg_p ();
+ m_pos_nan = nan.pos_p ();
if (flag_checking)
verify_range ();
}
@@ -1237,22 +1239,22 @@ frange::set_nan (tree type)
set_undefined ();
}
+// Build a signless NAN of type TYPE.
+
+inline void
+frange::set_nan (tree type)
+{
+ nan_state nan (true);
+ set_nan (type, nan);
+}
+
// Build a NAN of type TYPE with SIGN.
inline void
frange::set_nan (tree type, bool sign)
{
- if (HONOR_NANS (type))
- {
- m_kind = VR_NAN;
- m_type = type;
- m_neg_nan = sign;
- m_pos_nan = !sign;
- if (flag_checking)
- verify_range ();
- }
- else
- set_undefined ();
+ nan_state nan (/*pos=*/!sign, /*neg=*/sign);
+ set_nan (type, nan);
}
// Return TRUE if range is known to be finite.
--
2.40.1
^ permalink raw reply [flat|nested] 4+ messages in thread
* [COMMITTED] Hash known NANs correctly for franges.
2023-05-25 5:35 [COMMITTED] Add an frange::set_nan() variant that takes a nan_state Aldy Hernandez
@ 2023-05-25 5:35 ` Aldy Hernandez
2023-05-25 5:35 ` [COMMITTED] Disallow setting of NANs in frange setter unless setting trees Aldy Hernandez
2023-05-25 5:35 ` [COMMITTED] Stream out NANs correctly Aldy Hernandez
2 siblings, 0 replies; 4+ messages in thread
From: Aldy Hernandez @ 2023-05-25 5:35 UTC (permalink / raw)
To: GCC patches; +Cc: Andrew MacLeod, Aldy Hernandez
We're ICEing when trying to hash a known NAN. This is unnoticeable
because the only user would be IPA, and even so, it currently doesn't
handle floats. However, handling floats is a flip of a switch, so
it's best to handle them already.
gcc/ChangeLog:
* value-range.cc (add_vrange): Handle known NANs.
---
gcc/value-range.cc | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 874a1843ebf..2f37ff3e58e 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -269,14 +269,14 @@ add_vrange (const vrange &v, inchash::hash &hstate,
if (is_a <frange> (v))
{
const frange &r = as_a <frange> (v);
- if (r.varying_p ())
- hstate.add_int (VR_VARYING);
+ if (r.known_isnan ())
+ hstate.add_int (VR_NAN);
else
- hstate.add_int (VR_RANGE);
-
- hstate.add_real_value (r.lower_bound ());
- hstate.add_real_value (r.upper_bound ());
-
+ {
+ hstate.add_int (r.varying_p () ? VR_VARYING : VR_RANGE);
+ hstate.add_real_value (r.lower_bound ());
+ hstate.add_real_value (r.upper_bound ());
+ }
nan_state nan = r.get_nan_state ();
hstate.add_int (nan.pos_p ());
hstate.add_int (nan.neg_p ());
--
2.40.1
^ permalink raw reply [flat|nested] 4+ messages in thread
* [COMMITTED] Disallow setting of NANs in frange setter unless setting trees.
2023-05-25 5:35 [COMMITTED] Add an frange::set_nan() variant that takes a nan_state Aldy Hernandez
2023-05-25 5:35 ` [COMMITTED] Hash known NANs correctly for franges Aldy Hernandez
@ 2023-05-25 5:35 ` Aldy Hernandez
2023-05-25 5:35 ` [COMMITTED] Stream out NANs correctly Aldy Hernandez
2 siblings, 0 replies; 4+ messages in thread
From: Aldy Hernandez @ 2023-05-25 5:35 UTC (permalink / raw)
To: GCC patches; +Cc: Andrew MacLeod, Aldy Hernandez
frange::set() is confusing in that we can set a NAN by specifying a
bound of +-NAN, even though we tecnically disallow NANs in the setter
because the kind can never be VR_NAN. This is a wart for
get_tree_range(), which builds a range out of a tree from the source,
to work correctly. It's ugly, and it showed its limitation while
implementing LTO streaming of ranges.
This patch disallows passing NAN bounds in frange::set() and fixes
get_tree_range.
gcc/ChangeLog:
* value-query.cc (range_query::get_tree_range): Set NAN directly
if necessary.
* value-range.cc (frange::set): Assert that bounds are not NAN.
---
gcc/value-query.cc | 13 ++++++++++---
gcc/value-range.cc | 9 +--------
2 files changed, 11 insertions(+), 11 deletions(-)
diff --git a/gcc/value-query.cc b/gcc/value-query.cc
index 43297f17c39..a84f164d77b 100644
--- a/gcc/value-query.cc
+++ b/gcc/value-query.cc
@@ -189,9 +189,16 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt)
{
frange &f = as_a <frange> (r);
REAL_VALUE_TYPE *rv = TREE_REAL_CST_PTR (expr);
- f.set (TREE_TYPE (expr), *rv, *rv);
- if (!real_isnan (rv))
- f.clear_nan ();
+ if (real_isnan (rv))
+ {
+ bool sign = real_isneg (rv);
+ f.set_nan (TREE_TYPE (expr), sign);
+ }
+ else
+ {
+ nan_state nan (false);
+ f.set (TREE_TYPE (expr), *rv, *rv, nan);
+ }
return true;
}
diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 2f37ff3e58e..707b1f15fd4 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -359,14 +359,7 @@ frange::set (tree type,
gcc_unreachable ();
}
- // Handle NANs.
- if (real_isnan (&min) || real_isnan (&max))
- {
- gcc_checking_assert (real_identical (&min, &max));
- bool sign = real_isneg (&min);
- set_nan (type, sign);
- return;
- }
+ gcc_checking_assert (!real_isnan (&min) && !real_isnan (&max));
m_kind = kind;
m_type = type;
--
2.40.1
^ permalink raw reply [flat|nested] 4+ messages in thread
* [COMMITTED] Stream out NANs correctly.
2023-05-25 5:35 [COMMITTED] Add an frange::set_nan() variant that takes a nan_state Aldy Hernandez
2023-05-25 5:35 ` [COMMITTED] Hash known NANs correctly for franges Aldy Hernandez
2023-05-25 5:35 ` [COMMITTED] Disallow setting of NANs in frange setter unless setting trees Aldy Hernandez
@ 2023-05-25 5:35 ` Aldy Hernandez
2 siblings, 0 replies; 4+ messages in thread
From: Aldy Hernandez @ 2023-05-25 5:35 UTC (permalink / raw)
To: GCC patches; +Cc: Andrew MacLeod, Aldy Hernandez
NANs don't have bounds, so there's no need to stream them out.
gcc/ChangeLog:
* data-streamer-in.cc (streamer_read_value_range): Handle NANs.
* data-streamer-out.cc (streamer_write_vrange): Same.
* value-range.h (class vrange): Make streamer_write_vrange a friend.
---
gcc/data-streamer-in.cc | 16 ++++++++++++----
gcc/data-streamer-out.cc | 17 ++++++++++++-----
gcc/value-range.h | 1 +
3 files changed, 25 insertions(+), 9 deletions(-)
diff --git a/gcc/data-streamer-in.cc b/gcc/data-streamer-in.cc
index 07728bef413..578c328475f 100644
--- a/gcc/data-streamer-in.cc
+++ b/gcc/data-streamer-in.cc
@@ -248,14 +248,22 @@ streamer_read_value_range (class lto_input_block *ib, data_in *data_in,
if (is_a <frange> (vr))
{
frange &r = as_a <frange> (vr);
- REAL_VALUE_TYPE lb, ub;
- streamer_read_real_value (ib, &lb);
- streamer_read_real_value (ib, &ub);
+
+ // Stream in NAN bits.
struct bitpack_d bp = streamer_read_bitpack (ib);
bool pos_nan = (bool) bp_unpack_value (&bp, 1);
bool neg_nan = (bool) bp_unpack_value (&bp, 1);
nan_state nan (pos_nan, neg_nan);
- r.set (type, lb, ub, nan);
+
+ if (kind == VR_NAN)
+ r.set_nan (type, nan);
+ else
+ {
+ REAL_VALUE_TYPE lb, ub;
+ streamer_read_real_value (ib, &lb);
+ streamer_read_real_value (ib, &ub);
+ r.set (type, lb, ub, nan);
+ }
return;
}
gcc_unreachable ();
diff --git a/gcc/data-streamer-out.cc b/gcc/data-streamer-out.cc
index afc9862062b..93dedfcb895 100644
--- a/gcc/data-streamer-out.cc
+++ b/gcc/data-streamer-out.cc
@@ -410,7 +410,7 @@ streamer_write_vrange (struct output_block *ob, const vrange &v)
gcc_checking_assert (!v.undefined_p ());
// Write the common fields to all vranges.
- value_range_kind kind = v.varying_p () ? VR_VARYING : VR_RANGE;
+ value_range_kind kind = v.m_kind;
streamer_write_enum (ob->main_stream, value_range_kind, VR_LAST, kind);
stream_write_tree (ob, v.type (), true);
@@ -429,15 +429,22 @@ streamer_write_vrange (struct output_block *ob, const vrange &v)
if (is_a <frange> (v))
{
const frange &r = as_a <frange> (v);
- REAL_VALUE_TYPE lb = r.lower_bound ();
- REAL_VALUE_TYPE ub = r.upper_bound ();
- streamer_write_real_value (ob, &lb);
- streamer_write_real_value (ob, &ub);
+
+ // Stream out NAN bits.
bitpack_d bp = bitpack_create (ob->main_stream);
nan_state nan = r.get_nan_state ();
bp_pack_value (&bp, nan.pos_p (), 1);
bp_pack_value (&bp, nan.neg_p (), 1);
streamer_write_bitpack (&bp);
+
+ // Stream out bounds.
+ if (kind != VR_NAN)
+ {
+ REAL_VALUE_TYPE lb = r.lower_bound ();
+ REAL_VALUE_TYPE ub = r.upper_bound ();
+ streamer_write_real_value (ob, &lb);
+ streamer_write_real_value (ob, &ub);
+ }
return;
}
gcc_unreachable ();
diff --git a/gcc/value-range.h b/gcc/value-range.h
index 39023e7b5eb..2b4ebabe7c8 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -76,6 +76,7 @@ class GTY((user)) vrange
{
template <typename T> friend bool is_a (vrange &);
friend class Value_Range;
+ friend void streamer_write_vrange (struct output_block *, const vrange &);
public:
virtual void accept (const class vrange_visitor &v) const = 0;
virtual void set (tree, tree, value_range_kind = VR_RANGE);
--
2.40.1
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2023-05-25 5:35 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-05-25 5:35 [COMMITTED] Add an frange::set_nan() variant that takes a nan_state Aldy Hernandez
2023-05-25 5:35 ` [COMMITTED] Hash known NANs correctly for franges Aldy Hernandez
2023-05-25 5:35 ` [COMMITTED] Disallow setting of NANs in frange setter unless setting trees Aldy Hernandez
2023-05-25 5:35 ` [COMMITTED] Stream out NANs correctly Aldy Hernandez
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).