Re: [PATCH] Add __builtin_iseqsig()

[FX Coudert <fxcoudert@gmail.com>]

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

6 weeks later, I’d like to ask a global maintainer to review this.
The idea was okay’ed previously by Joseph Myers, but he asked for testing of both the quiet and signalling NaN cases, which is now done.

FX


> Le 6 juin 2023 à 20:15, FX Coudert <fxcoudert@gmail.com> a écrit :
> 
> Hi,
> 
> (It took me a while to get back to this.)
> 
> This is a new and improved version of the patch at https://gcc.gnu.org/pipermail/gcc-patches/2022-October/602932.html
> It addresses the comment from Joseph that FE_INVALID should really be tested in the case of both quiet and signaling NaNs, which is now done systematically.
> 
> Bootstrapped and regtested on x86_64-pc-linux-gnu
> OK to commit?
> 
> FX
> 

[-- Attachment #2: 0001-Add-__builtin_iseqsig.patch --]
[-- Type: application/octet-stream, Size: 17359 bytes --]

From 46833574721f363cbbde032dcf8205340eeae468 Mon Sep 17 00:00:00 2001
From: Francois-Xavier Coudert <fxcoudert@gcc.gnu.org>
Date: Thu, 1 Sep 2022 22:49:49 +0200
Subject: [PATCH 1/2] Add __builtin_iseqsig()

iseqsig() is a C2x library function, for signaling floating-point
equality checks.  Provide a GCC-builtin for it, which is folded to
a series of comparisons.

2022-09-01  Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>

	PR middle-end/77928

gcc/
	* doc/extend.texi: Document iseqsig builtin.
	* builtins.cc (fold_builtin_iseqsig): New function.
	(fold_builtin_2): Handle BUILT_IN_ISEQSIG.
	(is_inexpensive_builtin): Handle BUILT_IN_ISEQSIG.
	* builtins.def (BUILT_IN_ISEQSIG): New built-in.

gcc/c-family/
	* c-common.cc (check_builtin_function_arguments):
	Handle BUILT_IN_ISEQSIG.

gcc/testsuite/
	* gcc.dg/torture/builtin-iseqsig-1.c: New test.
	* gcc.dg/torture/builtin-iseqsig-2.c: New test.
	* gcc.dg/torture/builtin-iseqsig-3.c: New test.
---
 gcc/builtins.cc                               |  41 +++++++
 gcc/builtins.def                              |   1 +
 gcc/c-family/c-common.cc                      |   1 +
 gcc/doc/extend.texi                           |   7 +-
 .../gcc.dg/torture/builtin-iseqsig-1.c        | 113 ++++++++++++++++++
 .../gcc.dg/torture/builtin-iseqsig-2.c        | 113 ++++++++++++++++++
 .../gcc.dg/torture/builtin-iseqsig-3.c        | 113 ++++++++++++++++++
 7 files changed, 386 insertions(+), 3 deletions(-)
 create mode 100644 gcc/testsuite/gcc.dg/torture/builtin-iseqsig-1.c
 create mode 100644 gcc/testsuite/gcc.dg/torture/builtin-iseqsig-2.c
 create mode 100644 gcc/testsuite/gcc.dg/torture/builtin-iseqsig-3.c

diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index 8400adaf5b4..9fd44cf7fcd 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -171,6 +171,7 @@ static tree fold_builtin_fabs (location_t, tree, tree);
 static tree fold_builtin_abs (location_t, tree, tree);
 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 					enum tree_code);
+static tree fold_builtin_iseqsig (location_t, tree, tree);
 static tree fold_builtin_varargs (location_t, tree, tree*, int);
 
 static tree fold_builtin_strpbrk (location_t, tree, tree, tree, tree);
@@ -9445,6 +9446,42 @@ fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
 		      fold_build2_loc (loc, code, type, arg0, arg1));
 }
 
+/* Fold a call to __builtin_iseqsig().  ARG0 and ARG1 are the arguments.
+   After choosing the wider floating-point type for the comparison,
+   the code is folded to:
+     SAVE_EXPR<ARG0> >= SAVE_EXPR<ARG1> && SAVE_EXPR<ARG0> <= SAVE_EXPR<ARG1>  */
+
+static tree
+fold_builtin_iseqsig (location_t loc, tree arg0, tree arg1)
+{
+  tree type0, type1;
+  enum tree_code code0, code1;
+  tree cmp1, cmp2, cmp_type = NULL_TREE;
+
+  type0 = TREE_TYPE (arg0);
+  type1 = TREE_TYPE (arg1);
+
+  code0 = TREE_CODE (type0);
+  code1 = TREE_CODE (type1);
+
+  if (code0 == REAL_TYPE && code1 == REAL_TYPE)
+    /* Choose the wider of two real types.  */
+    cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
+      ? type0 : type1;
+  else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
+    cmp_type = type0;
+  else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
+    cmp_type = type1;
+
+  arg0 = builtin_save_expr (fold_convert_loc (loc, cmp_type, arg0));
+  arg1 = builtin_save_expr (fold_convert_loc (loc, cmp_type, arg1));
+
+  cmp1 = fold_build2_loc (loc, GE_EXPR, integer_type_node, arg0, arg1);
+  cmp2 = fold_build2_loc (loc, LE_EXPR, integer_type_node, arg0, arg1);
+
+  return fold_build2_loc (loc, TRUTH_AND_EXPR, integer_type_node, cmp1, cmp2);
+}
+
 /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal
    arithmetics if it can never overflow, or into internal functions that
    return both result of arithmetics and overflowed boolean flag in
