builtins: Fix up DFP ICEs on __builtin_is{inf,finite,normal} [PR43374]

__builtin_is{inf,finite,normal} builtins ICE on _Decimal{32,64,128,64x}
operands unless those operands are constant.

The problem is that we fold the builtins to comparisons with the largest
finite number, but
a) get_max_float was only handling binary floats
b) real_from_string again assumes binary float
and so we were ICEing in the build_real called after the two calls.

This patch adds decimal handling into get_max_float (well, moves it
from c-cppbuiltin.cc which was printing those for __DEC{32,64,128}_MAX__
macros) and uses real_from_string3 (perhaps it is time to rename it
to just real_from_string now that we can use function overloading)
so that it handles both binary and decimal floats.

2024-11-26  Jakub Jelinek  <jakub@redhat.com>

	PR middle-end/43374
gcc/
	* real.cc (get_max_float): Handle decimal float.
	* builtins.cc (fold_builtin_interclass_mathfn): Use
	real_from_string3 rather than real_from_string.  Use
	"1E%d" format string rather than "0x1p%d" for decimal
	float minimum.
gcc/c-family/
	* c-cppbuiltin.cc (builtin_define_decimal_float_constants): Use
	get_max_float.
gcc/testsuite/
	* gcc.dg/dfp/pr43374.c: New test.

diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index 029c561d46650143b10647ebd198acf41ddb3057..055b31d264ca6d3b09742bc4d5f4475c9047c9c0 100644 (file)
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -9580,7 +9580,7 @@ fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
            arg = fold_build1_loc (loc, NOP_EXPR, type, arg);
          }
        get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf), false);
-       real_from_string (&r, buf);
+       real_from_string3 (&r, buf, mode);
        result = build_call_expr (isgr_fn, 2,
                                  fold_build1_loc (loc, ABS_EXPR, type, arg),
                                  build_real (type, r));
@@ -9604,7 +9604,7 @@ fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
            arg = fold_build1_loc (loc, NOP_EXPR, type, arg);
          }
        get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf), false);
-       real_from_string (&r, buf);
+       real_from_string3 (&r, buf, mode);
        result = build_call_expr (isle_fn, 2,
                                  fold_build1_loc (loc, ABS_EXPR, type, arg),
                                  build_real (type, r));
@@ -9643,9 +9643,12 @@ fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
        arg = fold_build1_loc (loc, ABS_EXPR, type, arg);
 
        get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf), false);
-       real_from_string (&rmax, buf);
-       sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (orig_mode)->emin - 1);
-       real_from_string (&rmin, buf);
+       real_from_string3 (&rmax, buf, mode);
+       if (DECIMAL_FLOAT_MODE_P (mode))
+         sprintf (buf, "1E%d", REAL_MODE_FORMAT (orig_mode)->emin - 1);
+       else
+         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (orig_mode)->emin - 1);
+       real_from_string3 (&rmin, buf, orig_mode);
        max_exp = build_real (type, rmax);
        min_exp = build_real (type, rmin);
 

diff --git a/gcc/c-family/c-cppbuiltin.cc b/gcc/c-family/c-cppbuiltin.cc
index 349918c325cd862a20bde342530887ae9f1de9c6..8fbfef561e8a5df4a4826db165ce3d1d30a7a46d 100644 (file)
--- a/gcc/c-family/c-cppbuiltin.cc
+++ b/gcc/c-family/c-cppbuiltin.cc
@@ -357,17 +357,8 @@ builtin_define_decimal_float_constants (const char *name_prefix,
 
   /* Compute the maximum representable value.  */
   sprintf (name, "__%s_MAX__", name_prefix);
-  p = buf;
-  for (digits = fmt->p; digits; digits--)
-    {
-      *p++ = '9';
-      if (digits == fmt->p)
-       *p++ = '.';
-    }
-  *p = 0;
-  /* fmt->p plus 1, to account for the decimal point and fmt->emax
-     minus 1 because the digits are nines, not 1.0.  */
-  sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
+  get_max_float (fmt, buf, sizeof (buf) - strlen (suffix), false);
+  strcat (buf, suffix);
   builtin_define_with_value (name, buf, 0);
 
   /* Compute epsilon (the difference between 1 and least value greater

diff --git a/gcc/real.cc b/gcc/real.cc
index 1392595a72f11d7fb24bee1a43a15d3dbe8ab07c..b89ff83340918ba3f5a9cb10d4a0d9ce6a673224 100644 (file)
--- a/gcc/real.cc
+++ b/gcc/real.cc
@@ -5438,6 +5438,22 @@ void
 get_max_float (const struct real_format *fmt, char *buf, size_t len,
               bool norm_max)
 {
+  if (fmt->b == 10)
+    {
+      char *p = buf;
+      for (int i = fmt->p; i; i--)
+       {
+         *p++ = '9';
+         if (i == fmt->p)
+           *p++ = '.';
+       }
+      /* fmt->p plus 1, to account for the decimal point and fmt->emax
+        minus 1 because the digits are nines, not 1.0.  */
+      sprintf (buf + fmt->p + 1, "E%d", fmt->emax - 1);
+      gcc_assert (strlen (buf) < len);
+      return;
+    }
+
   int i, n;
   char *p;
   bool is_ibm_extended = fmt->pnan < fmt->p;

diff --git a/gcc/testsuite/gcc.dg/dfp/pr43374.c b/gcc/testsuite/gcc.dg/dfp/pr43374.c
new file mode 100644 (file)
index 0000000..83f3dca
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/dfp/pr43374.c
@@ -0,0 +1,56 @@
+/* PR middle-end/43374 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+__attribute__((noipa)) int
+foo (_Decimal32 x)
+{
+  return __builtin_isinf (x);
+}
+
+__attribute__((noipa)) int
+bar (_Decimal64 x)
+{
+  return __builtin_isfinite (x);
+}
+
+__attribute__((noipa)) int
+baz (_Decimal128 x)
+{
+  return __builtin_isnormal (x);
+}
+
+int
+main ()
+{
+  if (!foo (__builtin_infd32 ())
+      || !foo (-__builtin_infd32 ())
+      || foo (__builtin_nand32 (""))
+      || foo (9.999999E96DF)
+      || foo (-1E-95DF)
+      || foo (0.999999E-95DF)
+      || foo (-0.000001E-95DF)
+      || foo (0.000DF)
+      || foo (-0.00000DF))
+    __builtin_abort ();
+  if (bar (__builtin_infd64 ())
+      || bar (-__builtin_infd64 ())
+      || bar (__builtin_nand64 (""))
+      || !bar (9.999999999999999E384DD)
+      || !bar (-1E-383DD)
+      || !bar (0.999999999999999E-383DD)
+      || !bar (-0.000000000000001E-383DD)
+      || !bar (0.000DD)
+      || !bar (-0.0000000000DD))
+    __builtin_abort ();
+  if (baz (__builtin_infd128 ())
+      || baz (-__builtin_infd128 ())
+      || baz (__builtin_nand128 (""))
+      || !baz (9.999999999999999999999999999999999E6144DL)
+      || !baz (-1E-6143DL)
+      || baz (0.999999999999999999999999999999999E-6143DL)
+      || baz (-0.000000000000000000000000000000001E-6143DL)
+      || baz (0.000DL)
+      || baz (-0.0000000000000000000000DL))
+    __builtin_abort ();
+}