[gcc r13-3811] Provide normalized and denormal format version of real_isdenormal.

[gcc r13-3811] Provide normalized and denormal format version of real_isdenormal.

[Aldy Hernandez]

https://gcc.gnu.org/g:3e0ab430c0441ea3921e8b3a3987f73156412088

commit r13-3811-g3e0ab430c0441ea3921e8b3a3987f73156412088
Author: Aldy Hernandez <aldyh@redhat.com>
Date:   Mon Nov 7 14:18:57 2022 +0100

    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.

Diff:
---
 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;
 }