From patchwork Fri Aug 13 04:09:24 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michael Meissner X-Patchwork-Id: 1516520 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=o98UErg5; dkim-atps=neutral Received: from sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4Gm9873kF3z9sX5 for ; Fri, 13 Aug 2021 14:10:30 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 6E7443998007 for ; Fri, 13 Aug 2021 04:10:27 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 6E7443998007 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1628827827; bh=lPnz7sIOk2dYb2diCEUMfeL7cOs0SxTbas3MFm8fPsY=; h=Date:To:Subject:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=o98UErg5XoURalwYNMfZX9XOV6uiyUMCebt0UElwhnsDoeKipQ/I8DOpy43bGEB13 kL5Pt42R2mU7LSj+znEe+bcUyiWB9hTSkJh+j0HmV9CXqfIGvakG75wyUEYvAPG5DM BoxZIHZ9mOJEmcsYFGXkKIhS6/fnzhFpOK0tt/0o= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mx0a-001b2d01.pphosted.com (mx0a-001b2d01.pphosted.com [148.163.156.1]) by sourceware.org (Postfix) with ESMTPS id 63557385781B for ; Fri, 13 Aug 2021 04:09:35 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 63557385781B Received: from pps.filterd (m0187473.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.16.0.43/8.16.0.43) with SMTP id 17D42uLB132227; Fri, 13 Aug 2021 00:09:32 -0400 Received: from pps.reinject (localhost [127.0.0.1]) by mx0a-001b2d01.pphosted.com with ESMTP id 3acstpemp1-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 13 Aug 2021 00:09:32 -0400 Received: from m0187473.ppops.net (m0187473.ppops.net [127.0.0.1]) by pps.reinject (8.16.0.43/8.16.0.43) with SMTP id 17D45Ait139329; Fri, 13 Aug 2021 00:09:31 -0400 Received: from ppma03wdc.us.ibm.com (ba.79.3fa9.ip4.static.sl-reverse.com [169.63.121.186]) by mx0a-001b2d01.pphosted.com with ESMTP id 3acstpemnq-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 13 Aug 2021 00:09:31 -0400 Received: from pps.filterd (ppma03wdc.us.ibm.com [127.0.0.1]) by ppma03wdc.us.ibm.com (8.16.1.2/8.16.1.2) with SMTP id 17D43jIP030268; Fri, 13 Aug 2021 04:09:30 GMT Received: from b03cxnp07027.gho.boulder.ibm.com (b03cxnp07027.gho.boulder.ibm.com [9.17.130.14]) by ppma03wdc.us.ibm.com with ESMTP id 3a9htfajcc-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 13 Aug 2021 04:09:30 +0000 Received: from b03ledav006.gho.boulder.ibm.com (b03ledav006.gho.boulder.ibm.com [9.17.130.237]) by b03cxnp07027.gho.boulder.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 17D49TdI35127746 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 13 Aug 2021 04:09:29 GMT Received: from b03ledav006.gho.boulder.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 5DC6FC6057; Fri, 13 Aug 2021 04:09:29 +0000 (GMT) Received: from b03ledav006.gho.boulder.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 8572CC605A; Fri, 13 Aug 2021 04:09:28 +0000 (GMT) Received: from toto.the-meissners.org (unknown [9.160.31.187]) by b03ledav006.gho.boulder.ibm.com (Postfix) with ESMTPS; Fri, 13 Aug 2021 04:09:28 +0000 (GMT) Date: Fri, 13 Aug 2021 00:09:24 -0400 To: gcc-patches@gcc.gnu.org, Michael Meissner , Segher Boessenkool , David Edelsohn , Bill Schmidt , Peter Bergner , Will Schmidt Subject: [PATCH] Fix tests that require IBM 128-bit long double Message-ID: Mail-Followup-To: Michael Meissner , gcc-patches@gcc.gnu.org, Segher Boessenkool , David Edelsohn , Bill Schmidt , Peter Bergner , Will Schmidt MIME-Version: 1.0 Content-Disposition: inline X-TM-AS-GCONF: 00 X-Proofpoint-GUID: mkt6uwubkvjqauizQ5wN6ptZi9YEQA39 X-Proofpoint-ORIG-GUID: JeFqmEQPqea-D9tFLIrF3oNM4s1RBK4p X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.391, 18.0.790 definitions=2021-08-13_01:2021-08-12, 2021-08-13 signatures=0 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 lowpriorityscore=0 malwarescore=0 adultscore=0 clxscore=1015 priorityscore=1501 bulkscore=0 suspectscore=0 mlxlogscore=999 phishscore=0 impostorscore=0 spamscore=0 mlxscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2107140000 definitions=main-2108130024 X-Spam-Status: No, score=-10.3 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_EF, GIT_PATCH_0, KAM_MANYTO, KAM_SHORT, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Michael Meissner via Gcc-patches From: Michael Meissner Reply-To: Michael Meissner Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Fix tests that require IBM 128-bit long double I posted an earlier version of this patch on July 7th, and Segher had some comments about it on July 14th. This is a revised version of the patch * My patch: Message-ID: <20210707195837.GA28511@ibm-toto.the-meissners.org> * Seger's reply: Message-ID: <20210714223208.GF1583@gate.crashing.org> This patch adds 3 more selections to target-supports.exp to see if we can specify 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 just reverified that this patch still works on a little endian power9 system running Linux. 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. Compared the to last version that I posted, I simplified the fucntion names (eliminating the 'ppc_' and 'override_' parts). I have changed the length parameter from using sizeof to just using 16. I removed the #if code in the tests. I changed the comments. I did not remove the void * casts in calling memcmp, because not having those casts will cause the test to fail. This is because the variables are declared volatile, and GCC now complains that you are discarding the volatile in doing the call. Having this warning makes the test fail. Can I check this patch into the master branch? 2021-08-12 Michael Meissner gcc/testsuite/ PR target/94630 * gcc.target/powerpc/pr70117.c: Specify that we need the long double type to be IBM 128-bit. Remove the code to use __ibm128. * c-c++-common/dfp/convert-bfp-11.c: Specify that we need the long double type to be IBM 128-bit. Run the test at -O2 optimization. * lib/target-supports.exp (add_options_for_long_double_ibm128): New function. (check_effective_target_long_double_ibm128): New function. (add_options_for_long_double_ieee128): New function. (check_effective_target_long_double_ieee128): New function. (add_options_for_long_double_64bit): New function. (check_effective_target_long_double_64bit): New function. --- .../c-c++-common/dfp/convert-bfp-11.c | 20 ++-- gcc/testsuite/gcc.target/powerpc/pr70117.c | 24 ++-- gcc/testsuite/lib/target-supports.exp | 110 ++++++++++++++++++ 3 files changed, 130 insertions(+), 24 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..c09c8342bbb 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,16 @@ -/* { dg-skip-if "" { ! "powerpc*-*-linux*" } } */ +/* { dg-require-effective-target dfp } */ -/* 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 need 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. */ + +/* { dg-require-effective-target long_double_ibm128 } */ +/* { dg-options "-O2" } */ +/* { dg-add-options long_double_ibm128 } */ + +/* Test decimal float conversions to and from IBM 128-bit long double. */ #include "convert.h" @@ -36,9 +43,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..4a51f583157 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr70117.c +++ b/gcc/testsuite/gcc.target/powerpc/pr70117.c @@ -1,26 +1,18 @@ -/* { 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 long_double_ibm128 } */ +/* { dg-options "-std=c99 -O2" } */ +/* { dg-add-options long_double_ibm128 } */ #include -#if defined(__LONG_DOUBLE_IEEE128__) -/* If long double is IEEE 128-bit, we need to use the __ibm128 type instead of - long double. We can't use __ibm128 on systems that don't support IEEE - 128-bit floating point, because the type is not enabled on those - systems. */ -#define LDOUBLE __ibm128 - -#elif defined(__LONG_DOUBLE_IBM128__) -#define LDOUBLE long double - -#else -#error "long double must be either IBM 128-bit or IEEE 128-bit" +#ifndef __LONG_DOUBLE_IBM128__ +#error "long double must be IBM 128-bit" #endif union gl_long_double_union { struct { double hi; double lo; } dd; - LDOUBLE ld; + long double ld; }; /* This is gnulib's LDBL_MAX which, being 107 bits in precision, is @@ -36,7 +28,7 @@ volatile double dnan = 0.0/0.0; int main (void) { - LDOUBLE ld; + long double ld; ld = gl_LDBL_MAX.ld; if (__builtin_isinf (ld)) diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index 44465b14b06..09664e88537 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -2360,6 +2360,116 @@ proc check_effective_target_ppc_ieee128_ok { } { }] } +# Return the appropriate options to specify that long double uses the IBM +# 128-bit format on PowerPC. + +proc add_options_for_long_double_ibm128 { flags } { + if { [istarget powerpc*-*-*] } { + return "$flags -mlong-double-128 -Wno-psabi -mabi=ibmlongdouble" + } + return "$flags" +} + +# Check if GCC and GLIBC supports explicitly specifying that the long double +# format uses the IBM 128-bit extended double format. Under little endian +# PowerPC Linux, you need GLIBC 2.32 or later to be able to use a different +# long double format for running a program than the system default. + +proc check_effective_target_long_double_ibm128 { } { + return [check_runtime_nocache long_double_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 (sizeof (long double) != 16) + return 1; + b = one + two; + if (memcmp ((void *)&a, (void *)&b, 16) != 0) + return 1; + sprintf (buffer, "%lg", b); + return strcmp (buffer, "3") != 0; + } + } [add_options_for_long_double_ibm128 ""]] +} + +# Return the appropriate options to specify that long double uses the IBM +# 128-bit format on PowerPC. +proc add_options_for_long_double_ieee128 { flags } { + if { [istarget powerpc*-*-*] } { + return "$flags -mlong-double-128 -Wno-psabi -mabi=ieeelongdouble" + } + return "$flags" +} + +# Check if GCC and GLIBC supports explicitly specifying that the long double +# format uses the IEEE 128-bit format. Under little endian PowerPC Linux, you +# need GLIBC 2.32 or later to be able to use a different long double format for +# running a program than the system default. + +proc check_effective_target_long_double_ieee128 { } { + return [check_runtime_nocache long_double_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 (sizeof (long double) != 16) + return 1; + b = one + two; + if (memcmp ((void *)&a, (void *)&b, 16) != 0) + return 1; + sprintf (buffer, "%lg", b); + return strcmp (buffer, "3") != 0; + } + } [add_options_for_long_double_ieee128 ""]] +} + +# Return the appropriate options to specify that long double uses the IEEE +# 64-bit format on PowerPC. + +proc add_options_for_long_double_64bit { flags } { + if { [istarget powerpc*-*-*] } { + return "$flags -mlong-double-64" + } + return "$flags" +} + +# Check if GCC and GLIBC supports explicitly specifying that the long double +# format uses the IEEE 64-bit. Under little endian PowerPC Linux, you need +# GLIBC 2.32 or later to be able to use a different long double format for +# running a program than the system default. + +proc check_effective_target_long_double_64bit { } { + return [check_runtime_nocache long_double_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 (sizeof (long double) != 8) + return 1; + b = one + two; + if (memcmp ((void *)&a, (void *)&b, 16) != 0) + return 1; + sprintf (buffer, "%lg", b); + return strcmp (buffer, "3") != 0; + } + } [add_options_for_ppc_long_double_override_64bit ""]] +} + # Return 1 if the target supports executing VSX instructions, 0 # otherwise. Cache the result.