From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from esa1.mentor.iphmx.com (esa1.mentor.iphmx.com [68.232.129.153]) by sourceware.org (Postfix) with ESMTPS id 18F9D3858D28 for ; Thu, 29 Sep 2022 00:15:19 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 18F9D3858D28 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=codesourcery.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=mentor.com X-IronPort-AV: E=Sophos;i="5.93,353,1654588800"; d="scan'208";a="86595853" Received: from orw-gwy-02-in.mentorg.com ([192.94.38.167]) by esa1.mentor.iphmx.com with ESMTP; 28 Sep 2022 16:15:14 -0800 IronPort-SDR: YeBnWWxbY62DW9HQrPH7WgHvxlimHEtnMEv3i/LSrTxvYqF7sLL19ITxMdd3qtc1G9oIxWAxKR LFG2AnL9BvvsSnkD/ZKl3aiDMZNb8CuP4nwirxgjb0xTKcvr4D1yuT5x/OYqrEcHuG7vtlYj36 jCV0fDrud7Ov4FqXl6X6LH/oZPRUYWyYPt3lRS4Fld4EnM01SSmGH2QpzmAnQf6YcHEFJDH+yJ KP1Skeb5SS6uPdoWGN+ewxkMSC04gCtA6AfgLRtOVBQTX1LtHfqimULc7XTSN1/XCvjzmnUZP0 UMs= Date: Thu, 29 Sep 2022 00:15:09 +0000 From: Joseph Myers X-X-Sender: jsm28@digraph.polyomino.org.uk To: CC: Subject: Fix iseqsig for _FloatN and _FloatNx in C++ with GCC 13 Message-ID: User-Agent: Alpine 2.22 (DEB 394 2020-01-19) MIME-Version: 1.0 Content-Type: text/plain; charset="US-ASCII" X-Originating-IP: [137.202.0.90] X-ClientProxiedBy: svr-ies-mbx-13.mgc.mentorg.com (139.181.222.13) To svr-ies-mbx-10.mgc.mentorg.com (139.181.222.10) X-Spam-Status: No, score=-3116.7 required=5.0 tests=BAYES_00,GIT_PATCH_0,HEADER_FROM_DIFFERENT_DOMAINS,KAM_DMARC_STATUS,KAM_NUMSUBJECT,KAM_SHORT,SPF_HELO_PASS,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: 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 , 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 ia64-linux-gnu i686-linux-gnu mips-linux-gnu mips64-linux-gnu-n32 powerpc-linux-gnu powerpc64le-linux-gnu x86_64-linux-gnu. Note that there is an ICE building the glibc testsuite for x86_64 / i686 / ia64 , which will need to be resolved to complete testing this patch. --- I am seeking review of this patch, not applying it as a math maintainer. Also, full testing will need GCC bug 107080 (test reduced from an ICE building the glibc testcase modified by this patch) to be fixed. diff --git a/math/math.h b/math/math.h index 27963ef6dc..cf980c37c3 100644 --- a/math/math.h +++ b/math/math.h @@ -1391,14 +1391,62 @@ template<> struct __iseqsig_type } }; -# if __HAVE_FLOAT128_UNLIKE_LDBL +# if __HAVE_FLOAT32 && __GNUC_PREREQ (13, 0) +template<> struct __iseqsig_type<_Float32> +{ + static int __call (_Float32 __x, _Float32 __y) throw () + { + return __iseqsigf (__x, __y); + } +}; +# endif + +# if __HAVE_FLOAT64 && __GNUC_PREREQ (13, 0) +template<> struct __iseqsig_type<_Float64> +{ + static int __call (_Float64 __x, _Float64 __y) throw () + { + return __iseqsig (__x, __y); + } +}; +# endif + +# if __HAVE_FLOAT128_UNLIKE_LDBL || (__HAVE_FLOAT128 && __GNUC_PREREQ (13, 0)) /* When using an IEEE 128-bit long double, _Float128 is defined as long double in C++. */ template<> struct __iseqsig_type<_Float128> { static int __call (_Float128 __x, _Float128 __y) throw () { +# if __HAVE_FLOAT128_UNLIKE_LDBL return __iseqsigf128 (__x, __y); +# else + return __iseqsigl (__x, __y); +# endif + } +}; +# endif + +# if __HAVE_FLOAT32X && __GNUC_PREREQ (13, 0) +template<> struct __iseqsig_type<_Float32x> +{ + static int __call (_Float32x __x, _Float32x __y) throw () + { + return __iseqsig (__x, __y); + } +}; +# endif + +# if __HAVE_FLOAT64X && __GNUC_PREREQ (13, 0) +template<> struct __iseqsig_type<_Float64x> +{ + static int __call (_Float64x __x, _Float64x __y) throw () + { +# if __HAVE_FLOAT64X_LONG_DOUBLE + return __iseqsigl (__x, __y); +# else + return __iseqsigf128 (__x, __y); +# endif } }; # endif diff --git a/math/test-math-iseqsig.cc b/math/test-math-iseqsig.cc index 59a84d57bd..44be4aeba8 100644 --- a/math/test-math-iseqsig.cc +++ b/math/test-math-iseqsig.cc @@ -17,6 +17,7 @@ . */ #define _GNU_SOURCE 1 +#include #include #include @@ -67,6 +68,20 @@ check_type () } } +/* Run minimal tests of iseqsig for a pair of types, without relying + on C++ library support or knowledge of the representation. */ +template +static void +check_type_minimal () +{ + T1 t1 = 0; + T2 t2 = 0; + CHECK (iseqsig (t1, t2), 1); + + t2 = 1; + CHECK (iseqsig (t1, t2), 0); +} + #if __HAVE_DISTINCT_FLOAT128 static void check_float128 () @@ -105,6 +120,281 @@ do_test (void) #if __HAVE_DISTINCT_FLOAT128 check_float128 (); #endif + +#if __HAVE_FLOAT16 + check_type_minimal (); +#endif +#if __HAVE_FLOAT32 + check_type_minimal (); +#endif +#if __HAVE_FLOAT64 + check_type_minimal (); +#endif +#if __HAVE_FLOAT128 + check_type_minimal (); +#endif +#if __HAVE_FLOAT32X + check_type_minimal (); +#endif +#if __HAVE_FLOAT64X + check_type_minimal (); +#endif +#if __HAVE_FLOAT128X + check_type_minimal (); +#endif +#if __HAVE_FLOAT16 + check_type_minimal (); +#endif +#if __HAVE_FLOAT32 + check_type_minimal (); +#endif +#if __HAVE_FLOAT64 + check_type_minimal (); +#endif +#if __HAVE_FLOAT128 + check_type_minimal (); +#endif +#if __HAVE_FLOAT32X + check_type_minimal (); +#endif +#if __HAVE_FLOAT64X + check_type_minimal (); +#endif +#if __HAVE_FLOAT128X + check_type_minimal (); +#endif +#if __HAVE_FLOAT16 + check_type_minimal (); +#endif +#if __HAVE_FLOAT32 + check_type_minimal (); +#endif +#if __HAVE_FLOAT64 + check_type_minimal (); +#endif +#if __HAVE_FLOAT128 && LDBL_MANT_DIG != 106 + check_type_minimal (); +#endif +#if __HAVE_FLOAT32X + check_type_minimal (); +#endif +#if __HAVE_FLOAT64X && LDBL_MANT_DIG != 106 + check_type_minimal (); +#endif +#if __HAVE_FLOAT128X && LDBL_MANT_DIG != 106 + check_type_minimal (); +#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 + return 0; } -- Joseph S. Myers joseph@codesourcery.com