[06/12] math: Add test to check if round raise inexact floating-point exception

Message ID 20231228172026.2013007-7-adhemerval.zanella@linaro.org (mailing list archive)
State Superseded
Delegated to: H.J. Lu
Headers
Series Improve rounding to interger function for C23 |

Checks

Context Check Description
redhat-pt-bot/TryBot-apply_patch success Patch applied to master at the time it was sent

Commit Message

Adhemerval Zanella Dec. 28, 2023, 5:20 p.m. UTC
  It is not allowed anymore on ISO C23.
---
 math/Makefile              |  4 ++
 math/test-round-except-2.c | 67 ++++++++++++++++++++++++++++++
 math/test-round-except.c   | 85 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 156 insertions(+)
 create mode 100644 math/test-round-except-2.c
 create mode 100644 math/test-round-except.c
  

Comments

H.J. Lu April 1, 2024, 2:02 p.m. UTC | #1
On Thu, Dec 28, 2023 at 9:22 AM Adhemerval Zanella
<adhemerval.zanella@linaro.org> wrote:
>
> It is not allowed anymore on ISO C23.
> ---
>  math/Makefile              |  4 ++
>  math/test-round-except-2.c | 67 ++++++++++++++++++++++++++++++
>  math/test-round-except.c   | 85 ++++++++++++++++++++++++++++++++++++++
>  3 files changed, 156 insertions(+)
>  create mode 100644 math/test-round-except-2.c
>  create mode 100644 math/test-round-except.c
>
> diff --git a/math/Makefile b/math/Makefile
> index 7ae107170c..dfe24a8c03 100644
> --- a/math/Makefile
> +++ b/math/Makefile
> @@ -530,6 +530,8 @@ tests = \
>    test-nearbyint-except \
>    test-nearbyint-except-2 \
>    test-powl \
> +  test-round-except \
> +  test-round-except-2 \
>    test-signgam-uchar \
>    test-signgam-uchar-init \
>    test-signgam-uint \
> @@ -1001,6 +1003,8 @@ CFLAGS-test-floor-except.c += -fno-builtin
>  CFLAGS-test-floor-except-2.c += -fno-builtin
>  CFLAGS-test-trunc-except.c += -fno-builtin
>  CFLAGS-test-trunc-except-2.c += -fno-builtin
> +CFLAGS-test-round-except.c += -fno-builtin
> +CFLAGS-test-round-except-2.c += -fno-builtin
>
>  include ../Rules
>
> diff --git a/math/test-round-except-2.c b/math/test-round-except-2.c
> new file mode 100644
> index 0000000000..dffc02e91f
> --- /dev/null
> +++ b/math/test-round-except-2.c
> @@ -0,0 +1,67 @@
> +/* Test round functions do not disable exception traps.
> +   Copyright (C) 2023 Free Software Foundation, Inc.

2024

> +   This file is part of the GNU C Library.
> +
> +   The GNU C Library is free software; you can redistribute it and/or
> +   modify it under the terms of the GNU Lesser General Public
> +   License as published by the Free Software Foundation; either
> +   version 2.1 of the License, or (at your option) any later version.
> +
> +   The GNU C Library is distributed in the hope that it will be useful,
> +   but WITHOUT ANY WARRANTY; without even the implied warranty of
> +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> +   Lesser General Public License for more details.
> +
> +   You should have received a copy of the GNU Lesser General Public
> +   License along with the GNU C Library; if not, see
> +   <https://www.gnu.org/licenses/>.  */
> +
> +#include <fenv.h>
> +#include <math.h>
> +#include <stdio.h>
> +
> +#ifndef FE_INEXACT
> +# define FE_INEXACT 0
> +#endif
> +
> +#define TEST_FUNC(NAME, FLOAT, SUFFIX)                                 \
> +static int                                                             \
> +NAME (void)                                                            \
> +{                                                                      \
> +  int result = 0;                                                      \
> +  volatile FLOAT a, b __attribute__ ((unused));                                \
> +  a = 1.5;                                                             \
> +  /* round must work when traps on "inexact" are enabled.  */  \
> +  b = round ## SUFFIX (a);                                             \
> +  /* And it must have left those traps enabled.  */                    \
> +  if (fegetexcept () == FE_INEXACT)                                    \
> +    puts ("PASS: " #FLOAT);                                            \
> +  else                                                                 \
> +    {                                                                  \
> +      puts ("FAIL: " #FLOAT);                                          \
> +      result = 1;                                                      \
> +    }                                                                  \
> +  return result;                                                       \
> +}
> +
> +TEST_FUNC (float_test, float, f)
> +TEST_FUNC (double_test, double, )
> +TEST_FUNC (ldouble_test, long double, l)
> +
> +static int
> +do_test (void)
> +{
> +  if (feenableexcept (FE_INEXACT) == -1)
> +    {
> +      puts ("enabling FE_INEXACT traps failed, cannot test");
> +      return 77;
> +    }
> +  int result = float_test ();
> +  feenableexcept (FE_INEXACT);
> +  result |= double_test ();
> +  feenableexcept (FE_INEXACT);
> +  result |= ldouble_test ();
> +  return result;
> +}
> +
> +#include <support/test-driver.c>
> diff --git a/math/test-round-except.c b/math/test-round-except.c
> new file mode 100644
> index 0000000000..cd43c964ab
> --- /dev/null
> +++ b/math/test-round-except.c
> @@ -0,0 +1,85 @@
> +/* Test round functions do not clear exceptions.
> +   Copyright (C) 2015-2023 Free Software Foundation, Inc.

Just 2024.

> +   This file is part of the GNU C Library.
> +
> +   The GNU C Library is free software; you can redistribute it and/or
> +   modify it under the terms of the GNU Lesser General Public
> +   License as published by the Free Software Foundation; either
> +   version 2.1 of the License, or (at your option) any later version.
> +
> +   The GNU C Library is distributed in the hope that it will be useful,
> +   but WITHOUT ANY WARRANTY; without even the implied warranty of
> +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> +   Lesser General Public License for more details.
> +
> +   You should have received a copy of the GNU Lesser General Public
> +   License along with the GNU C Library; if not, see
> +   <https://www.gnu.org/licenses/>.  */
> +
> +#include <fenv.h>
> +#include <math.h>
> +#include <stdbool.h>
> +#include <stdio.h>
> +
> +#include <math-tests.h>
> +
> +#ifndef FE_INVALID
> +# define FE_INVALID 0
> +#endif
> +
> +static bool any_supported = false;
> +
> +#define TEST_FUNC(NAME, FLOAT, SUFFIX)                                 \
> +static int                                                             \
> +NAME (void)                                                            \
> +{                                                                      \
> +  int result = 0;                                                      \
> +  if (!EXCEPTION_TESTS (FLOAT))                                                \
> +    return 0;                                                          \
> +  any_supported = true;                                                        \
> +  volatile FLOAT a, b __attribute__ ((unused));                                \
> +  a = 1.0;                                                             \
> +  /* round must not clear already-raised exceptions.  */               \
> +  feraiseexcept (FE_ALL_EXCEPT);                                       \
> +  b = round ## SUFFIX (a);                                             \
> +  if (fetestexcept (FE_ALL_EXCEPT) == FE_ALL_EXCEPT)                   \
> +    puts ("PASS: " #FLOAT);                                            \
> +  else                                                                 \
> +    {                                                                  \
> +      puts ("FAIL: " #FLOAT);                                          \
> +      result = 1;                                                      \
> +    }                                                                  \
> +  /* But it mustn't lose exceptions from sNaN arguments.  */           \
> +  if (SNAN_TESTS (FLOAT))                                              \
> +    {                                                                  \
> +      static volatile FLOAT snan = __builtin_nans ## SUFFIX ("");      \
> +      volatile FLOAT c __attribute__ ((unused));                       \
> +      feclearexcept (FE_ALL_EXCEPT);                                   \
> +      c = round ## SUFFIX (snan);                                      \
> +      if (fetestexcept (FE_INVALID) == FE_INVALID)                     \
> +       puts ("PASS: " #FLOAT " sNaN");                                 \
> +      else                                                             \
> +       {                                                               \
> +         puts ("FAIL: " #FLOAT " sNaN");                               \
> +         result = 1;                                                   \
> +       }                                                               \
> +    }                                                                  \
> +  return result;                                                       \
> +}
> +
> +TEST_FUNC (float_test, float, f)
> +TEST_FUNC (double_test, double, )
> +TEST_FUNC (ldouble_test, long double, l)
> +
> +static int
> +do_test (void)
> +{
> +  int result = float_test ();
> +  result |= double_test ();
> +  result |= ldouble_test ();
> +  if (!any_supported)
> +    return 77;
> +  return result;
> +}
> +
> +#include <support/test-driver.c>
> --
> 2.34.1
>
  

Patch

diff --git a/math/Makefile b/math/Makefile
index 7ae107170c..dfe24a8c03 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -530,6 +530,8 @@  tests = \
   test-nearbyint-except \
   test-nearbyint-except-2 \
   test-powl \
+  test-round-except \
+  test-round-except-2 \
   test-signgam-uchar \
   test-signgam-uchar-init \
   test-signgam-uint \
@@ -1001,6 +1003,8 @@  CFLAGS-test-floor-except.c += -fno-builtin
 CFLAGS-test-floor-except-2.c += -fno-builtin
 CFLAGS-test-trunc-except.c += -fno-builtin
 CFLAGS-test-trunc-except-2.c += -fno-builtin
+CFLAGS-test-round-except.c += -fno-builtin
+CFLAGS-test-round-except-2.c += -fno-builtin
 
 include ../Rules
 
diff --git a/math/test-round-except-2.c b/math/test-round-except-2.c
new file mode 100644
index 0000000000..dffc02e91f
--- /dev/null
+++ b/math/test-round-except-2.c
@@ -0,0 +1,67 @@ 
+/* Test round functions do not disable exception traps.
+   Copyright (C) 2023 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <fenv.h>
+#include <math.h>
+#include <stdio.h>
+
+#ifndef FE_INEXACT
+# define FE_INEXACT 0
+#endif
+
+#define TEST_FUNC(NAME, FLOAT, SUFFIX)					\
+static int								\
+NAME (void)								\
+{									\
+  int result = 0;							\
+  volatile FLOAT a, b __attribute__ ((unused));				\
+  a = 1.5;								\
+  /* round must work when traps on "inexact" are enabled.  */	\
+  b = round ## SUFFIX (a);						\
+  /* And it must have left those traps enabled.  */			\
+  if (fegetexcept () == FE_INEXACT)					\
+    puts ("PASS: " #FLOAT);						\
+  else									\
+    {									\
+      puts ("FAIL: " #FLOAT);						\
+      result = 1;							\
+    }									\
+  return result;							\
+}
+
+TEST_FUNC (float_test, float, f)
+TEST_FUNC (double_test, double, )
+TEST_FUNC (ldouble_test, long double, l)
+
+static int
+do_test (void)
+{
+  if (feenableexcept (FE_INEXACT) == -1)
+    {
+      puts ("enabling FE_INEXACT traps failed, cannot test");
+      return 77;
+    }
+  int result = float_test ();
+  feenableexcept (FE_INEXACT);
+  result |= double_test ();
+  feenableexcept (FE_INEXACT);
+  result |= ldouble_test ();
+  return result;
+}
+
+#include <support/test-driver.c>
diff --git a/math/test-round-except.c b/math/test-round-except.c
new file mode 100644
index 0000000000..cd43c964ab
--- /dev/null
+++ b/math/test-round-except.c
@@ -0,0 +1,85 @@ 
+/* Test round functions do not clear exceptions.
+   Copyright (C) 2015-2023 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <fenv.h>
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#include <math-tests.h>
+
+#ifndef FE_INVALID
+# define FE_INVALID 0
+#endif
+
+static bool any_supported = false;
+
+#define TEST_FUNC(NAME, FLOAT, SUFFIX)					\
+static int								\
+NAME (void)								\
+{									\
+  int result = 0;							\
+  if (!EXCEPTION_TESTS (FLOAT))						\
+    return 0;								\
+  any_supported = true;							\
+  volatile FLOAT a, b __attribute__ ((unused));				\
+  a = 1.0;								\
+  /* round must not clear already-raised exceptions.  */		\
+  feraiseexcept (FE_ALL_EXCEPT);					\
+  b = round ## SUFFIX (a);						\
+  if (fetestexcept (FE_ALL_EXCEPT) == FE_ALL_EXCEPT)			\
+    puts ("PASS: " #FLOAT);						\
+  else									\
+    {									\
+      puts ("FAIL: " #FLOAT);						\
+      result = 1;							\
+    }									\
+  /* But it mustn't lose exceptions from sNaN arguments.  */		\
+  if (SNAN_TESTS (FLOAT))						\
+    {									\
+      static volatile FLOAT snan = __builtin_nans ## SUFFIX ("");	\
+      volatile FLOAT c __attribute__ ((unused));			\
+      feclearexcept (FE_ALL_EXCEPT);					\
+      c = round ## SUFFIX (snan);					\
+      if (fetestexcept (FE_INVALID) == FE_INVALID)			\
+	puts ("PASS: " #FLOAT " sNaN");					\
+      else								\
+	{								\
+	  puts ("FAIL: " #FLOAT " sNaN");				\
+	  result = 1;							\
+	}								\
+    }									\
+  return result;							\
+}
+
+TEST_FUNC (float_test, float, f)
+TEST_FUNC (double_test, double, )
+TEST_FUNC (ldouble_test, long double, l)
+
+static int
+do_test (void)
+{
+  int result = float_test ();
+  result |= double_test ();
+  result |= ldouble_test ();
+  if (!any_supported)
+    return 77;
+  return result;
+}
+
+#include <support/test-driver.c>