Movatterモバイル変換

[0]ホーム
URL:

This is the mail archive of thelibc-alpha@sourceware.orgmailing list for theglibc project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav:[Date Prev] [Date Next][Thread Prev] [Thread Next]
Other format:[Raw text]

[PATCH v2] Provide a C++ version of issignaling that does not use __MATH_TG

Changes since v1:  - Added test case.-- 8< --The macro __MATH_TG contains the logic to select between long double and_Float128, when these types are ABI-distinct.  This logic relies on__builtin_types_compatible_p, which is not available in C++ mode.On the other hand, C++ function overloading provides the means todistinguish between the floating-point types.  The overloadingresolution will match the correct parameter regardless of typequalifiers, i.e.: const and volatile.Tested for powerpc64le, s390x, and x86_64.* math/math.h [defined __cplusplus] (issignaling): Provide a C++definition for issignaling that does not rely on __MATH_TG,since __MATH_TG uses __builtin_types_compatible_p, which is onlyavailable in C mode.(CFLAGS-test-math-issignaling.cc): New variable.* math/Makefile [CXX] (tests): Add test-math-issignaling.* math/test-math-issignaling.cc: New test for C++ implementationof type-generic issignaling.* sysdeps/powerpc/powerpc64le/Makefile [subdir == math](CXXFLAGS-test-math-issignaling.cc): Add -mfloat128 to the buildoptions of test-math-issignaling on powerpc64le.--- math/Makefile                        |   3 +- math/math.h                          |  19 +++++- math/test-math-issignaling.cc        | 113 +++++++++++++++++++++++++++++++++++ sysdeps/powerpc/powerpc64le/Makefile |   1 + 4 files changed, 134 insertions(+), 2 deletions(-) create mode 100644 math/test-math-issignaling.ccdiff --git a/math/Makefile b/math/Makefileindex e09b0c0545..0130fcf38b 100644--- a/math/Makefile+++ b/math/Makefile@@ -203,7 +203,7 @@ tests-static = test-fpucw-static test-fpucw-ieee-static \        test-signgam-ullong-static test-signgam-ullong-init-static  ifneq (,$(CXX))-tests += test-math-isinff test-math-iszero+tests += test-math-isinff test-math-iszero test-math-issignaling endif  ifneq (no,$(PERL))@@ -350,6 +350,7 @@ CFLAGS-test-signgam-ullong-init-static.c = -std=c99  CFLAGS-test-math-isinff.cc = -std=gnu++11 CFLAGS-test-math-iszero.cc = -std=gnu++11+CFLAGS-test-math-issignaling.cc = -std=gnu++11  CFLAGS-test-iszero-excess-precision.c = -fexcess-precision=standard CFLAGS-test-iseqsig-excess-precision.c = -fexcess-precision=standarddiff --git a/math/math.h b/math/math.hindex dea8dbe1ae..1d6cdb0685 100644--- a/math/math.h+++ b/math/math.h@@ -474,7 +474,24 @@ enum # include <bits/iscanonical.h>  /* Return nonzero value if X is a signaling NaN.  */-# define issignaling(x) __MATH_TG ((x), __issignaling, (x))+# ifndef __cplusplus+#  define issignaling(x) __MATH_TG ((x), __issignaling, (x))+# else+   /* In C++ mode, __MATH_TG cannot be used, because it relies on+      __builtin_types_compatible_p, which is a C-only builtin.  On the+      other hand, overloading provides the means to distinguish between+      the floating-point types.  The overloading resolution will match+      the correct parameter (regardless of type qualifiers (i.e.: const+      and volatile).  */+extern "C++" {+int issignaling (float __val) { return __issignalingf (__val); }+int issignaling (double __val) { return __issignaling (__val); }+int issignaling (long double __val) { return __issignalingl (__val); }+#if __HAVE_DISTINCT_FLOAT128+int issignaling (_Float128  __val) { return __issignalingf128 (__val); }+#endif+} /* extern C++ */+# endif  /* Return nonzero value if X is subnormal.  */ # define issubnormal(x) (fpclassify (x) == FP_SUBNORMAL)diff --git a/math/test-math-issignaling.cc b/math/test-math-issignaling.ccnew file mode 100644index 0000000000..f302a27735--- /dev/null+++ b/math/test-math-issignaling.cc@@ -0,0 +1,113 @@+/* Test for the C++ implementation of issignaling.+   Copyright (C) 2017 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+   <http://www.gnu.org/licenses/>.  */++#define _GNU_SOURCE 1+#include <math.h>+#include <stdio.h>++#include <limits>++/* There is no signaling_NaN for _Float128 in std::numeric_limits.+   Include ieee754_float128.h and use the bitfields in the union+   ieee854_float128.ieee_nan to build a signaling NaN.  */+#if __HAVE_FLOAT128+#include <ieee754_float128.h>+#endif++static bool errors;++static void+check (int actual, int expected, const char *actual_expr, int line)+{+  if (actual != expected)+    {+      errors = true;+      printf ("%s:%d: error: %s\n", __FILE__, line, actual_expr);+      printf ("%s:%d:   expected: %d\n", __FILE__, line, expected);+      printf ("%s:%d:   actual: %d\n", __FILE__, line, actual);+    }+}++#define CHECK(actual, expected) \+  check ((actual), (expected), #actual, __LINE__)++template <class T>+static void+check_type ()+{+  typedef std::numeric_limits<T> limits;+  CHECK (issignaling (T{0}), 0);+  if (limits::has_infinity)+    {+      CHECK (issignaling (limits::infinity ()), 0);+      CHECK (issignaling (-limits::infinity ()), 0);+    }+  if (limits::has_quiet_NaN)+    CHECK (issignaling (limits::quiet_NaN ()), 0);+  if (limits::has_signaling_NaN)+    CHECK (issignaling (limits::signaling_NaN ()), 1);+}++#if __HAVE_FLOAT128+static void+check_float128 ()+{+  ieee854_float128 q;++  q.d = 0;+  CHECK (issignaling (q.d), 0);++  /* Infinity.  */+  q.ieee.negative = 0;+  q.ieee.exponent = 0x7FFF;+  q.ieee.mantissa0 = 0x0000;+  q.ieee.mantissa1 = 0x00000000;+  q.ieee.mantissa2 = 0x00000000;+  q.ieee.mantissa3 = 0x00000000;+  CHECK (issignaling (q.d), 0);++  /* Quite NaN.  */+  q.ieee_nan.quiet_nan = 1;+  q.ieee_nan.mantissa0 = 0x0000;+  CHECK (issignaling (q.d), 0);++  /* Still a quite NaN.  */+  q.ieee_nan.quiet_nan = 1;+  q.ieee_nan.mantissa0 = 0x4000;+  CHECK (issignaling (q.d), 0);++  /* Signaling NaN.  */+  q.ieee_nan.quiet_nan = 0;+  q.ieee_nan.mantissa0 = 0x4000;+  CHECK (issignaling (q.d), 1);+}+#endif++static int+do_test (void)+{+  check_type<float> ();+  check_type<double> ();+  check_type<long double> ();+#if __HAVE_FLOAT128+  check_float128 ();+#endif+  return errors;+}++#include <support/test-driver.c>diff --git a/sysdeps/powerpc/powerpc64le/Makefile b/sysdeps/powerpc/powerpc64le/Makefileindex 77617b670a..19adbfa1c1 100644--- a/sysdeps/powerpc/powerpc64le/Makefile+++ b/sysdeps/powerpc/powerpc64le/Makefile@@ -16,6 +16,7 @@ $(foreach suf,$(all-object-suffixes),%f128_r$(suf)): CFLAGS += -mfloat128 $(foreach suf,$(all-object-suffixes),$(objpfx)test-float128%$(suf)): CFLAGS += -mfloat128 $(foreach suf,$(all-object-suffixes),$(objpfx)test-ifloat128%$(suf)): CFLAGS += -mfloat128 CFLAGS-libm-test-support-float128.c += -mfloat128+CFLAGS-test-math-issignaling.cc += -mfloat128 $(objpfx)test-float128% $(objpfx)test-ifloat128%: \   gnulib-tests += $(f128-loader-link) endif-- 2.13.5
Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav:[Date Prev] [Date Next][Thread Prev] [Thread Next]
[8]ページ先頭
©2009-2026 Movatter.jp