From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1005) id 7B39C3851C0B; Wed, 7 Jul 2021 17:47:45 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 7B39C3851C0B Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Michael Meissner To: gcc-cvs@gcc.gnu.org Subject: [gcc(refs/users/meissner/heads/work059)] Fix long double tests when default long double is not IBM. X-Act-Checkin: gcc X-Git-Author: Michael Meissner X-Git-Refname: refs/users/meissner/heads/work059 X-Git-Oldrev: 2464fa9843115be82b45de6eab067bd5dbac1947 X-Git-Newrev: f8fa1fd7e3f96cdc06c62b7e8a1f1705bf66acc7 Message-Id: <20210707174745.7B39C3851C0B@sourceware.org> Date: Wed, 7 Jul 2021 17:47:45 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 07 Jul 2021 17:47:45 -0000 https://gcc.gnu.org/g:f8fa1fd7e3f96cdc06c62b7e8a1f1705bf66acc7 commit f8fa1fd7e3f96cdc06c62b7e8a1f1705bf66acc7 Author: Michael Meissner Date: Wed Jul 7 13:47:28 2021 -0400 Fix long double tests when default long double is not IBM. This patch adds 3 more selections to target-supports.exp to see if we can force the compiler to use a particular long double format (IEEE 128-bit, IBM extended double, 64-bit), and the library support will track the changes for the long double. This is needed because two of the tests in the test suite use long double, and they are actually testing IBM extended double. This patch also forces the two tests that explicitly require long double to use the IBM double-double encoding to explicitly run the test. This requires GLIBC 2.32 or greater in order to do the switch. I have run tests on a little endian power9 system with 3 compilers. There were no regressions with these patches, and the two tests in the following patches now work if the default long double is not IBM 128-bit: * One compiler used the default IBM 128-bit format; * One compiler used the IEEE 128-bit format; (and) * One compiler used 64-bit long doubles. I have also tested compilers on a big endian power8 system with a compiler defaulting to power8 code generation and another with the default cpu set. There were no regressions. Can I check this patch into the master branch? 2021-07-07 Michael Meissner gcc/testsuite/ PR target/70117 * gcc.target/powerpc/pr70117.c: Force the long double type to use the IBM 128-bit format. * c-c++-common/dfp/convert-bfp-11.c: Force using IBM 128-bit long double. Remove check for 64-bit long double. * lib/target-supports.exp (add_options_for_ppc_long_double_override_ibm128): New function. (check_effective_target_ppc_long_double_override_ibm128): New function. (add_options_for_ppc_long_double_override_ieee128): New function. (check_effective_target_ppc_long_double_override_ieee128): New function. (add_options_for_ppc_long_double_override_64bit): New function. (check_effective_target_ppc_long_double_override_64bit): New function. Diff: --- gcc/testsuite/c-c++-common/dfp/convert-bfp-11.c | 18 ++-- gcc/testsuite/gcc.target/powerpc/pr70117.c | 6 +- gcc/testsuite/lib/target-supports.exp | 107 ++++++++++++++++++++++++ 3 files changed, 121 insertions(+), 10 deletions(-) diff --git a/gcc/testsuite/c-c++-common/dfp/convert-bfp-11.c b/gcc/testsuite/c-c++-common/dfp/convert-bfp-11.c index 95c433d2c24..35da07d1fa4 100644 --- a/gcc/testsuite/c-c++-common/dfp/convert-bfp-11.c +++ b/gcc/testsuite/c-c++-common/dfp/convert-bfp-11.c @@ -1,9 +1,14 @@ -/* { dg-skip-if "" { ! "powerpc*-*-linux*" } } */ +/* { dg-require-effective-target dfp } */ +/* { dg-require-effective-target ppc_long_double_override_ibm128 } */ +/* { dg-add-options ppc_long_double_override_ibm128 } */ -/* Test decimal float conversions to and from IBM 128-bit long double. - Checks are skipped at runtime if long double is not 128 bits. - Don't force 128-bit long doubles because runtime support depends - on glibc. */ +/* We force the long double type to be IBM 128-bit because the CONVERT_TO_PINF + tests will fail if we use IEEE 128-bit floating point. This is due to IEEE + 128-bit having a larger exponent range than IBM 128-bit extended double. So + tests that would generate an infinity with IBM 128-bit will generate a + normal number with IEEE 128-bit. */ + +/* Test decimal float conversions to and from IBM 128-bit long double. */ #include "convert.h" @@ -36,9 +41,6 @@ CONVERT_TO_PINF (312, tf, sd, 1.6e+308L, d32) int main () { - if (sizeof (long double) != 16) - return 0; - convert_101 (); convert_102 (); diff --git a/gcc/testsuite/gcc.target/powerpc/pr70117.c b/gcc/testsuite/gcc.target/powerpc/pr70117.c index 3bbd2c595e0..8a5fad1dee0 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr70117.c +++ b/gcc/testsuite/gcc.target/powerpc/pr70117.c @@ -1,5 +1,7 @@ -/* { dg-do run { target { powerpc*-*-linux* powerpc*-*-darwin* powerpc*-*-aix* rs6000-*-* } } } */ -/* { dg-options "-std=c99 -mlong-double-128 -O2" } */ +/* { dg-do run } */ +/* { dg-require-effective-target ppc_long_double_override_ibm128 } */ +/* { dg-options "-std=c99 -O2" } */ +/* { dg-add-options ppc_long_double_override_ibm128 } */ #include diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index 789723fb287..0a392cb0fd5 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -2360,6 +2360,113 @@ proc check_effective_target_ppc_ieee128_ok { } { }] } +# Check if we can explicitly override the long double format to use the IBM +# 128-bit extended double format, and GLIBC supports doing this override by +# switching the sprintf to handle IBM 128-bit long double. + +proc add_options_for_ppc_long_double_override_ibm128 { flags } { + if { [istarget powerpc*-*-*] } { + return "$flags -mlong-double-128 -Wno-psabi -mabi=ibmlongdouble" + } + return "$flags" +} + +proc check_effective_target_ppc_long_double_override_ibm128 { } { + return [check_runtime_nocache ppc_long_double_override_ibm128 { + #include + #include + volatile __ibm128 a = (__ibm128) 3.0; + volatile long double one = 1.0L; + volatile long double two = 2.0L; + volatile long double b; + char buffer[20]; + int main() + { + #if !defined(_ARCH_PPC) || !defined(__LONG_DOUBLE_IBM128__) + return 1; + #else + b = one + two; + if (memcmp ((void *)&a, (void *)&b, sizeof (long double)) != 0) + return 1; + sprintf (buffer, "%lg", b); + return strcmp (buffer, "3") != 0; + #endif + } + } [add_options_for_ppc_long_double_override_ibm128 ""]] +} + +# Check if we can explicitly override the long double format to use the IEEE +# 128-bit format, and GLIBC supports doing this override by switching the +# sprintf to handle IEEE 128-bit long double. + +proc add_options_for_ppc_long_double_override_ieee128 { flags } { + if { [istarget powerpc*-*-*] } { + return "$flags -mlong-double-128 -Wno-psabi -mabi=ieeelongdouble" + } + return "$flags" +} + +proc check_effective_target_ppc_long_double_override_ieee128 { } { + return [check_runtime_nocache ppc_long_double_override_ieee128 { + #include + #include + volatile _Float128 a = 3.0f128; + volatile long double one = 1.0L; + volatile long double two = 2.0L; + volatile long double b; + char buffer[20]; + int main() + { + #if !defined(_ARCH_PPC) || !defined(__LONG_DOUBLE_IEEE128__) + return 1; + #else + b = one + two; + if (memcmp ((void *)&a, (void *)&b, sizeof (long double)) != 0) + return 1; + sprintf (buffer, "%lg", b); + return strcmp (buffer, "3") != 0; + #endif + } + } [add_options_for_ppc_long_double_override_ieee128 ""]] +} + +# Check if we can explicitly override the long double format to use 64-bit +# floating point, and GLIBC supports doing this override by switching the +# sprintf to handle 64-bit long double. + +proc add_options_for_ppc_long_double_override_64bit { flags } { + if { [istarget powerpc*-*-*] } { + return "$flags -mlong-double-64" + } + return "$flags" +} + +proc check_effective_target_ppc_long_double_override_64bit { } { + return [check_runtime_nocache ppc_long_double_override_64bit { + #include + #include + volatile double a = 3.0; + volatile long double one = 1.0L; + volatile long double two = 2.0L; + volatile long double b; + char buffer[20]; + int main() + { + #if !defined(_ARCH_PPC) || defined(__LONG_DOUBLE_128__) + return 1; + #else + if (sizeof (long double) != sizeof (double)) + return 1; + b = one + two; + if (memcmp ((void *)&a, (void *)&b, sizeof (long double)) != 0) + return 1; + sprintf (buffer, "%lg", b); + return strcmp (buffer, "3") != 0; + #endif + } + } [add_options_for_ppc_long_double_override_64bit ""]] +} + # Return 1 if the target supports executing VSX instructions, 0 # otherwise. Cache the result.