@@ -9833,6 +9870,9 @@ fold_builtin_2 (location_t loc, tree expr, tree fndecl, tree arg0, tree arg1)
 					 arg0, arg1, UNORDERED_EXPR,
 					 NOP_EXPR);
 
+    case BUILT_IN_ISEQSIG:
+      return fold_builtin_iseqsig (loc, arg0, arg1);
+
       /* We do the folding for va_start in the expander.  */
     case BUILT_IN_VA_START:
       break;
@@ -11343,6 +11383,7 @@ is_inexpensive_builtin (tree decl)
       case BUILT_IN_ISLESSEQUAL:
       case BUILT_IN_ISLESSGREATER:
       case BUILT_IN_ISUNORDERED:
+      case BUILT_IN_ISEQSIG:
       case BUILT_IN_VA_ARG_PACK:
       case BUILT_IN_VA_ARG_PACK_LEN:
       case BUILT_IN_VA_COPY:
diff --git a/gcc/builtins.def b/gcc/builtins.def
index 4ad95a12f83..8cc282c1b87 100644
--- a/gcc/builtins.def
+++ b/gcc/builtins.def
@@ -1023,6 +1023,7 @@ DEF_GCC_BUILTIN        (BUILT_IN_ISLESS, "isless", BT_FN_INT_VAR, ATTR_CONST_NOT
 DEF_GCC_BUILTIN        (BUILT_IN_ISLESSEQUAL, "islessequal", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
 DEF_GCC_BUILTIN        (BUILT_IN_ISLESSGREATER, "islessgreater", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
 DEF_GCC_BUILTIN        (BUILT_IN_ISUNORDERED, "isunordered", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN        (BUILT_IN_ISEQSIG, "iseqsig", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
 DEF_GCC_BUILTIN        (BUILT_IN_ISSIGNALING, "issignaling", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
 DEF_LIB_BUILTIN        (BUILT_IN_LABS, "labs", BT_FN_LONG_LONG, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_C99_BUILTIN        (BUILT_IN_LLABS, "llabs", BT_FN_LONGLONG_LONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
index 9c8eed5442a..9e1ce2a2bc9 100644
--- a/gcc/c-family/c-common.cc
+++ b/gcc/c-family/c-common.cc
@@ -6330,6 +6330,7 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
     case BUILT_IN_ISLESSEQUAL:
     case BUILT_IN_ISLESSGREATER:
     case BUILT_IN_ISUNORDERED:
+    case BUILT_IN_ISEQSIG:
       if (builtin_function_validate_nargs (loc, fndecl, nargs, 2))
 	{
 	  enum tree_code code0, code1;
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index cdbd4b34a35..360389df9dc 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -13017,6 +13017,7 @@ is called and the @var{flag} argument passed to it.
 @node Other Builtins
 @section Other Built-in Functions Provided by GCC
 @cindex built-in functions
+@findex __builtin_iseqsig
 @findex __builtin_isfinite
 @findex __builtin_isnormal
 @findex __builtin_isgreater
@@ -13568,9 +13569,9 @@ the same names as the standard macros ( @code{isgreater},
 @code{islessgreater}, and @code{isunordered}) , with @code{__builtin_}
 prefixed.  We intend for a library implementor to be able to simply
 @code{#define} each standard macro to its built-in equivalent.
-In the same fashion, GCC provides @code{fpclassify}, @code{isfinite},
-@code{isinf_sign}, @code{isnormal} and @code{signbit} built-ins used with
-@code{__builtin_} prefixed.  The @code{isinf} and @code{isnan}
+In the same fashion, GCC provides @code{fpclassify}, @code{iseqsig},
+@code{isfinite}, @code{isinf_sign}, @code{isnormal} and @code{signbit} built-ins
+used with @code{__builtin_} prefixed.  The @code{isinf} and @code{isnan}
 built-in functions appear both with and without the @code{__builtin_} prefix.
 With @code{-ffinite-math-only} option the @code{isinf} and @code{isnan}
 built-in functions will always return 0.
diff --git a/gcc/testsuite/gcc.dg/torture/builtin-iseqsig-1.c b/gcc/testsuite/gcc.dg/torture/builtin-iseqsig-1.c
new file mode 100644
index 00000000000..c66431fff1c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/builtin-iseqsig-1.c
@@ -0,0 +1,113 @@
+/* { dg-do run { xfail powerpc*-*-* } } */
+/* remove the xfail for powerpc when pr58684 is fixed */
+/* { dg-add-options ieee } */
+/* { dg-additional-options "-fsignaling-nans" } */
+/* { dg-require-effective-target fenv_exceptions } */
+
+#include <fenv.h>
+
+void
+ftrue (float x, float y)
+{
+  if (!__builtin_iseqsig (x, y))
+    __builtin_abort ();
+}
+
+void
+ffalse (float x, float y)
+{
+  if (__builtin_iseqsig (x, y))
+    __builtin_abort ();
+}
+
+int
+main ()
+{
+  volatile float f1, f2;
+
+  f1 = 0.f; f2 = 0.f;
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.f; f2 = -0.f;
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.f; f2 = 1.f;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = -0.f; f2 = 1.f;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.f; f2 = __builtin_inff();
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = -0.f; f2 = __builtin_inff();
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.f; f2 = __builtin_nanf("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = -0.f; f2 = __builtin_nanf("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = 1.f; f2 = 1.f;
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.f; f2 = 0.f;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.f; f2 = -0.f;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.f; f2 = __builtin_inff();
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.f; f2 = __builtin_nanf("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_inff(); f2 = __builtin_inff();
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = __builtin_inff(); f2 = __builtin_nanf("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_nanf(""); f2 = __builtin_nanf("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_nansf(""); f2 = 1.f;
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = 1.f; f2 = __builtin_nansf("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_nansf(""); f2 = __builtin_nansf("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/builtin-iseqsig-2.c b/gcc/testsuite/gcc.dg/torture/builtin-iseqsig-2.c
new file mode 100644
index 00000000000..03625b07e6f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/builtin-iseqsig-2.c
@@ -0,0 +1,113 @@
+/* { dg-do run { xfail powerpc*-*-* } } */
+/* remove the xfail for powerpc when pr58684 is fixed */
+/* { dg-add-options ieee } */
+/* { dg-additional-options "-fsignaling-nans" } */
+/* { dg-require-effective-target fenv_exceptions_double } */
+
+#include <fenv.h>
+
+void
+ftrue (double x, double y)
+{
+  if (!__builtin_iseqsig (x, y))
+    __builtin_abort ();
+}
+
+void
+ffalse (double x, double y)
+{
+  if (__builtin_iseqsig (x, y))
+    __builtin_abort ();
+}
+
+int
+main ()
+{
+  volatile double f1, f2;
+
+  f1 = 0.; f2 = 0.;
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.; f2 = -0.;
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.; f2 = 1.;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = -0.; f2 = 1.;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.; f2 = __builtin_inf();
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = -0.; f2 = __builtin_inf();
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.; f2 = __builtin_nan("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = -0.; f2 = __builtin_nan("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = 1.; f2 = 1.;
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.; f2 = 0.;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.; f2 = -0.;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.; f2 = __builtin_inf();
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.; f2 = __builtin_nan("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_inf(); f2 = __builtin_inf();
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = __builtin_inf(); f2 = __builtin_nan("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_nan(""); f2 = __builtin_nan("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_nans(""); f2 = 1.;
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = 1.; f2 = __builtin_nans("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_nans(""); f2 = __builtin_nans("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/builtin-iseqsig-3.c b/gcc/testsuite/gcc.dg/torture/builtin-iseqsig-3.c
new file mode 100644
index 00000000000..ed24035264a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/builtin-iseqsig-3.c
@@ -0,0 +1,113 @@
+/* { dg-do run { xfail powerpc*-*-* } } */
+/* remove the xfail for powerpc when pr58684 is fixed */
+/* { dg-add-options ieee } */
+/* { dg-additional-options "-fsignaling-nans" } */
+/* { dg-require-effective-target fenv_exceptions_long_double } */
+
+#include <fenv.h>
+
+void
+ftrue (long double x, long double y)
+{
+  if (!__builtin_iseqsig (x, y))
+    __builtin_abort ();
+}
+
+void
+ffalse (long double x, long double y)
+{
+  if (__builtin_iseqsig (x, y))
+    __builtin_abort ();
+}
+
+int
+main ()
+{
+  volatile long double f1, f2;
+
+  f1 = 0.L; f2 = 0.f;
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.L; f2 = -0.f;
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.L; f2 = 1.f;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = -0.L; f2 = 1.f;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.L; f2 = __builtin_infl();
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = -0.L; f2 = __builtin_infl();
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 0.L; f2 = __builtin_nanl("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = -0.L; f2 = __builtin_nanl("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = 1.L; f2 = 1.f;
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.L; f2 = 0.f;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.L; f2 = -0.f;
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.L; f2 = __builtin_infl();
+  ffalse (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = 1.L; f2 = __builtin_nanl("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_infl(); f2 = __builtin_infl();
+  ftrue (f1, f2);
+  if (fetestexcept (FE_INVALID)) __builtin_abort ();
+
+  f1 = __builtin_infl(); f2 = __builtin_nanl("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_nanl(""); f2 = __builtin_nanl("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_nansl(""); f2 = 1.L;
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = 1.L; f2 = __builtin_nansl("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  f1 = __builtin_nansl(""); f2 = __builtin_nansl("");
+  ffalse (f1, f2);
+  if (!fetestexcept (FE_INVALID)) __builtin_abort ();
+  feclearexcept (FE_INVALID);
+
+  return 0;
+}
-- 
2.34.1


[-- Attachment #3: Type: text/plain, Size: 2 bytes --]