picnoir/glibc
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
glibc/math/test-math-iseqsig.cc

402 lines
11 KiB
C++
Raw Normal View History

Provide a C++ version of iseqsig (bug 22377) In C++ mode, __MATH_TG cannot be used for defining iseqsig, because __MATH_TG relies on __builtin_types_compatible_p, which is a C-only builtin. This is true when float128 is provided as an ABI-distinct type from long double. Moreover, the comparison macros from ISO C take two floating-point arguments, which need not have the same type. Choosing what underlying function to call requires evaluating the formats of the arguments, then selecting which is wider. The macro __MATH_EVAL_FMT2 provides this information, however, only the type of the macro expansion is relevant (actually evaluating the expression would be incorrect). This patch provides a C++ version of iseqsig, in which only the type of __MATH_EVAL_FMT2 (__typeof or decltype) is used as a template parameter for __iseqsig_type. This function calls the appropriate underlying function. Tested for powerpc64le and x86_64. [BZ #22377] * math/Makefile [C++] (tests): Add test for iseqsig. * math/math.h [C++] (iseqsig): New implementation, which does not rely on __MATH_TG/__builtin_types_compatible_p. * math/test-math-iseqsig.cc: New file. * sysdeps/powerpc/powerpc64le/Makefile (CFLAGS-test-math-iseqsig.cc): New variable.
2017-11-03 13:44:36 +01:00
/* Test for the C++ implementation of iseqsig.
Update copyright dates with scripts/update-copyrights I used these shell commands: ../glibc/scripts/update-copyrights $PWD/../gnulib/build-aux/update-copyright (cd ../glibc && git commit -am"[this commit message]") and then ignored the output, which consisted lines saying "FOO: warning: copyright statement not found" for each of 7061 files FOO. I then removed trailing white space from math/tgmath.h, support/tst-support-open-dev-null-range.c, and sysdeps/x86_64/multiarch/strlen-vec.S, to work around the following obscure pre-commit check failure diagnostics from Savannah. I don't know why I run into these diagnostics whereas others evidently do not. remote: *** 912-#endif remote: *** 913: remote: *** 914- remote: *** error: lines with trailing whitespace found ... remote: *** error: sysdeps/unix/sysv/linux/statx_cp.c: trailing lines
2022-01-01 19:54:23 +01:00
Copyright (C) 2017-2022 Free Software Foundation, Inc.
Provide a C++ version of iseqsig (bug 22377) In C++ mode, __MATH_TG cannot be used for defining iseqsig, because __MATH_TG relies on __builtin_types_compatible_p, which is a C-only builtin. This is true when float128 is provided as an ABI-distinct type from long double. Moreover, the comparison macros from ISO C take two floating-point arguments, which need not have the same type. Choosing what underlying function to call requires evaluating the formats of the arguments, then selecting which is wider. The macro __MATH_EVAL_FMT2 provides this information, however, only the type of the macro expansion is relevant (actually evaluating the expression would be incorrect). This patch provides a C++ version of iseqsig, in which only the type of __MATH_EVAL_FMT2 (__typeof or decltype) is used as a template parameter for __iseqsig_type. This function calls the appropriate underlying function. Tested for powerpc64le and x86_64. [BZ #22377] * math/Makefile [C++] (tests): Add test for iseqsig. * math/math.h [C++] (iseqsig): New implementation, which does not rely on __MATH_TG/__builtin_types_compatible_p. * math/test-math-iseqsig.cc: New file. * sysdeps/powerpc/powerpc64le/Makefile (CFLAGS-test-math-iseqsig.cc): New variable.
2017-11-03 13:44:36 +01:00
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
Prefer https to http for gnu.org and fsf.org URLs Also, change sources.redhat.com to sourceware.org. This patch was automatically generated by running the following shell script, which uses GNU sed, and which avoids modifying files imported from upstream: sed -ri ' s,(http|ftp)(://(.*\.)?(gnu|fsf|sourceware)\.org($|[^.]|\.[^a-z])),https\2,g s,(http|ftp)(://(.*\.)?)sources\.redhat\.com($|[^.]|\.[^a-z]),https\2sourceware.org\4,g ' \ $(find $(git ls-files) -prune -type f \ ! -name '*.po' \ ! -name 'ChangeLog*' \ ! -path COPYING ! -path COPYING.LIB \ ! -path manual/fdl-1.3.texi ! -path manual/lgpl-2.1.texi \ ! -path manual/texinfo.tex ! -path scripts/config.guess \ ! -path scripts/config.sub ! -path scripts/install-sh \ ! -path scripts/mkinstalldirs ! -path scripts/move-if-change \ ! -path INSTALL ! -path locale/programs/charmap-kw.h \ ! -path po/libc.pot ! -path sysdeps/gnu/errlist.c \ ! '(' -name configure \ -execdir test -f configure.ac -o -f configure.in ';' ')' \ ! '(' -name preconfigure \ -execdir test -f preconfigure.ac ';' ')' \ -print) and then by running 'make dist-prepare' to regenerate files built from the altered files, and then executing the following to cleanup: chmod a+x sysdeps/unix/sysv/linux/riscv/configure # Omit irrelevant whitespace and comment-only changes, # perhaps from a slightly-different Autoconf version. git checkout -f \ sysdeps/csky/configure \ sysdeps/hppa/configure \ sysdeps/riscv/configure \ sysdeps/unix/sysv/linux/csky/configure # Omit changes that caused a pre-commit check to fail like this: # remote: *** error: sysdeps/powerpc/powerpc64/ppc-mcount.S: trailing lines git checkout -f \ sysdeps/powerpc/powerpc64/ppc-mcount.S \ sysdeps/unix/sysv/linux/s390/s390-64/syscall.S # Omit change that caused a pre-commit check to fail like this: # remote: *** error: sysdeps/sparc/sparc64/multiarch/memcpy-ultra3.S: last line does not end in newline git checkout -f sysdeps/sparc/sparc64/multiarch/memcpy-ultra3.S
2019-09-07 07:40:42 +02:00
<https://www.gnu.org/licenses/>. */
Provide a C++ version of iseqsig (bug 22377) In C++ mode, __MATH_TG cannot be used for defining iseqsig, because __MATH_TG relies on __builtin_types_compatible_p, which is a C-only builtin. This is true when float128 is provided as an ABI-distinct type from long double. Moreover, the comparison macros from ISO C take two floating-point arguments, which need not have the same type. Choosing what underlying function to call requires evaluating the formats of the arguments, then selecting which is wider. The macro __MATH_EVAL_FMT2 provides this information, however, only the type of the macro expansion is relevant (actually evaluating the expression would be incorrect). This patch provides a C++ version of iseqsig, in which only the type of __MATH_EVAL_FMT2 (__typeof or decltype) is used as a template parameter for __iseqsig_type. This function calls the appropriate underlying function. Tested for powerpc64le and x86_64. [BZ #22377] * math/Makefile [C++] (tests): Add test for iseqsig. * math/math.h [C++] (iseqsig): New implementation, which does not rely on __MATH_TG/__builtin_types_compatible_p. * math/test-math-iseqsig.cc: New file. * sysdeps/powerpc/powerpc64le/Makefile (CFLAGS-test-math-iseqsig.cc): New variable.
2017-11-03 13:44:36 +01:00
#define _GNU_SOURCE 1
Fix iseqsig for _FloatN and _FloatNx in C++ with GCC 13 With GCC 13, _FloatN and _FloatNx types, when they exist, are distinct types like they are in C with GCC 7 and later, rather than typedefs for types such as float, double or long double. This breaks the templated iseqsig implementation for C++ in <math.h>, when used with types that were previously implemented as aliases. Add the necessary definitions for _Float32, _Float64, _Float128 (when the same format as long double), _Float32x and _Float64x in this case, so that iseqsig can be used with such types in C++ with GCC 13 as it could with previous GCC versions. Also add tests for calling iseqsig in C++ with arguments of such types (more minimal than existing tests, so that they can work with older GCC versions and without relying on any C++ library support for the types or on hardcoding details of their formats). The LDBL_MANT_DIG != 106 conditionals on some tests are because the type-generic comparison macros have undefined behavior when neither argument has a type whose set of values is a subset of those for the type of the other argument, which applies when one argument is IBM long double and the other is an IEEE format wider than binary64. Tested with build-many-glibcs.py glibcs build for aarch64-linux-gnu i686-linux-gnu mips-linux-gnu mips64-linux-gnu-n32 powerpc-linux-gnu powerpc64le-linux-gnu x86_64-linux-gnu.
2022-09-30 21:36:41 +02:00
#include <float.h>
Provide a C++ version of iseqsig (bug 22377) In C++ mode, __MATH_TG cannot be used for defining iseqsig, because __MATH_TG relies on __builtin_types_compatible_p, which is a C-only builtin. This is true when float128 is provided as an ABI-distinct type from long double. Moreover, the comparison macros from ISO C take two floating-point arguments, which need not have the same type. Choosing what underlying function to call requires evaluating the formats of the arguments, then selecting which is wider. The macro __MATH_EVAL_FMT2 provides this information, however, only the type of the macro expansion is relevant (actually evaluating the expression would be incorrect). This patch provides a C++ version of iseqsig, in which only the type of __MATH_EVAL_FMT2 (__typeof or decltype) is used as a template parameter for __iseqsig_type. This function calls the appropriate underlying function. Tested for powerpc64le and x86_64. [BZ #22377] * math/Makefile [C++] (tests): Add test for iseqsig. * math/math.h [C++] (iseqsig): New implementation, which does not rely on __MATH_TG/__builtin_types_compatible_p. * math/test-math-iseqsig.cc: New file. * sysdeps/powerpc/powerpc64le/Makefile (CFLAGS-test-math-iseqsig.cc): New variable.
2017-11-03 13:44:36 +01:00
#include <math.h>
#include <stdio.h>
#include <limits>
/* There is no 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 NaN. */
#if __HAVE_DISTINCT_FLOAT128
# include <ieee754_float128.h>
#endif
#include <support/check.h>
static void
check (int actual, int expected, const char *actual_expr, int line)
{
if (actual != expected)
{
support_record_failure ();
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 T1, class T2>
static void
check_type ()
{
T1 t1 = 0;
T2 t2 = 0;
CHECK (iseqsig (t1, t2), 1);
t2 = 1;
CHECK (iseqsig (t1, t2), 0);
if (std::numeric_limits<T1>::has_quiet_NaN
&& std::numeric_limits<T2>::has_quiet_NaN)
{
CHECK (iseqsig (std::numeric_limits<T1>::quiet_NaN (), t2), 0);
CHECK (iseqsig (t1, std::numeric_limits<T2>::quiet_NaN ()), 0);
CHECK (iseqsig (std::numeric_limits<T1>::quiet_NaN (),
std::numeric_limits<T2>::quiet_NaN ()), 0);
}
}
Fix iseqsig for _FloatN and _FloatNx in C++ with GCC 13 With GCC 13, _FloatN and _FloatNx types, when they exist, are distinct types like they are in C with GCC 7 and later, rather than typedefs for types such as float, double or long double. This breaks the templated iseqsig implementation for C++ in <math.h>, when used with types that were previously implemented as aliases. Add the necessary definitions for _Float32, _Float64, _Float128 (when the same format as long double), _Float32x and _Float64x in this case, so that iseqsig can be used with such types in C++ with GCC 13 as it could with previous GCC versions. Also add tests for calling iseqsig in C++ with arguments of such types (more minimal than existing tests, so that they can work with older GCC versions and without relying on any C++ library support for the types or on hardcoding details of their formats). The LDBL_MANT_DIG != 106 conditionals on some tests are because the type-generic comparison macros have undefined behavior when neither argument has a type whose set of values is a subset of those for the type of the other argument, which applies when one argument is IBM long double and the other is an IEEE format wider than binary64. Tested with build-many-glibcs.py glibcs build for aarch64-linux-gnu i686-linux-gnu mips-linux-gnu mips64-linux-gnu-n32 powerpc-linux-gnu powerpc64le-linux-gnu x86_64-linux-gnu.
2022-09-30 21:36:41 +02:00
/* Run minimal tests of iseqsig for a pair of types, without relying
on C++ library support or knowledge of the representation. */
template <class T1, class T2>
static void
check_type_minimal ()
{
T1 t1 = 0;
T2 t2 = 0;
CHECK (iseqsig (t1, t2), 1);
t2 = 1;
CHECK (iseqsig (t1, t2), 0);
}
Provide a C++ version of iseqsig (bug 22377) In C++ mode, __MATH_TG cannot be used for defining iseqsig, because __MATH_TG relies on __builtin_types_compatible_p, which is a C-only builtin. This is true when float128 is provided as an ABI-distinct type from long double. Moreover, the comparison macros from ISO C take two floating-point arguments, which need not have the same type. Choosing what underlying function to call requires evaluating the formats of the arguments, then selecting which is wider. The macro __MATH_EVAL_FMT2 provides this information, however, only the type of the macro expansion is relevant (actually evaluating the expression would be incorrect). This patch provides a C++ version of iseqsig, in which only the type of __MATH_EVAL_FMT2 (__typeof or decltype) is used as a template parameter for __iseqsig_type. This function calls the appropriate underlying function. Tested for powerpc64le and x86_64. [BZ #22377] * math/Makefile [C++] (tests): Add test for iseqsig. * math/math.h [C++] (iseqsig): New implementation, which does not rely on __MATH_TG/__builtin_types_compatible_p. * math/test-math-iseqsig.cc: New file. * sysdeps/powerpc/powerpc64le/Makefile (CFLAGS-test-math-iseqsig.cc): New variable.
2017-11-03 13:44:36 +01:00
#if __HAVE_DISTINCT_FLOAT128
static void
check_float128 ()
{
ieee854_float128 q1, q2, q3_nan;
q1.d = 0;
q2.d = 1;
q3_nan.ieee_nan.negative = 0;
q3_nan.ieee_nan.exponent = 0x7FFF;
q3_nan.ieee_nan.quiet_nan = 1;
q3_nan.ieee_nan.mantissa0 = 0x0000;
q3_nan.ieee_nan.mantissa1 = 0x00000000;
q3_nan.ieee_nan.mantissa2 = 0x00000000;
q3_nan.ieee_nan.mantissa3 = 0x00000000;
CHECK (iseqsig (q1.d, q1.d), 1);
CHECK (iseqsig (q1.d, q2.d), 0);
CHECK (iseqsig (q1.d, q3_nan.d), 0);
CHECK (iseqsig (q3_nan.d, q3_nan.d), 0);
}
#endif
static int
do_test (void)
{
check_type<float, float> ();
check_type<float, double> ();
check_type<float, long double> ();
check_type<double, float> ();
check_type<double, double> ();
check_type<double, long double> ();
check_type<long double, float> ();
check_type<long double, double> ();
check_type<long double, long double> ();
#if __HAVE_DISTINCT_FLOAT128
check_float128 ();
#endif
Fix iseqsig for _FloatN and _FloatNx in C++ with GCC 13 With GCC 13, _FloatN and _FloatNx types, when they exist, are distinct types like they are in C with GCC 7 and later, rather than typedefs for types such as float, double or long double. This breaks the templated iseqsig implementation for C++ in <math.h>, when used with types that were previously implemented as aliases. Add the necessary definitions for _Float32, _Float64, _Float128 (when the same format as long double), _Float32x and _Float64x in this case, so that iseqsig can be used with such types in C++ with GCC 13 as it could with previous GCC versions. Also add tests for calling iseqsig in C++ with arguments of such types (more minimal than existing tests, so that they can work with older GCC versions and without relying on any C++ library support for the types or on hardcoding details of their formats). The LDBL_MANT_DIG != 106 conditionals on some tests are because the type-generic comparison macros have undefined behavior when neither argument has a type whose set of values is a subset of those for the type of the other argument, which applies when one argument is IBM long double and the other is an IEEE format wider than binary64. Tested with build-many-glibcs.py glibcs build for aarch64-linux-gnu i686-linux-gnu mips-linux-gnu mips64-linux-gnu-n32 powerpc-linux-gnu powerpc64le-linux-gnu x86_64-linux-gnu.
2022-09-30 21:36:41 +02:00
#if __HAVE_FLOAT16
check_type_minimal<float, _Float16> ();
#endif
#if __HAVE_FLOAT32
check_type_minimal<float, _Float32> ();
#endif
#if __HAVE_FLOAT64
check_type_minimal<float, _Float64> ();
#endif
#if __HAVE_FLOAT128
check_type_minimal<float, _Float128> ();
#endif
#if __HAVE_FLOAT32X
check_type_minimal<float, _Float32x> ();
#endif
#if __HAVE_FLOAT64X
check_type_minimal<float, _Float64x> ();
#endif
#if __HAVE_FLOAT128X
check_type_minimal<float, _Float128x> ();
#endif
#if __HAVE_FLOAT16
check_type_minimal<double, _Float16> ();
#endif
#if __HAVE_FLOAT32
check_type_minimal<double, _Float32> ();
#endif
#if __HAVE_FLOAT64
check_type_minimal<double, _Float64> ();
#endif
#if __HAVE_FLOAT128
check_type_minimal<double, _Float128> ();
#endif
#if __HAVE_FLOAT32X
check_type_minimal<double, _Float32x> ();
#endif
#if __HAVE_FLOAT64X
check_type_minimal<double, _Float64x> ();
#endif
#if __HAVE_FLOAT128X
check_type_minimal<double, _Float128x> ();
#endif
#if __HAVE_FLOAT16
check_type_minimal<long double, _Float16> ();
#endif
#if __HAVE_FLOAT32
check_type_minimal<long double, _Float32> ();
#endif
#if __HAVE_FLOAT64
check_type_minimal<long double, _Float64> ();
#endif
#if __HAVE_FLOAT128 && LDBL_MANT_DIG != 106
check_type_minimal<long double, _Float128> ();
#endif
#if __HAVE_FLOAT32X
check_type_minimal<long double, _Float32x> ();
#endif
#if __HAVE_FLOAT64X && LDBL_MANT_DIG != 106
check_type_minimal<long double, _Float64x> ();
#endif
#if __HAVE_FLOAT128X && LDBL_MANT_DIG != 106
check_type_minimal<long double, _Float128x> ();
#endif
#if __HAVE_FLOAT16
check_type_minimal<_Float16, float> ();
#endif
#if __HAVE_FLOAT16
check_type_minimal<_Float16, double> ();
#endif
#if __HAVE_FLOAT16
check_type_minimal<_Float16, long double> ();
#endif
#if __HAVE_FLOAT16
check_type_minimal<_Float16, _Float16> ();
#endif
#if __HAVE_FLOAT16 && __HAVE_FLOAT32
check_type_minimal<_Float16, _Float32> ();
#endif
#if __HAVE_FLOAT16 && __HAVE_FLOAT64
check_type_minimal<_Float16, _Float64> ();
#endif
#if __HAVE_FLOAT16 && __HAVE_FLOAT128
check_type_minimal<_Float16, _Float128> ();
#endif
#if __HAVE_FLOAT16 && __HAVE_FLOAT32X
check_type_minimal<_Float16, _Float32x> ();
#endif
#if __HAVE_FLOAT16 && __HAVE_FLOAT64X
check_type_minimal<_Float16, _Float64x> ();
#endif
#if __HAVE_FLOAT16 && __HAVE_FLOAT128X
check_type_minimal<_Float16, _Float128x> ();
#endif
#if __HAVE_FLOAT32
check_type_minimal<_Float32, float> ();
#endif
#if __HAVE_FLOAT32
check_type_minimal<_Float32, double> ();
#endif
#if __HAVE_FLOAT32
check_type_minimal<_Float32, long double> ();
#endif
#if __HAVE_FLOAT32 && __HAVE_FLOAT16
check_type_minimal<_Float32, _Float16> ();
#endif
#if __HAVE_FLOAT32
check_type_minimal<_Float32, _Float32> ();
#endif
#if __HAVE_FLOAT32 && __HAVE_FLOAT64
check_type_minimal<_Float32, _Float64> ();
#endif
#if __HAVE_FLOAT32 && __HAVE_FLOAT128
check_type_minimal<_Float32, _Float128> ();
#endif
#if __HAVE_FLOAT32 && __HAVE_FLOAT32X
check_type_minimal<_Float32, _Float32x> ();
#endif
#if __HAVE_FLOAT32 && __HAVE_FLOAT64X
check_type_minimal<_Float32, _Float64x> ();
#endif
#if __HAVE_FLOAT32 && __HAVE_FLOAT128X
check_type_minimal<_Float32, _Float128x> ();
#endif
#if __HAVE_FLOAT64
check_type_minimal<_Float64, float> ();
#endif
#if __HAVE_FLOAT64
check_type_minimal<_Float64, double> ();
#endif
#if __HAVE_FLOAT64
check_type_minimal<_Float64, long double> ();
#endif
#if __HAVE_FLOAT64 && __HAVE_FLOAT16
check_type_minimal<_Float64, _Float16> ();
#endif
#if __HAVE_FLOAT64 && __HAVE_FLOAT32
check_type_minimal<_Float64, _Float32> ();
#endif
#if __HAVE_FLOAT64
check_type_minimal<_Float64, _Float64> ();
#endif
#if __HAVE_FLOAT64 && __HAVE_FLOAT128
check_type_minimal<_Float64, _Float128> ();
#endif
#if __HAVE_FLOAT64 && __HAVE_FLOAT32X
check_type_minimal<_Float64, _Float32x> ();
#endif
#if __HAVE_FLOAT64 && __HAVE_FLOAT64X
check_type_minimal<_Float64, _Float64x> ();
#endif
#if __HAVE_FLOAT64 && __HAVE_FLOAT128X
check_type_minimal<_Float64, _Float128x> ();
#endif
#if __HAVE_FLOAT128
check_type_minimal<_Float128, float> ();
#endif
#if __HAVE_FLOAT128
check_type_minimal<_Float128, double> ();
#endif
#if __HAVE_FLOAT128 && LDBL_MANT_DIG != 106
check_type_minimal<_Float128, long double> ();
#endif
#if __HAVE_FLOAT128 && __HAVE_FLOAT16
check_type_minimal<_Float128, _Float16> ();
#endif
#if __HAVE_FLOAT128 && __HAVE_FLOAT32
check_type_minimal<_Float128, _Float32> ();
#endif
#if __HAVE_FLOAT128 && __HAVE_FLOAT64
check_type_minimal<_Float128, _Float64> ();
#endif
#if __HAVE_FLOAT128
check_type_minimal<_Float128, _Float128> ();
#endif
#if __HAVE_FLOAT128 && __HAVE_FLOAT32X
check_type_minimal<_Float128, _Float32x> ();
#endif
#if __HAVE_FLOAT128 && __HAVE_FLOAT64X
check_type_minimal<_Float128, _Float64x> ();
#endif
#if __HAVE_FLOAT128 && __HAVE_FLOAT128X
check_type_minimal<_Float128, _Float128x> ();
#endif
#if __HAVE_FLOAT32X
check_type_minimal<_Float32x, float> ();
#endif
#if __HAVE_FLOAT32X
check_type_minimal<_Float32x, double> ();
#endif
#if __HAVE_FLOAT32X
check_type_minimal<_Float32x, long double> ();
#endif
#if __HAVE_FLOAT32X && __HAVE_FLOAT16
check_type_minimal<_Float32x, _Float16> ();
#endif
#if __HAVE_FLOAT32X && __HAVE_FLOAT32
check_type_minimal<_Float32x, _Float32> ();
#endif
#if __HAVE_FLOAT32X && __HAVE_FLOAT64
check_type_minimal<_Float32x, _Float64> ();
#endif
#if __HAVE_FLOAT32X && __HAVE_FLOAT128
check_type_minimal<_Float32x, _Float128> ();
#endif
#if __HAVE_FLOAT32X
check_type_minimal<_Float32x, _Float32x> ();
#endif
#if __HAVE_FLOAT32X && __HAVE_FLOAT64X
check_type_minimal<_Float32x, _Float64x> ();
#endif
#if __HAVE_FLOAT32X && __HAVE_FLOAT128X
check_type_minimal<_Float32x, _Float128x> ();
#endif
#if __HAVE_FLOAT64X
check_type_minimal<_Float64x, float> ();
#endif
#if __HAVE_FLOAT64X
check_type_minimal<_Float64x, double> ();
#endif
#if __HAVE_FLOAT64X && LDBL_MANT_DIG != 106
check_type_minimal<_Float64x, long double> ();
#endif
#if __HAVE_FLOAT64X && __HAVE_FLOAT16
check_type_minimal<_Float64x, _Float16> ();
#endif
#if __HAVE_FLOAT64X && __HAVE_FLOAT32
check_type_minimal<_Float64x, _Float32> ();
#endif
#if __HAVE_FLOAT64X && __HAVE_FLOAT64
check_type_minimal<_Float64x, _Float64> ();
#endif
#if __HAVE_FLOAT64X && __HAVE_FLOAT128
check_type_minimal<_Float64x, _Float128> ();
#endif
#if __HAVE_FLOAT64X && __HAVE_FLOAT32X
check_type_minimal<_Float64x, _Float32x> ();
#endif
#if __HAVE_FLOAT64X
check_type_minimal<_Float64x, _Float64x> ();
#endif
#if __HAVE_FLOAT64X && __HAVE_FLOAT128X
check_type_minimal<_Float64x, _Float128x> ();
#endif
#if __HAVE_FLOAT128X
check_type_minimal<_Float128x, float> ();
#endif
#if __HAVE_FLOAT128X
check_type_minimal<_Float128x, double> ();
#endif
#if __HAVE_FLOAT128X && LDBL_MANT_DIG != 106
check_type_minimal<_Float128x, long double> ();
#endif
#if __HAVE_FLOAT128X && __HAVE_FLOAT16
check_type_minimal<_Float128x, _Float16> ();
#endif
#if __HAVE_FLOAT128X && __HAVE_FLOAT32
check_type_minimal<_Float128x, _Float32> ();
#endif
#if __HAVE_FLOAT128X && __HAVE_FLOAT64
check_type_minimal<_Float128x, _Float64> ();
#endif
#if __HAVE_FLOAT128X && __HAVE_FLOAT128
check_type_minimal<_Float128x, _Float128> ();
#endif
#if __HAVE_FLOAT128X && __HAVE_FLOAT32X
check_type_minimal<_Float128x, _Float32x> ();
#endif
#if __HAVE_FLOAT128X && __HAVE_FLOAT64X
check_type_minimal<_Float128x, _Float64x> ();
#endif
#if __HAVE_FLOAT128X
check_type_minimal<_Float128x, _Float128x> ();
#endif
Provide a C++ version of iseqsig (bug 22377) In C++ mode, __MATH_TG cannot be used for defining iseqsig, because __MATH_TG relies on __builtin_types_compatible_p, which is a C-only builtin. This is true when float128 is provided as an ABI-distinct type from long double. Moreover, the comparison macros from ISO C take two floating-point arguments, which need not have the same type. Choosing what underlying function to call requires evaluating the formats of the arguments, then selecting which is wider. The macro __MATH_EVAL_FMT2 provides this information, however, only the type of the macro expansion is relevant (actually evaluating the expression would be incorrect). This patch provides a C++ version of iseqsig, in which only the type of __MATH_EVAL_FMT2 (__typeof or decltype) is used as a template parameter for __iseqsig_type. This function calls the appropriate underlying function. Tested for powerpc64le and x86_64. [BZ #22377] * math/Makefile [C++] (tests): Add test for iseqsig. * math/math.h [C++] (iseqsig): New implementation, which does not rely on __MATH_TG/__builtin_types_compatible_p. * math/test-math-iseqsig.cc: New file. * sysdeps/powerpc/powerpc64le/Makefile (CFLAGS-test-math-iseqsig.cc): New variable.
2017-11-03 13:44:36 +01:00
return 0;
}
#include <support/test-driver.c>
Reference in a new issue Copy permalink