Re: [PATCH] [PR24021] Implement PLUS_EXPR range-op entry for floats.

[Aldy Hernandez <aldyh@redhat.com>]

[-- Attachment #1: Type: text/plain, Size: 4609 bytes --]

On Tue, Nov 8, 2022 at 2:15 PM Jakub Jelinek <jakub@redhat.com> wrote:
>
> On Tue, Nov 08, 2022 at 01:47:58PM +0100, Aldy Hernandez wrote:
> > On Tue, Nov 8, 2022 at 12:07 PM Jakub Jelinek <jakub@redhat.com> wrote:
> > >
> > > On Mon, Nov 07, 2022 at 04:38:29PM +0100, Aldy Hernandez wrote:
> > > > From d214bcdff2cb90ad1eb808d29bda6fb98d510b4c Mon Sep 17 00:00:00 2001
> > > > From: Aldy Hernandez <aldyh@redhat.com>
> > > > Date: Mon, 7 Nov 2022 14:18:57 +0100
> > > > Subject: [PATCH] Provide normalized and denormal format version of
> > > >  real_isdenormal.
> > > >
> > > > Implement real_isdenormal_target() to be used within real.cc where the
> > > > argument is known to be in denormal format.  Rewrite real_isdenormal()
> > > > for use outside of real.cc where the argument is known to be
> > > > normalized.
> > > >
> > > > gcc/ChangeLog:
> > > >
> > > >       * real.cc (real_isdenormal_target): New.
> > > >       (encode_ieee_single): Use real_isdenormal_target.
> > > >       (encode_ieee_double): Same.
> > > >       (encode_ieee_extended): Same.
> > > >       (encode_ieee_quad): Same.
> > > >       (encode_ieee_half): Same.
> > > >       (encode_arm_bfloat_half): Same.
> > > >       * value-range.cc (frange::flush_denormals_to_zero): Same.
> > > >       * real.h (real_isdenormal): Rewrite to look at mode.
> > >
> > > I'd make real_isdenormal_target static inline bool
> > > rather than inline bool, it is only defined in real.cc, so there is
> > > no point exporting it.
> >
> > Huh.  I thought inline alone would inhibit the exporting.  Thanks.
>
> That is what happens with C99 inline (unless there is extern for the decl),
> but C++ inline is different.  It isn't guaranteed to be exported, but
> with -fkeep-inline-functions or if you say take address of the inline
> in a way that can't be optimized back into a call to the inline (or even
> just call it with -O0), it is exported.
> >
> > > Though, as you've added the mode argument, the real.cc inline
> > > could very well also be called real_isdenormal too, it wouldn't be
> > > a redeclaration or ODR violation.
> >
> > Great, even better.
> >
> > OK pending tests?
> > Aldy
>
> > From c3ca1d606bfb22bf4f8bc7ac0ce561bd6afc3368 Mon Sep 17 00:00:00 2001
> > From: Aldy Hernandez <aldyh@redhat.com>
> > Date: Mon, 7 Nov 2022 14:18:57 +0100
> > Subject: [PATCH] Provide normalized and denormal format version of
> >  real_isdenormal.
> >
> > Implement a variant of real_isdenormal() to be used within real.cc
> > where the argument is known to be in denormal format.  Rewrite
> > real_isdenormal() for use outside of real.cc where the argument is
> > known to be normalized.
> >
> > gcc/ChangeLog:
> >
> >       * real.cc (real_isdenormal): New.
> >       * real.h (real_isdenormal): Add mode argument.  Rewrite for
> >       normalized values.
> >       * value-range.cc (frange::flush_denormals_to_zero): Pass mode to
> >       real_isdenormal.
> > ---
> >  gcc/real.cc        | 10 ++++++++++
> >  gcc/real.h         |  7 ++++---
> >  gcc/value-range.cc |  5 +++--
> >  3 files changed, 17 insertions(+), 5 deletions(-)
> >
> > diff --git a/gcc/real.cc b/gcc/real.cc
> > index aae7c335d59..028aad95ec4 100644
> > --- a/gcc/real.cc
> > +++ b/gcc/real.cc
> > @@ -111,6 +111,16 @@ static const REAL_VALUE_TYPE * real_digit (int);
> >  static void times_pten (REAL_VALUE_TYPE *, int);
> >
> >  static void round_for_format (const struct real_format *, REAL_VALUE_TYPE *);
> > +
> > +/* Determine whether a floating-point value X is a denormal.  R is
> > +   expected to be in denormal form, so this function is only
> > +   meaningful after a call to round_for_format.  */
> > +
> > +static inline bool
> > +real_isdenormal (const REAL_VALUE_TYPE *r)
> > +{
> > +  return (r->sig[SIGSZ-1] & SIG_MSB) == 0;
>
> I would probably keep the r->cl == rvc_normal in here too.
> I know the code in real.cc didn't do it before, but what
> r->sig is for the rvc_zero/rvc_inf is unclear.  It is true
> that get_zero/get_canonical_?nan/get_inf clear the whole sig,
> but not really sure if we guarantee that everywhere.
> The real.cc uses were like:
>   bool denormal = ...;
> at the start of the function and then
>   switch (...)
>     {
> ...
>     case rvc_normal:
>       if (denormal)
>         ...
>     }
> so another even better possibility would be to use your simple
> real.cc (real_isdenormal) and drop all the denormal variables, so:
> - bool denormal = ...;
>   switch (...)
>     {
> ...
>     case rvc_normal:
> -     if (denormal)
> +     if (real_isdenormal (r))
>         ...
>     }

Sure.

Attached patch in testing.

Aldy

[-- Attachment #2: 0001-Provide-normalized-and-denormal-format-version-of-re.patch --]
[-- Type: text/x-patch, Size: 6888 bytes --]

From d02ce8eaf16d2fc6db6472268fd962e09c2fd81e Mon Sep 17 00:00:00 2001
From: Aldy Hernandez <aldyh@redhat.com>
Date: Mon, 7 Nov 2022 14:18:57 +0100
Subject: [PATCH] Provide normalized and denormal format version of
 real_isdenormal.

Implement a variant of real_isdenormal() to be used within real.cc
where the argument is known to be in denormal format.  Rewrite
real_isdenormal() for use outside of real.cc where the argument is
known to be normalized.

gcc/ChangeLog:

	* real.cc (real_isdenormal): New.
	(encode_ieee_single): Call real_isdenormal.
	(encode_ieee_double): Same.
	(encode_ieee_extended): Same.
	(encode_ieee_quad): Same.
	(encode_ieee_half): Same.
	(encode_arm_bfloat_half): Same.
	* real.h (real_isdenormal): Add mode argument.  Rewrite for
	normalized values.
	* value-range.cc (frange::flush_denormals_to_zero): Pass mode to
	real_isdenormal.
---
 gcc/real.cc        | 28 ++++++++++++++++------------
 gcc/real.h         |  7 ++++---
 gcc/value-range.cc |  5 +++--
 3 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/gcc/real.cc b/gcc/real.cc
index aae7c335d59..1c71858dd01 100644
--- a/gcc/real.cc
+++ b/gcc/real.cc
@@ -111,6 +111,16 @@ static const REAL_VALUE_TYPE * real_digit (int);
 static void times_pten (REAL_VALUE_TYPE *, int);
 
 static void round_for_format (const struct real_format *, REAL_VALUE_TYPE *);
+
+/* Determine whether a floating-point value X is a denormal.  R is
+   expected to be in denormal form, so this function is only
+   meaningful after a call to round_for_format.  */
+
+static inline bool
+real_isdenormal (const REAL_VALUE_TYPE *r)
+{
+  return r->cl == rvc_normal && (r->sig[SIGSZ-1] & SIG_MSB) == 0;
+}
 \f
 /* Initialize R with a positive zero.  */
 
@@ -2962,7 +2972,6 @@ encode_ieee_single (const struct real_format *fmt, long *buf,
 {
   unsigned long image, sig, exp;
   unsigned long sign = r->sign;
-  bool denormal = real_isdenormal (r);
 
   image = sign << 31;
   sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
@@ -3002,7 +3011,7 @@ encode_ieee_single (const struct real_format *fmt, long *buf,
       /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
 	 whereas the intermediate representation is 0.F x 2**exp.
 	 Which means we're off by one.  */
-      if (denormal)
+      if (real_isdenormal (r))
 	exp = 0;
       else
       exp = REAL_EXP (r) + 127 - 1;
@@ -3183,7 +3192,6 @@ encode_ieee_double (const struct real_format *fmt, long *buf,
 {
   unsigned long image_lo, image_hi, sig_lo, sig_hi, exp;
   unsigned long sign = r->sign;
-  bool denormal = real_isdenormal (r);
 
   image_hi = sign << 31;
   image_lo = 0;
@@ -3255,7 +3263,7 @@ encode_ieee_double (const struct real_format *fmt, long *buf,
       /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
 	 whereas the intermediate representation is 0.F x 2**exp.
 	 Which means we're off by one.  */
-      if (denormal)
+      if (real_isdenormal (r))
 	exp = 0;
       else
 	exp = REAL_EXP (r) + 1023 - 1;
@@ -3441,7 +3449,6 @@ encode_ieee_extended (const struct real_format *fmt, long *buf,
 		      const REAL_VALUE_TYPE *r)
 {
   unsigned long image_hi, sig_hi, sig_lo;
-  bool denormal = real_isdenormal (r);
 
   image_hi = r->sign << 15;
   sig_hi = sig_lo = 0;
@@ -3523,7 +3530,7 @@ encode_ieee_extended (const struct real_format *fmt, long *buf,
 	   this discrepancy has been taken care of by the difference
 	   in fmt->emin in round_for_format.  */
 
-	if (denormal)
+	if (real_isdenormal (r))
 	  exp = 0;
 	else
 	  {
@@ -3972,7 +3979,6 @@ encode_ieee_quad (const struct real_format *fmt, long *buf,
 {
   unsigned long image3, image2, image1, image0, exp;
   unsigned long sign = r->sign;
-  bool denormal = real_isdenormal (r);
   REAL_VALUE_TYPE u;
 
   image3 = sign << 31;
@@ -4048,7 +4054,7 @@ encode_ieee_quad (const struct real_format *fmt, long *buf,
       /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
 	 whereas the intermediate representation is 0.F x 2**exp.
 	 Which means we're off by one.  */
-      if (denormal)
+      if (real_isdenormal (r))
 	exp = 0;
       else
 	exp = REAL_EXP (r) + 16383 - 1;
@@ -4729,7 +4735,6 @@ encode_ieee_half (const struct real_format *fmt, long *buf,
 {
   unsigned long image, sig, exp;
   unsigned long sign = r->sign;
-  bool denormal = real_isdenormal (r);
 
   image = sign << 15;
   sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 11)) & 0x3ff;
@@ -4769,7 +4774,7 @@ encode_ieee_half (const struct real_format *fmt, long *buf,
       /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
 	 whereas the intermediate representation is 0.F x 2**exp.
 	 Which means we're off by one.  */
-      if (denormal)
+      if (real_isdenormal (r))
 	exp = 0;
       else
 	exp = REAL_EXP (r) + 15 - 1;
@@ -4843,7 +4848,6 @@ encode_arm_bfloat_half (const struct real_format *fmt, long *buf,
 {
   unsigned long image, sig, exp;
   unsigned long sign = r->sign;
-  bool denormal = real_isdenormal (r);
 
   image = sign << 15;
   sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 8)) & 0x7f;
@@ -4880,7 +4884,7 @@ encode_arm_bfloat_half (const struct real_format *fmt, long *buf,
       break;
 
     case rvc_normal:
-      if (denormal)
+      if (real_isdenormal (r))
 	exp = 0;
       else
       exp = REAL_EXP (r) + 127 - 1;
diff --git a/gcc/real.h b/gcc/real.h
index 306e9593866..b14bcdd3fde 100644
--- a/gcc/real.h
+++ b/gcc/real.h
@@ -286,11 +286,12 @@ extern bool real_isnan (const REAL_VALUE_TYPE *);
 /* Determine whether a floating-point value X is a signaling NaN.  */
 extern bool real_issignaling_nan (const REAL_VALUE_TYPE *);
 
-/* Determine whether a floating-point value X is a denormal.  */
+/* Determine whether floating-point value R is a denormal.  This
+   function is only valid for normalized values.  */
 inline bool
-real_isdenormal (const REAL_VALUE_TYPE *r)
+real_isdenormal (const REAL_VALUE_TYPE *r, machine_mode mode)
 {
-  return r->cl == rvc_normal && (r->sig[SIGSZ-1] & SIG_MSB) == 0;
+  return r->cl == rvc_normal && REAL_EXP (r) < REAL_MODE_FORMAT (mode)->emin;
 }
 
 /* Determine whether a floating-point value X is finite.  */
diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index a855aaf626c..859c7fb4af9 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -266,15 +266,16 @@ frange::flush_denormals_to_zero ()
   if (undefined_p () || known_isnan ())
     return;
 
+  machine_mode mode = TYPE_MODE (type ());
   // Flush [x, -DENORMAL] to [x, -0.0].
-  if (real_isdenormal (&m_max) && real_isneg (&m_max))
+  if (real_isdenormal (&m_max, mode) && real_isneg (&m_max))
     {
       m_max = dconst0;
       if (HONOR_SIGNED_ZEROS (m_type))
 	m_max.sign = 1;
     }
   // Flush [+DENORMAL, x] to [+0.0, x].
-  if (real_isdenormal (&m_min) && !real_isneg (&m_min))
+  if (real_isdenormal (&m_min, mode) && !real_isneg (&m_min))
     m_min = dconst0;
 }
 
-- 
2.38.1