From 7e3cd5454ea057e848ca072bede1a73a32668af3 Mon Sep 17 00:00:00 2001 From: Michael Meissner Date: Wed, 28 Apr 2021 20:28:26 -0400 Subject: [PATCH] Add long double target-supports on PowerPC. This patch add several more selections to target-supports.exp: * 3 selections if we can change the long double format to a particular value. * 3 functions to return the options needed to switch the long double format for use with dg-add-options. 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? gcc/testsuite/ 2021-04-28 Michael Meissner * 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. --- gcc/testsuite/lib/target-supports.exp | 107 ++++++++++++++++++++++++++ 1 file changed, 107 insertions(+) diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index a522da322aa8..88991272a889 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. -- 2.43.5