From patchwork Thu Sep 19 13:12:00 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: mmalcomson@nvidia.com X-Patchwork-Id: 1987399 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=Nvidia.com header.i=@Nvidia.com header.a=rsa-sha256 header.s=selector2 header.b=iztkkKf7; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.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 ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4X8bcT1N2Dz1y1g for ; Thu, 19 Sep 2024 23:15:53 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id EDDAF385B50D for ; Thu, 19 Sep 2024 13:15:50 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from NAM02-DM3-obe.outbound.protection.outlook.com (mail-dm3nam02on2062f.outbound.protection.outlook.com [IPv6:2a01:111:f403:2405::62f]) by sourceware.org (Postfix) with ESMTPS id 887613858C78 for ; Thu, 19 Sep 2024 13:12:49 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 887613858C78 Authentication-Results: sourceware.org; dmarc=fail (p=reject dis=none) header.from=nvidia.com Authentication-Results: sourceware.org; spf=fail smtp.mailfrom=nvidia.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 887613858C78 Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=2a01:111:f403:2405::62f ARC-Seal: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1726751575; cv=pass; b=FdG1CwOm8FB8ql/Cs8gTx0ENilN1feTgyT+Vd4tq4wzGRYQ4tFQKNFHdD4nSAalQj4XUl5RlOt7etUMs2nC5vM6OxaU5Rej0TWyj6A6T6cXK+PpsDS3V9sf+bquRCfoq2eRTs1hKBpIR3rc4fox49kX9SmxTlH+LT8BUsp/okHw= ARC-Message-Signature: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1726751575; c=relaxed/simple; bh=3Z39VJZY1gDCS+i02jvUOh854A/Z/zhJjW2XYZv5GaU=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=dds0KTDcxv+Ea+h8S5D0YRilIQMrZ7NQer2FGhAt4FUZ1rj+qx4iYxTRKdB8oKRiW/Ujeno3+AgnP7Vytjeyh2Jw9QKobwrIIu7iZmvwhOBn1y+MaQPpYStAXc24alwWHQC14muf05LHMnjIR7XYQ5BnCjDIW9ZMD8/fjUIK3go= ARC-Authentication-Results: i=2; server2.sourceware.org ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=uLOWQBGJDqWnlMeFyJQnZjOtnu2+NJbM1bgx81W/zLX9Ll4eTgv7ooUOID13XfjCXZXHNmVN/WH+s8NsS+tjP+255rBW7vCxh8D49mAhMrX1VfLpVzh0airpuvAdnPf5e+9X1IGNsuXfTGFmkml3waepF6HP+E58KxYLdETvVVNu8caTeG4yJ6aYx17yIlQyMgcwl5P0jgcYatQqLPnoHefQPP5U/oefVadM+ltPPHrbWf2EYFUDPDzvq3jIGkU4EqHBLptGId3CHA6danID0zNSnhR1aS7P/vSzsKZseyRatKIqQZXfi4/UkBaQgmJY4h6Ffx0aY97+U1/V2na0nw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=08cAG4TikfLln+nVNOfqNEzez9IBBMMKEogJFcz/f4k=; b=FbEr0d/aD/FP1LnQTdqamJWORXgQb1hYH/iNeX5Cnz3INFViIjb9ne/dlx2gjJ6Vqz4bnTKDwkbUlUA+q2l/Gy87Q2JlL8bYCDZJ5FxLodPdumvI6xpHJf9tbmovkoXC3eDifbGP6gQwJHbI/LVPNaBdLRC9E7ZUHxWz/XFa3b/NLa3wTQm8Wkc3BrRdZMQURzWSIRbb4w0YILNBmrtcNrIJbdhiG+idQruaFvAOnL19H2Kb05nzdbl9bOLs4NAHFnuB8Mvs0tr8ZZdnuilTq9QyuwsEeGftAHVnPz5Se8tsbsaMz2l//gXN0qGt+IUOpGcMaBKUXHQQhaSXnwEhCw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 216.228.117.160) smtp.rcpttodomain=gcc.gnu.org smtp.mailfrom=nvidia.com; dmarc=pass (p=reject sp=reject pct=100) action=none header.from=nvidia.com; dkim=none (message not signed); arc=none (0) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Nvidia.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=08cAG4TikfLln+nVNOfqNEzez9IBBMMKEogJFcz/f4k=; b=iztkkKf7BV4CiJ6TU1BAgjKMHea6kJK6CJLfAV0PntL507HDT4SIoAfV79qiedJ/rukqA+YlpX8TorPS3cbrcOIGlFqX6SzjB+MfbL15DSGsAAnJImh8eSyH2XIXXMEHaWOePbeZWXHqCpmtUHvduh4GbeGqzqyKd0n4UJ/fR5eqawXc7ntPge93VBX+5uJVkCAIUVGq+rRnQR2g9+MlFselHnA8cbL4BsM4LuEpMvyN0nvDrW4z1a09dDqwK1cvgSSoBhojaHYvaPAVDnIpKMbfkGasp1Fpjo42ls6H67CfvSxn81PkvaW29On3rr2mJ3dBBWhhishJAZuEOF2I2w== Received: from BY5PR13CA0019.namprd13.prod.outlook.com (2603:10b6:a03:180::32) by CYYPR12MB8921.namprd12.prod.outlook.com (2603:10b6:930:c7::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7982.17; Thu, 19 Sep 2024 13:12:44 +0000 Received: from CO1PEPF000066EB.namprd05.prod.outlook.com (2603:10b6:a03:180:cafe::fa) by BY5PR13CA0019.outlook.office365.com (2603:10b6:a03:180::32) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7982.11 via Frontend Transport; Thu, 19 Sep 2024 13:12:44 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 216.228.117.160) smtp.mailfrom=nvidia.com; dkim=none (message not signed) header.d=none;dmarc=pass action=none header.from=nvidia.com; Received-SPF: Pass (protection.outlook.com: domain of nvidia.com designates 216.228.117.160 as permitted sender) receiver=protection.outlook.com; client-ip=216.228.117.160; helo=mail.nvidia.com; pr=C Received: from mail.nvidia.com (216.228.117.160) by CO1PEPF000066EB.mail.protection.outlook.com (10.167.249.7) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7918.13 via Frontend Transport; Thu, 19 Sep 2024 13:12:44 +0000 Received: from rnnvmail201.nvidia.com (10.129.68.8) by mail.nvidia.com (10.129.200.66) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1544.4; Thu, 19 Sep 2024 06:12:29 -0700 Received: from f2784bb-lcelt.nvidia.com (10.126.230.35) by rnnvmail201.nvidia.com (10.129.68.8) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1544.4; Thu, 19 Sep 2024 06:12:27 -0700 From: To: CC: Jonathan Wakely , Joseph Myers , Richard Biener , Matthew Malcomson Subject: [PATCH 4/8] [RFC] Have libatomic working as first draft Date: Thu, 19 Sep 2024 14:12:00 +0100 Message-ID: <20240919131204.3865854-5-mmalcomson@nvidia.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240919131204.3865854-1-mmalcomson@nvidia.com> References: <20240919131204.3865854-1-mmalcomson@nvidia.com> MIME-Version: 1.0 X-Originating-IP: [10.126.230.35] X-ClientProxiedBy: rnnvmail202.nvidia.com (10.129.68.7) To rnnvmail201.nvidia.com (10.129.68.8) X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: CO1PEPF000066EB:EE_|CYYPR12MB8921:EE_ X-MS-Office365-Filtering-Correlation-Id: 3e312897-5cab-4dc8-0e17-08dcd8acbfcc X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; ARA:13230040|1800799024|376014|36860700013|82310400026; X-Microsoft-Antispam-Message-Info: tUgliz+pPw1fQuGlc7N2wkjcQMbeqkugZ46GjI0Fcw5wKkbzwM13BbAThnhJ64bB8mnPkI/1AxnTTuOYSw0pSZJsHjF4kUKQt5WE8QQc4V8NcBNJRbd4hKqWDt5VeSgGYo8v9z9BmtE59s5n1Ohn4d2Zn9qiM6Ruaq/gVYR0AS3F2bds2OB1SF2GpBfHl3OlCRHKNDFb/z6xDsDVKuNNF2Odg06iRNBWZURKoYPKBWbTbHRNLuiHFyZSU09/AVp8+FLNv+8z5iqE6pPizZ0BoLYWMUwaKTJ2JH8YMYmlshyeZISS5dlLt2WGwWDOwn/KH7SJ0lckaGHeL14YLmFhw51ahwJH+PdJyxxkW9FY7vd2uNuED5oV7vqdYkSySEHdQ5lCaJuR05uxj7SIgT6b32efZZYFUi60h0ZRJqRGGct4Pd7sBeYuoswGSjj35Y37nGlHxGi+25qWMwgRv2+yNe8qNDc775rjkuEl2NiynAntl+aliRWJ+8KydFsPXiMPcLIoFSE1mulM+Gg/HSSZQfDZHDu8zV9X17vK6BxkHJPllom9sScXrbMX7QtjSRcljExW6a+AaegY7zCqFjf1oMKKlWAW9uPXYdh5LAaKC10VmThGjgJvY88VlYYm4gxCX9VezrgYnidEQdswN3LOCnA5SmTdKlqvKVr8nDJ92u9GSWCuxxhtmYBGtpEv109x4cV6arhut33Fk+gvqQbgLHCujENk1HwNShGVkCugM7j5pYguFsVNwmG6jv0scKE64KQMXus0XVw0yaUFQo4qXn/in6yvlmp4hOF5ssoLuofqOEiIs9qoN0Qm9kJRj5JThBq58t7q82MOYJZGJlrXvDm5VJKIjGtZQFq0vUxZuJp6jdN9XsRWDJsKUTy7TVB/EuqQoOkMuyMjyxzappl9yI2tdthQmk0TjKJUJBDzPb/pm/h2yrw7ECQ7b6CSq2dVjL1J7sarmRr+WXu/QMBk0pnnRIV/dKFrkvooY12fB/1ol4iNs3DJxtN833aVnAvf+SO3xLm7wD8qO0DbJ0bGJufV2R32bhOreJ/fehFSxQXuDamEwk2g2xiD4wazP9RA9OJoQhijZdDmrxDO7Xvpd/TMPbG8DDvnRcyrmNP65s6ZXc7TRb0RO4hs3eJe/n4l0i9PkvHU2HnQQxFDYULMsggB4w8yvS2yhaRDSXV11qpxg8UOBTi0lyHCU5Lhvu5t7+TGPeybaQTSU00kHiV6IcZHCwfo47RjEz83VWhofvAc4gWqb5PxyQ7tWYv/MZVcAuxu5+Uh1HfoieaCzRVQpcTop9WaWC9H1IyaE1qyXL8cHqAGOzCFMNgbFLiBAmAiLx+X7Np0lPo8JD1qBFjbUTayWVzGRc5YN3hl5tK7fufDwwQqeqsj4AWN8zZJOMGbur+q9TE7ugUW4aEjhL0t27hEJqwGC7LSgEHJZpP93vg9dj6viG2rBvM8sYF7t36F X-Forefront-Antispam-Report: CIP:216.228.117.160; CTRY:US; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:mail.nvidia.com; PTR:dc6edge1.nvidia.com; CAT:NONE; SFS:(13230040)(1800799024)(376014)(36860700013)(82310400026); DIR:OUT; SFP:1101; X-OriginatorOrg: Nvidia.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 19 Sep 2024 13:12:44.2782 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 3e312897-5cab-4dc8-0e17-08dcd8acbfcc X-MS-Exchange-CrossTenant-Id: 43083d15-7273-40c1-b7db-39efd9ccc17a X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=43083d15-7273-40c1-b7db-39efd9ccc17a; Ip=[216.228.117.160]; Helo=[mail.nvidia.com] X-MS-Exchange-CrossTenant-AuthSource: CO1PEPF000066EB.namprd05.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: CYYPR12MB8921 X-Spam-Status: No, score=-11.1 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FORGED_SPF_HELO, GIT_PATCH_0, KAM_LINEPADDING, KAM_SHORT, SPF_HELO_PASS, SPF_NONE, 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 X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org From: Matthew Malcomson As it stands there are still a few things to look at whether they could be improved: 1) Need to find the exact version of automake to use. I'm using automake 1.15.1 from https://ftp.gnu.org/gnu/automake/ but the header is claiming I'm using automake 1.15. 2) The internal naming is all a little "not right" up for floating point. E.g. the SIZE() macro is no longer adding a SIZE integer suffix to something but instead adding a suffix representing a type. Not sure whether the churn to fix this is worth it -- will ask upstream. 3) Have not implemented the word-size compare and swap loop fallback. This because the implementation uses a mask and the mask is not always the same for any given architecture. Hence the existing approach in code would not work for all floating point types. - I would appreciate some feedback about whether this is OK to not implement. Seems reasonable to me. 4) In the existing test for the availability of an atomic fetch operation there are two things that I do not know why they are needed and hence didn't add them to the check for atomic floating point fetch_{add,sub}. I just wanted to highlight this in case I missed something. 1) I only put the `x` register into a register with an `asm` call. To be honest I don't know why anything need be put into a register, but I didn't put the floating point value into a register because I didn't know of a standard GCC floating point register constraint that worked across all architectures. - Is there any need for this `asm` line (I copied from existing libatomic configure code without understanding). - Is there any need for the constant addition to be applied? 2) I used a cast of a 1.0 floating point literal as the "addition" for all floating point types in the configury check. - Is there something subtle I'm missing about this? (I *think* it's fine, but felt like this seemed to be a place where I could trip up without knowing). Description of things done in this commit: We implement the new floating point builtins around fetch_add. This is mostly a configure/makefile change. The main overview of the changes is that we create a new list of suffixes (_fpf, _fp, _fpl, _fp16b, _fp16, _fp32, _fp64, _fp128, _fp32x, _fp64x) and re-compile fadd_n.c and fsub_n.c for these suffixes. The existing machinery for checking whether a given atomic builtin is implemented is extended to check for these same suffixes on the atomic builtins. The existing machinery for generating atomic fetch_ implementations using a given suffix and general patterns is also re-used (n.b. with the exception that the implementation based on a compare and exchange of a word is not implemented because the pre-processor does not know the size of the floating point types). The AArch64 backend is updated slightly. It didn't build because it assumed there was some IFUNC for all operations implemented (and didn't have any IFUNC for the new floating point operations). The new functions are advertised as LIBATOMIC_1.3 in the linker map for the dynamic library. Signed-off-by: Matthew Malcomson --- libatomic/Makefile.am | 6 +- libatomic/Makefile.in | 12 +- libatomic/acinclude.m4 | 49 + libatomic/auto-config.h.in | 84 +- libatomic/config/linux/aarch64/host-config.h | 2 + libatomic/configure | 1153 +++++++++++++++++- libatomic/configure.ac | 4 + libatomic/fadd_n.c | 23 + libatomic/fop_n.c | 5 +- libatomic/fsub_n.c | 23 + libatomic/libatomic.map | 44 + libatomic/libatomic_i.h | 58 + libatomic/testsuite/Makefile.in | 1 + 13 files changed, 1392 insertions(+), 72 deletions(-) diff --git a/libatomic/Makefile.am b/libatomic/Makefile.am index efadd9dcd48..ec24f1da86b 100644 --- a/libatomic/Makefile.am +++ b/libatomic/Makefile.am @@ -110,6 +110,7 @@ IFUNC_OPT = $(word $(PAT_S),$(IFUNC_OPTIONS)) M_SIZE = -DN=$(PAT_N) M_IFUNC = $(if $(PAT_S),$(IFUNC_DEF) $(IFUNC_OPT)) M_FILE = $(PAT_BASE)_n.c +M_FLOATING = $(if $(findstring $(PAT_N),$(FPSUFFIXES)),-DFLOATING) # The lack of explicit dependency on the source file means that VPATH cannot # work properly. Instead, perform this operation by hand. First, collect a @@ -120,10 +121,13 @@ all_c_files := $(foreach dir,$(search_path),$(wildcard $(dir)/*.c)) M_SRC = $(firstword $(filter %/$(M_FILE), $(all_c_files))) %_.lo: Makefile - $(LTCOMPILE) $(M_DEPS) $(M_SIZE) $(M_IFUNC) -c -o $@ $(M_SRC) + $(LTCOMPILE) $(M_DEPS) $(M_SIZE) $(M_FLOATING) $(M_IFUNC) -c -o $@ $(M_SRC) ## Include all of the sizes in the "normal" set of compilation flags. libatomic_la_LIBADD = $(foreach s,$(SIZES),$(addsuffix _$(s)_.lo,$(SIZEOBJS))) +# Include the special floating point "sizes" as a set of compilation flags. +FPOBJS = fadd fsub +libatomic_la_LIBADD += $(foreach suf,$(FPSUFFIXES),$(addsuffix _$(suf)_.lo,$(FPOBJS))) ## On a target-specific basis, include alternates to be selected by IFUNC. if HAVE_IFUNC diff --git a/libatomic/Makefile.in b/libatomic/Makefile.in index 9798e7c09e9..c70ebf9cc8b 100644 --- a/libatomic/Makefile.in +++ b/libatomic/Makefile.in @@ -289,6 +289,7 @@ ECHO_T = @ECHO_T@ EGREP = @EGREP@ EXEEXT = @EXEEXT@ FGREP = @FGREP@ +FPSUFFIXES = @FPSUFFIXES@ GREP = @GREP@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ @@ -441,6 +442,7 @@ IFUNC_OPT = $(word $(PAT_S),$(IFUNC_OPTIONS)) M_SIZE = -DN=$(PAT_N) M_IFUNC = $(if $(PAT_S),$(IFUNC_DEF) $(IFUNC_OPT)) M_FILE = $(PAT_BASE)_n.c +M_FLOATING = $(if $(findstring $(PAT_N),$(FPSUFFIXES)),-DFLOATING) # The lack of explicit dependency on the source file means that VPATH cannot # work properly. Instead, perform this operation by hand. First, collect a @@ -450,8 +452,12 @@ all_c_files := $(foreach dir,$(search_path),$(wildcard $(dir)/*.c)) # Then sort through them to find the one we want, and select the first. M_SRC = $(firstword $(filter %/$(M_FILE), $(all_c_files))) libatomic_la_LIBADD = $(foreach s,$(SIZES),$(addsuffix \ - _$(s)_.lo,$(SIZEOBJS))) $(am__append_1) $(am__append_2) \ - $(am__append_3) $(am__append_4) + _$(s)_.lo,$(SIZEOBJS))) $(foreach \ + suf,$(FPSUFFIXES),$(addsuffix _$(suf)_.lo,$(FPOBJS))) \ + $(am__append_1) $(am__append_2) $(am__append_3) \ + $(am__append_4) +# Include the special floating point "sizes" as a set of compilation flags. +FPOBJS = fadd fsub @ARCH_AARCH64_LINUX_TRUE@@HAVE_IFUNC_TRUE@IFUNC_OPTIONS = -march=armv8-a+lse @ARCH_ARM_LINUX_TRUE@@HAVE_IFUNC_TRUE@IFUNC_OPTIONS = -march=armv7-a+fp -DHAVE_KERNEL64 @ARCH_I386_TRUE@@HAVE_IFUNC_TRUE@IFUNC_OPTIONS = -march=i586 @@ -894,7 +900,7 @@ vpath % $(strip $(search_path)) -include $(wildcard $(DEPDIR)/*.Ppo) %_.lo: Makefile - $(LTCOMPILE) $(M_DEPS) $(M_SIZE) $(M_IFUNC) -c -o $@ $(M_SRC) + $(LTCOMPILE) $(M_DEPS) $(M_SIZE) $(M_FLOATING) $(M_IFUNC) -c -o $@ $(M_SRC) # Amend the automake generated all-multi rule to guarantee that all-multi # is not run in parallel with the %_.lo rules which generate $(DEPDIR)/*.Ppo diff --git a/libatomic/acinclude.m4 b/libatomic/acinclude.m4 index f35ab5b60a5..59445f68b85 100644 --- a/libatomic/acinclude.m4 +++ b/libatomic/acinclude.m4 @@ -17,6 +17,23 @@ AC_DEFUN([LIBAT_FORALL_MODES], $1(TI,16)] ) dnl +dnl Iterate over all the floating types that we want to check. +dnl Arguments to the function given are the floting point type and the suffix +dnl used to identify this floating point type. +dnl +AC_DEFUN([LIBAT_FOR_FLOATING_TYPES], + [$1(float,fpf) + $1(double,fp) + $1(long double,fpl) + $1(bfloat16,fpf16b) + $1(_Float16,fpf16) + $1(_Float32,fpf32) + $1(_Float64,fpf64) + $1(_Float128,fpf128) + $1(_Float32x,fpf32x) + $1(_Float64x,fpf64x)] +) +dnl dnl Check for builtin types by mode. dnl dnl A less interesting of size checking than autoconf normally provides. @@ -33,6 +50,20 @@ AC_DEFUN([LIBAT_HAVE_INT_MODE],[ SIZES="$SIZES $2" fi ]) +dnl +dnl Check if built in floating point types are defined for this target. +dnl +AC_DEFUN([LIBAT_HAVE_FLOATING_TYPE],[ + AC_CACHE_CHECK([for type $1],[libat_cv_have_type_$2], + [AC_COMPILE_IFELSE([AC_LANG_SOURCE([$1 x;])], + [libat_cv_have_type_$2=yes],[libat_cv_have_type_$2=no])]) + LIBAT_DEFINE_YESNO([HAVE_$2], [$libat_cv_have_type_$2], + [Have support for floating type $1.]) + if test x$libat_cv_have_type_$2 = xyes; then + FPSUFFIXES="$FPSUFFIXES $2" + fi +]) + dnl dnl Check for atomic builtins. dnl See: @@ -154,6 +185,24 @@ AC_DEFUN([LIBAT_HAVE_ATOMIC_FETCH_ADD],[ AH_BOTTOM([#define MAYBE_HAVE_ATOMIC_FETCH_ADD_$2 HAVE_ATOMIC_FETCH_ADD_$2]) ]) +dnl +dnl Test if we have __atomic_fetch_add for floating point type $1, with suffix $2 +dnl +AC_DEFUN([LIBAT_HAVE_ATOMIC_FETCH_ADDSUB_FP],[ + LIBAT_TEST_ATOMIC_BUILTIN([for __atomic_fetch_{add,sub} for floating type $1], + [libat_cv_have_at_faddsub_$2], [ + $1 *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, ($1)(1.0), 0); + __atomic_add_fetch (x, ($1)(1.0), 0); + __atomic_fetch_sub (x, ($1)(1.0), 0); + __atomic_sub_fetch (x, ($1)(1.0), 0); + ]) +LIBAT_DEFINE_YESNO([HAVE_ATOMIC_FETCH_ADDSUB_$2], [$libat_cv_have_at_faddsub_$2], + [Have __atomic_fetch_{add,sub} for floating point type $1.]) + AH_BOTTOM([#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_$2 HAVE_ATOMIC_FETCH_ADDSUB_$2]) +]) + dnl dnl Test if we have __atomic_fetch_op for all op for mode $1, size $2 dnl diff --git a/libatomic/auto-config.h.in b/libatomic/auto-config.h.in index ab3424a759e..fe56b31f4b6 100644 --- a/libatomic/auto-config.h.in +++ b/libatomic/auto-config.h.in @@ -33,6 +33,36 @@ /* Have __atomic_exchange for 8 byte integers. */ #undef HAVE_ATOMIC_EXCHANGE_8 +/* Have __atomic_fetch_{add,sub} for floating point type double. */ +#undef HAVE_ATOMIC_FETCH_ADDSUB_fp + +/* Have __atomic_fetch_{add,sub} for floating point type float. */ +#undef HAVE_ATOMIC_FETCH_ADDSUB_fpf + +/* Have __atomic_fetch_{add,sub} for floating point type _Float128. */ +#undef HAVE_ATOMIC_FETCH_ADDSUB_fpf128 + +/* Have __atomic_fetch_{add,sub} for floating point type _Float16. */ +#undef HAVE_ATOMIC_FETCH_ADDSUB_fpf16 + +/* Have __atomic_fetch_{add,sub} for floating point type bfloat16. */ +#undef HAVE_ATOMIC_FETCH_ADDSUB_fpf16b + +/* Have __atomic_fetch_{add,sub} for floating point type _Float32. */ +#undef HAVE_ATOMIC_FETCH_ADDSUB_fpf32 + +/* Have __atomic_fetch_{add,sub} for floating point type _Float32x. */ +#undef HAVE_ATOMIC_FETCH_ADDSUB_fpf32x + +/* Have __atomic_fetch_{add,sub} for floating point type _Float64. */ +#undef HAVE_ATOMIC_FETCH_ADDSUB_fpf64 + +/* Have __atomic_fetch_{add,sub} for floating point type _Float64x. */ +#undef HAVE_ATOMIC_FETCH_ADDSUB_fpf64x + +/* Have __atomic_fetch_{add,sub} for floating point type long double. */ +#undef HAVE_ATOMIC_FETCH_ADDSUB_fpl + /* Have __atomic_fetch_add for 1 byte integers. */ #undef HAVE_ATOMIC_FETCH_ADD_1 @@ -153,6 +183,36 @@ /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H +/* Have support for floating type double. */ +#undef HAVE_fp + +/* Have support for floating type float. */ +#undef HAVE_fpf + +/* Have support for floating type _Float128. */ +#undef HAVE_fpf128 + +/* Have support for floating type _Float16. */ +#undef HAVE_fpf16 + +/* Have support for floating type bfloat16. */ +#undef HAVE_fpf16b + +/* Have support for floating type _Float32. */ +#undef HAVE_fpf32 + +/* Have support for floating type _Float32x. */ +#undef HAVE_fpf32x + +/* Have support for floating type _Float64. */ +#undef HAVE_fpf64 + +/* Have support for floating type _Float64x. */ +#undef HAVE_fpf64x + +/* Have support for floating type long double. */ +#undef HAVE_fpl + /* Define ifunc resolver function argument. */ #undef IFUNC_RESOLVER_ARGS @@ -281,12 +341,32 @@ #define MAYBE_HAVE_ATOMIC_FETCH_OP_16 HAVE_ATOMIC_FETCH_OP_16 +#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_fpf HAVE_ATOMIC_FETCH_ADDSUB_fpf + +#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_fp HAVE_ATOMIC_FETCH_ADDSUB_fp + +#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_fpl HAVE_ATOMIC_FETCH_ADDSUB_fpl + +#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_fpf16b HAVE_ATOMIC_FETCH_ADDSUB_fpf16b + +#define FAST_ATOMIC_LDST_2 HAVE_ATOMIC_LDST_2 + +#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_fpf16 HAVE_ATOMIC_FETCH_ADDSUB_fpf16 + +#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_fpf32 HAVE_ATOMIC_FETCH_ADDSUB_fpf32 + +#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_fpf64 HAVE_ATOMIC_FETCH_ADDSUB_fpf64 + +#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_fpf128 HAVE_ATOMIC_FETCH_ADDSUB_fpf128 + +#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_fpf32x HAVE_ATOMIC_FETCH_ADDSUB_fpf32x + +#define MAYBE_HAVE_ATOMIC_FETCH_ADDSUB_fpf64x HAVE_ATOMIC_FETCH_ADDSUB_fpf64x + #ifndef WORDS_BIGENDIAN #define WORDS_BIGENDIAN 0 #endif -#define FAST_ATOMIC_LDST_2 HAVE_ATOMIC_LDST_2 - #define MAYBE_HAVE_ATOMIC_LDST_4 HAVE_ATOMIC_LDST_4 #define FAST_ATOMIC_LDST_4 HAVE_ATOMIC_LDST_4 diff --git a/libatomic/config/linux/aarch64/host-config.h b/libatomic/config/linux/aarch64/host-config.h index 93f367d5878..639ed3efeaa 100644 --- a/libatomic/config/linux/aarch64/host-config.h +++ b/libatomic/config/linux/aarch64/host-config.h @@ -77,6 +77,8 @@ typedef struct __ifunc_arg_t { # define IFUNC_NCOND(N) 0 # define IFUNC_ALT 1 # endif +# elif defined(FLOATING) +# define IFUNC_NCOND(N) 0 # else # define IFUNC_COND_1 (hwcap & HWCAP_ATOMICS) # define IFUNC_NCOND(N) 1 diff --git a/libatomic/configure b/libatomic/configure index d579bab96f8..f68c18295f7 100755 --- a/libatomic/configure +++ b/libatomic/configure @@ -644,6 +644,7 @@ ARCH_AARCH64_LINUX_TRUE HAVE_IFUNC_FALSE HAVE_IFUNC_TRUE tmake_file +FPSUFFIXES SIZES XLDFLAGS XCFLAGS @@ -11456,7 +11457,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 11459 "configure" +#line 11460 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -11562,7 +11563,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 11565 "configure" +#line 11566 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -12665,6 +12666,317 @@ _ACEOF + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for type float" >&5 +$as_echo_n "checking for type float... " >&6; } +if ${libat_cv_have_type_fpf+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +float x; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + libat_cv_have_type_fpf=yes +else + libat_cv_have_type_fpf=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_type_fpf" >&5 +$as_echo "$libat_cv_have_type_fpf" >&6; } + + yesno=`echo $libat_cv_have_type_fpf | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_fpf $yesno +_ACEOF + + + if test x$libat_cv_have_type_fpf = xyes; then + FPSUFFIXES="$FPSUFFIXES fpf" + fi + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for type double" >&5 +$as_echo_n "checking for type double... " >&6; } +if ${libat_cv_have_type_fp+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +double x; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + libat_cv_have_type_fp=yes +else + libat_cv_have_type_fp=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_type_fp" >&5 +$as_echo "$libat_cv_have_type_fp" >&6; } + + yesno=`echo $libat_cv_have_type_fp | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_fp $yesno +_ACEOF + + + if test x$libat_cv_have_type_fp = xyes; then + FPSUFFIXES="$FPSUFFIXES fp" + fi + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for type long double" >&5 +$as_echo_n "checking for type long double... " >&6; } +if ${libat_cv_have_type_fpl+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +long double x; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + libat_cv_have_type_fpl=yes +else + libat_cv_have_type_fpl=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_type_fpl" >&5 +$as_echo "$libat_cv_have_type_fpl" >&6; } + + yesno=`echo $libat_cv_have_type_fpl | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_fpl $yesno +_ACEOF + + + if test x$libat_cv_have_type_fpl = xyes; then + FPSUFFIXES="$FPSUFFIXES fpl" + fi + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for type bfloat16" >&5 +$as_echo_n "checking for type bfloat16... " >&6; } +if ${libat_cv_have_type_fpf16b+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +bfloat16 x; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + libat_cv_have_type_fpf16b=yes +else + libat_cv_have_type_fpf16b=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_type_fpf16b" >&5 +$as_echo "$libat_cv_have_type_fpf16b" >&6; } + + yesno=`echo $libat_cv_have_type_fpf16b | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_fpf16b $yesno +_ACEOF + + + if test x$libat_cv_have_type_fpf16b = xyes; then + FPSUFFIXES="$FPSUFFIXES fpf16b" + fi + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for type _Float16" >&5 +$as_echo_n "checking for type _Float16... " >&6; } +if ${libat_cv_have_type_fpf16+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +_Float16 x; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + libat_cv_have_type_fpf16=yes +else + libat_cv_have_type_fpf16=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_type_fpf16" >&5 +$as_echo "$libat_cv_have_type_fpf16" >&6; } + + yesno=`echo $libat_cv_have_type_fpf16 | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_fpf16 $yesno +_ACEOF + + + if test x$libat_cv_have_type_fpf16 = xyes; then + FPSUFFIXES="$FPSUFFIXES fpf16" + fi + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for type _Float32" >&5 +$as_echo_n "checking for type _Float32... " >&6; } +if ${libat_cv_have_type_fpf32+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +_Float32 x; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + libat_cv_have_type_fpf32=yes +else + libat_cv_have_type_fpf32=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_type_fpf32" >&5 +$as_echo "$libat_cv_have_type_fpf32" >&6; } + + yesno=`echo $libat_cv_have_type_fpf32 | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_fpf32 $yesno +_ACEOF + + + if test x$libat_cv_have_type_fpf32 = xyes; then + FPSUFFIXES="$FPSUFFIXES fpf32" + fi + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for type _Float64" >&5 +$as_echo_n "checking for type _Float64... " >&6; } +if ${libat_cv_have_type_fpf64+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +_Float64 x; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + libat_cv_have_type_fpf64=yes +else + libat_cv_have_type_fpf64=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_type_fpf64" >&5 +$as_echo "$libat_cv_have_type_fpf64" >&6; } + + yesno=`echo $libat_cv_have_type_fpf64 | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_fpf64 $yesno +_ACEOF + + + if test x$libat_cv_have_type_fpf64 = xyes; then + FPSUFFIXES="$FPSUFFIXES fpf64" + fi + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for type _Float128" >&5 +$as_echo_n "checking for type _Float128... " >&6; } +if ${libat_cv_have_type_fpf128+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +_Float128 x; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + libat_cv_have_type_fpf128=yes +else + libat_cv_have_type_fpf128=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_type_fpf128" >&5 +$as_echo "$libat_cv_have_type_fpf128" >&6; } + + yesno=`echo $libat_cv_have_type_fpf128 | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_fpf128 $yesno +_ACEOF + + + if test x$libat_cv_have_type_fpf128 = xyes; then + FPSUFFIXES="$FPSUFFIXES fpf128" + fi + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for type _Float32x" >&5 +$as_echo_n "checking for type _Float32x... " >&6; } +if ${libat_cv_have_type_fpf32x+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +_Float32x x; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + libat_cv_have_type_fpf32x=yes +else + libat_cv_have_type_fpf32x=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_type_fpf32x" >&5 +$as_echo "$libat_cv_have_type_fpf32x" >&6; } + + yesno=`echo $libat_cv_have_type_fpf32x | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_fpf32x $yesno +_ACEOF + + + if test x$libat_cv_have_type_fpf32x = xyes; then + FPSUFFIXES="$FPSUFFIXES fpf32x" + fi + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for type _Float64x" >&5 +$as_echo_n "checking for type _Float64x... " >&6; } +if ${libat_cv_have_type_fpf64x+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +_Float64x x; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + libat_cv_have_type_fpf64x=yes +else + libat_cv_have_type_fpf64x=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_type_fpf64x" >&5 +$as_echo "$libat_cv_have_type_fpf64x" >&6; } + + yesno=`echo $libat_cv_have_type_fpf64x | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_fpf64x $yesno +_ACEOF + + + if test x$libat_cv_have_type_fpf64x = xyes; then + FPSUFFIXES="$FPSUFFIXES fpf64x" + fi + + + # Check for compiler builtins of atomic operations. # Do link tests if possible, instead asm tests, limited to some platforms @@ -14697,81 +15009,793 @@ _ACEOF - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5 -$as_echo_n "checking whether byte ordering is bigendian... " >&6; } -if ${ac_cv_c_bigendian+:} false; then : + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __atomic_fetch_{add,sub} for floating type float" >&5 +$as_echo_n "checking for __atomic_fetch_{add,sub} for floating type float... " >&6; } +if ${libat_cv_have_at_faddsub_fpf+:} false; then : $as_echo_n "(cached) " >&6 else - ac_cv_c_bigendian=unknown - # See if we're dealing with a universal compiler. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#ifndef __APPLE_CC__ - not a universal capable compiler - #endif - typedef int dummy; - -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - # Check for potential -arch flags. It is not universal unless - # there are at least two -arch flags with different values. - ac_arch= - ac_prev= - for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do - if test -n "$ac_prev"; then - case $ac_word in - i?86 | x86_64 | ppc | ppc64) - if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then - ac_arch=$ac_word - else - ac_cv_c_bigendian=universal - break - fi - ;; - esac - ac_prev= - elif test "x$ac_word" = "x-arch"; then - ac_prev=arch - fi - done -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - if test $ac_cv_c_bigendian = unknown; then - # See if sys/param.h defines the BYTE_ORDER macro. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext + cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#include - #include int main () { -#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \ - && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \ - && LITTLE_ENDIAN) - bogus endian macros - #endif + + float *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, (float)(1.0), 0); + __atomic_add_fetch (x, (float)(1.0), 0); + __atomic_fetch_sub (x, (float)(1.0), 0); + __atomic_sub_fetch (x, (float)(1.0), 0); ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - # It does; now see whether it defined to BIG_ENDIAN or not. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - #include - -int -main () -{ -#if BYTE_ORDER != BIG_ENDIAN - not big endian - #endif - - ; + if test x$atomic_builtins_link_tests = xyes; then + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + eval libat_cv_have_at_faddsub_fpf=yes + else + eval libat_cv_have_at_faddsub_fpf=no + fi + else + old_CFLAGS="$CFLAGS" + # Compile unoptimized. + CFLAGS="$CFLAGS -O0 -S" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if grep __atomic_ conftest.s >/dev/null 2>&1 ; then + eval libat_cv_have_at_faddsub_fpf=no + else + eval libat_cv_have_at_faddsub_fpf=yes + fi + else + eval libat_cv_have_at_faddsub_fpf=no + fi + CFLAGS="$old_CFLAGS" + fi + rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_at_faddsub_fpf" >&5 +$as_echo "$libat_cv_have_at_faddsub_fpf" >&6; } + + + yesno=`echo $libat_cv_have_at_faddsub_fpf | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_ATOMIC_FETCH_ADDSUB_fpf $yesno +_ACEOF + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __atomic_fetch_{add,sub} for floating type double" >&5 +$as_echo_n "checking for __atomic_fetch_{add,sub} for floating type double... " >&6; } +if ${libat_cv_have_at_faddsub_fp+:} false; then : + $as_echo_n "(cached) " >&6 +else + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + double *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, (double)(1.0), 0); + __atomic_add_fetch (x, (double)(1.0), 0); + __atomic_fetch_sub (x, (double)(1.0), 0); + __atomic_sub_fetch (x, (double)(1.0), 0); + + ; + return 0; +} +_ACEOF + if test x$atomic_builtins_link_tests = xyes; then + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + eval libat_cv_have_at_faddsub_fp=yes + else + eval libat_cv_have_at_faddsub_fp=no + fi + else + old_CFLAGS="$CFLAGS" + # Compile unoptimized. + CFLAGS="$CFLAGS -O0 -S" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if grep __atomic_ conftest.s >/dev/null 2>&1 ; then + eval libat_cv_have_at_faddsub_fp=no + else + eval libat_cv_have_at_faddsub_fp=yes + fi + else + eval libat_cv_have_at_faddsub_fp=no + fi + CFLAGS="$old_CFLAGS" + fi + rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_at_faddsub_fp" >&5 +$as_echo "$libat_cv_have_at_faddsub_fp" >&6; } + + + yesno=`echo $libat_cv_have_at_faddsub_fp | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_ATOMIC_FETCH_ADDSUB_fp $yesno +_ACEOF + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __atomic_fetch_{add,sub} for floating type long double" >&5 +$as_echo_n "checking for __atomic_fetch_{add,sub} for floating type long double... " >&6; } +if ${libat_cv_have_at_faddsub_fpl+:} false; then : + $as_echo_n "(cached) " >&6 +else + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + long double *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, (long double)(1.0), 0); + __atomic_add_fetch (x, (long double)(1.0), 0); + __atomic_fetch_sub (x, (long double)(1.0), 0); + __atomic_sub_fetch (x, (long double)(1.0), 0); + + ; + return 0; +} +_ACEOF + if test x$atomic_builtins_link_tests = xyes; then + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + eval libat_cv_have_at_faddsub_fpl=yes + else + eval libat_cv_have_at_faddsub_fpl=no + fi + else + old_CFLAGS="$CFLAGS" + # Compile unoptimized. + CFLAGS="$CFLAGS -O0 -S" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if grep __atomic_ conftest.s >/dev/null 2>&1 ; then + eval libat_cv_have_at_faddsub_fpl=no + else + eval libat_cv_have_at_faddsub_fpl=yes + fi + else + eval libat_cv_have_at_faddsub_fpl=no + fi + CFLAGS="$old_CFLAGS" + fi + rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_at_faddsub_fpl" >&5 +$as_echo "$libat_cv_have_at_faddsub_fpl" >&6; } + + + yesno=`echo $libat_cv_have_at_faddsub_fpl | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_ATOMIC_FETCH_ADDSUB_fpl $yesno +_ACEOF + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __atomic_fetch_{add,sub} for floating type bfloat16" >&5 +$as_echo_n "checking for __atomic_fetch_{add,sub} for floating type bfloat16... " >&6; } +if ${libat_cv_have_at_faddsub_fpf16b+:} false; then : + $as_echo_n "(cached) " >&6 +else + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + bfloat16 *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, (bfloat16)(1.0), 0); + __atomic_add_fetch (x, (bfloat16)(1.0), 0); + __atomic_fetch_sub (x, (bfloat16)(1.0), 0); + __atomic_sub_fetch (x, (bfloat16)(1.0), 0); + + ; + return 0; +} +_ACEOF + if test x$atomic_builtins_link_tests = xyes; then + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + eval libat_cv_have_at_faddsub_fpf16b=yes + else + eval libat_cv_have_at_faddsub_fpf16b=no + fi + else + old_CFLAGS="$CFLAGS" + # Compile unoptimized. + CFLAGS="$CFLAGS -O0 -S" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if grep __atomic_ conftest.s >/dev/null 2>&1 ; then + eval libat_cv_have_at_faddsub_fpf16b=no + else + eval libat_cv_have_at_faddsub_fpf16b=yes + fi + else + eval libat_cv_have_at_faddsub_fpf16b=no + fi + CFLAGS="$old_CFLAGS" + fi + rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_at_faddsub_fpf16b" >&5 +$as_echo "$libat_cv_have_at_faddsub_fpf16b" >&6; } + + + yesno=`echo $libat_cv_have_at_faddsub_fpf16b | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_ATOMIC_FETCH_ADDSUB_fpf16b $yesno +_ACEOF + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __atomic_fetch_{add,sub} for floating type _Float16" >&5 +$as_echo_n "checking for __atomic_fetch_{add,sub} for floating type _Float16... " >&6; } +if ${libat_cv_have_at_faddsub_fpf16+:} false; then : + $as_echo_n "(cached) " >&6 +else + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + _Float16 *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, (_Float16)(1.0), 0); + __atomic_add_fetch (x, (_Float16)(1.0), 0); + __atomic_fetch_sub (x, (_Float16)(1.0), 0); + __atomic_sub_fetch (x, (_Float16)(1.0), 0); + + ; + return 0; +} +_ACEOF + if test x$atomic_builtins_link_tests = xyes; then + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + eval libat_cv_have_at_faddsub_fpf16=yes + else + eval libat_cv_have_at_faddsub_fpf16=no + fi + else + old_CFLAGS="$CFLAGS" + # Compile unoptimized. + CFLAGS="$CFLAGS -O0 -S" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if grep __atomic_ conftest.s >/dev/null 2>&1 ; then + eval libat_cv_have_at_faddsub_fpf16=no + else + eval libat_cv_have_at_faddsub_fpf16=yes + fi + else + eval libat_cv_have_at_faddsub_fpf16=no + fi + CFLAGS="$old_CFLAGS" + fi + rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_at_faddsub_fpf16" >&5 +$as_echo "$libat_cv_have_at_faddsub_fpf16" >&6; } + + + yesno=`echo $libat_cv_have_at_faddsub_fpf16 | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_ATOMIC_FETCH_ADDSUB_fpf16 $yesno +_ACEOF + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __atomic_fetch_{add,sub} for floating type _Float32" >&5 +$as_echo_n "checking for __atomic_fetch_{add,sub} for floating type _Float32... " >&6; } +if ${libat_cv_have_at_faddsub_fpf32+:} false; then : + $as_echo_n "(cached) " >&6 +else + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + _Float32 *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, (_Float32)(1.0), 0); + __atomic_add_fetch (x, (_Float32)(1.0), 0); + __atomic_fetch_sub (x, (_Float32)(1.0), 0); + __atomic_sub_fetch (x, (_Float32)(1.0), 0); + + ; + return 0; +} +_ACEOF + if test x$atomic_builtins_link_tests = xyes; then + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + eval libat_cv_have_at_faddsub_fpf32=yes + else + eval libat_cv_have_at_faddsub_fpf32=no + fi + else + old_CFLAGS="$CFLAGS" + # Compile unoptimized. + CFLAGS="$CFLAGS -O0 -S" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if grep __atomic_ conftest.s >/dev/null 2>&1 ; then + eval libat_cv_have_at_faddsub_fpf32=no + else + eval libat_cv_have_at_faddsub_fpf32=yes + fi + else + eval libat_cv_have_at_faddsub_fpf32=no + fi + CFLAGS="$old_CFLAGS" + fi + rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_at_faddsub_fpf32" >&5 +$as_echo "$libat_cv_have_at_faddsub_fpf32" >&6; } + + + yesno=`echo $libat_cv_have_at_faddsub_fpf32 | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_ATOMIC_FETCH_ADDSUB_fpf32 $yesno +_ACEOF + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __atomic_fetch_{add,sub} for floating type _Float64" >&5 +$as_echo_n "checking for __atomic_fetch_{add,sub} for floating type _Float64... " >&6; } +if ${libat_cv_have_at_faddsub_fpf64+:} false; then : + $as_echo_n "(cached) " >&6 +else + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + _Float64 *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, (_Float64)(1.0), 0); + __atomic_add_fetch (x, (_Float64)(1.0), 0); + __atomic_fetch_sub (x, (_Float64)(1.0), 0); + __atomic_sub_fetch (x, (_Float64)(1.0), 0); + + ; + return 0; +} +_ACEOF + if test x$atomic_builtins_link_tests = xyes; then + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + eval libat_cv_have_at_faddsub_fpf64=yes + else + eval libat_cv_have_at_faddsub_fpf64=no + fi + else + old_CFLAGS="$CFLAGS" + # Compile unoptimized. + CFLAGS="$CFLAGS -O0 -S" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if grep __atomic_ conftest.s >/dev/null 2>&1 ; then + eval libat_cv_have_at_faddsub_fpf64=no + else + eval libat_cv_have_at_faddsub_fpf64=yes + fi + else + eval libat_cv_have_at_faddsub_fpf64=no + fi + CFLAGS="$old_CFLAGS" + fi + rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_at_faddsub_fpf64" >&5 +$as_echo "$libat_cv_have_at_faddsub_fpf64" >&6; } + + + yesno=`echo $libat_cv_have_at_faddsub_fpf64 | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_ATOMIC_FETCH_ADDSUB_fpf64 $yesno +_ACEOF + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __atomic_fetch_{add,sub} for floating type _Float128" >&5 +$as_echo_n "checking for __atomic_fetch_{add,sub} for floating type _Float128... " >&6; } +if ${libat_cv_have_at_faddsub_fpf128+:} false; then : + $as_echo_n "(cached) " >&6 +else + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + _Float128 *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, (_Float128)(1.0), 0); + __atomic_add_fetch (x, (_Float128)(1.0), 0); + __atomic_fetch_sub (x, (_Float128)(1.0), 0); + __atomic_sub_fetch (x, (_Float128)(1.0), 0); + + ; + return 0; +} +_ACEOF + if test x$atomic_builtins_link_tests = xyes; then + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + eval libat_cv_have_at_faddsub_fpf128=yes + else + eval libat_cv_have_at_faddsub_fpf128=no + fi + else + old_CFLAGS="$CFLAGS" + # Compile unoptimized. + CFLAGS="$CFLAGS -O0 -S" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if grep __atomic_ conftest.s >/dev/null 2>&1 ; then + eval libat_cv_have_at_faddsub_fpf128=no + else + eval libat_cv_have_at_faddsub_fpf128=yes + fi + else + eval libat_cv_have_at_faddsub_fpf128=no + fi + CFLAGS="$old_CFLAGS" + fi + rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_at_faddsub_fpf128" >&5 +$as_echo "$libat_cv_have_at_faddsub_fpf128" >&6; } + + + yesno=`echo $libat_cv_have_at_faddsub_fpf128 | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_ATOMIC_FETCH_ADDSUB_fpf128 $yesno +_ACEOF + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __atomic_fetch_{add,sub} for floating type _Float32x" >&5 +$as_echo_n "checking for __atomic_fetch_{add,sub} for floating type _Float32x... " >&6; } +if ${libat_cv_have_at_faddsub_fpf32x+:} false; then : + $as_echo_n "(cached) " >&6 +else + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + _Float32x *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, (_Float32x)(1.0), 0); + __atomic_add_fetch (x, (_Float32x)(1.0), 0); + __atomic_fetch_sub (x, (_Float32x)(1.0), 0); + __atomic_sub_fetch (x, (_Float32x)(1.0), 0); + + ; + return 0; +} +_ACEOF + if test x$atomic_builtins_link_tests = xyes; then + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + eval libat_cv_have_at_faddsub_fpf32x=yes + else + eval libat_cv_have_at_faddsub_fpf32x=no + fi + else + old_CFLAGS="$CFLAGS" + # Compile unoptimized. + CFLAGS="$CFLAGS -O0 -S" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if grep __atomic_ conftest.s >/dev/null 2>&1 ; then + eval libat_cv_have_at_faddsub_fpf32x=no + else + eval libat_cv_have_at_faddsub_fpf32x=yes + fi + else + eval libat_cv_have_at_faddsub_fpf32x=no + fi + CFLAGS="$old_CFLAGS" + fi + rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_at_faddsub_fpf32x" >&5 +$as_echo "$libat_cv_have_at_faddsub_fpf32x" >&6; } + + + yesno=`echo $libat_cv_have_at_faddsub_fpf32x | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_ATOMIC_FETCH_ADDSUB_fpf32x $yesno +_ACEOF + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __atomic_fetch_{add,sub} for floating type _Float64x" >&5 +$as_echo_n "checking for __atomic_fetch_{add,sub} for floating type _Float64x... " >&6; } +if ${libat_cv_have_at_faddsub_fpf64x+:} false; then : + $as_echo_n "(cached) " >&6 +else + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + _Float64x *x; + asm("" : "=g"(x)); + __atomic_fetch_add (x, (_Float64x)(1.0), 0); + __atomic_add_fetch (x, (_Float64x)(1.0), 0); + __atomic_fetch_sub (x, (_Float64x)(1.0), 0); + __atomic_sub_fetch (x, (_Float64x)(1.0), 0); + + ; + return 0; +} +_ACEOF + if test x$atomic_builtins_link_tests = xyes; then + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + eval libat_cv_have_at_faddsub_fpf64x=yes + else + eval libat_cv_have_at_faddsub_fpf64x=no + fi + else + old_CFLAGS="$CFLAGS" + # Compile unoptimized. + CFLAGS="$CFLAGS -O0 -S" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if grep __atomic_ conftest.s >/dev/null 2>&1 ; then + eval libat_cv_have_at_faddsub_fpf64x=no + else + eval libat_cv_have_at_faddsub_fpf64x=yes + fi + else + eval libat_cv_have_at_faddsub_fpf64x=no + fi + CFLAGS="$old_CFLAGS" + fi + rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libat_cv_have_at_faddsub_fpf64x" >&5 +$as_echo "$libat_cv_have_at_faddsub_fpf64x" >&6; } + + + yesno=`echo $libat_cv_have_at_faddsub_fpf64x | tr 'yesno' '1 0 '` + +cat >>confdefs.h <<_ACEOF +#define HAVE_ATOMIC_FETCH_ADDSUB_fpf64x $yesno +_ACEOF + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5 +$as_echo_n "checking whether byte ordering is bigendian... " >&6; } +if ${ac_cv_c_bigendian+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_c_bigendian=unknown + # See if we're dealing with a universal compiler. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifndef __APPLE_CC__ + not a universal capable compiler + #endif + typedef int dummy; + +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + + # Check for potential -arch flags. It is not universal unless + # there are at least two -arch flags with different values. + ac_arch= + ac_prev= + for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do + if test -n "$ac_prev"; then + case $ac_word in + i?86 | x86_64 | ppc | ppc64) + if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then + ac_arch=$ac_word + else + ac_cv_c_bigendian=universal + break + fi + ;; + esac + ac_prev= + elif test "x$ac_word" = "x-arch"; then + ac_prev=arch + fi + done +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + if test $ac_cv_c_bigendian = unknown; then + # See if sys/param.h defines the BYTE_ORDER macro. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + #include + +int +main () +{ +#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \ + && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \ + && LITTLE_ENDIAN) + bogus endian macros + #endif + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + # It does; now see whether it defined to BIG_ENDIAN or not. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + #include + +int +main () +{ +#if BYTE_ORDER != BIG_ENDIAN + not big endian + #endif + + ; return 0; } _ACEOF @@ -15761,6 +16785,7 @@ XCFLAGS="$XCFLAGS $XPCFLAGS" + # Conditionalize the makefile for this target machine. tmake_file_= for f in ${tmake_file} diff --git a/libatomic/configure.ac b/libatomic/configure.ac index 32a2cdb13ae..597f88b073e 100644 --- a/libatomic/configure.ac +++ b/libatomic/configure.ac @@ -196,6 +196,7 @@ AC_CHECK_HEADERS([fenv.h]) # Check for common type sizes LIBAT_FORALL_MODES([LIBAT_HAVE_INT_MODE]) +LIBAT_FOR_FLOATING_TYPES([LIBAT_HAVE_FLOATING_TYPE]) # Check for compiler builtins of atomic operations. LIBAT_TEST_ATOMIC_INIT @@ -205,6 +206,8 @@ LIBAT_FORALL_MODES([LIBAT_HAVE_ATOMIC_EXCHANGE]) LIBAT_FORALL_MODES([LIBAT_HAVE_ATOMIC_CAS]) LIBAT_FORALL_MODES([LIBAT_HAVE_ATOMIC_FETCH_ADD]) LIBAT_FORALL_MODES([LIBAT_HAVE_ATOMIC_FETCH_OP]) +LIBAT_FOR_FLOATING_TYPES([LIBAT_HAVE_ATOMIC_FETCH_ADDSUB_FP]) + AC_C_BIGENDIAN # I don't like the default behaviour of WORDS_BIGENDIAN undefined for LE. @@ -273,6 +276,7 @@ AC_SUBST(XCFLAGS) AC_SUBST(XLDFLAGS) AC_SUBST(LIBS) AC_SUBST(SIZES) +AC_SUBST(FPSUFFIXES) # Conditionalize the makefile for this target machine. tmake_file_= diff --git a/libatomic/fadd_n.c b/libatomic/fadd_n.c index 32b75cec654..bae6b95d728 100644 --- a/libatomic/fadd_n.c +++ b/libatomic/fadd_n.c @@ -28,6 +28,28 @@ #define NAME add #define OP(X,Y) ((X) + (Y)) +/* + When compiling this file for the floating point operations, some of the names + become a bit of a misnomer. + - SIZE now logically creates a token suffixed by a "floating point suffix" + rather than suffixed by "size". + - UTYPE is now something like U_fp for double and they are typedef'd to the + corresponding floating point type. + - N is no longer a number, but instead a floating point suffix. +*/ +#if FLOATING +# define HAVE_ATOMIC_FETCH_OP_fpf HAVE_ATOMIC_FETCH_ADDSUB_fpf +# define HAVE_ATOMIC_FETCH_OP_fpf HAVE_ATOMIC_FETCH_ADDSUB_fpf +# define HAVE_ATOMIC_FETCH_OP_fp HAVE_ATOMIC_FETCH_ADDSUB_fp +# define HAVE_ATOMIC_FETCH_OP_fpl HAVE_ATOMIC_FETCH_ADDSUB_fpl +# define HAVE_ATOMIC_FETCH_OP_fpf16 HAVE_ATOMIC_FETCH_ADDSUB_fpf16 +# define HAVE_ATOMIC_FETCH_OP_fpf32 HAVE_ATOMIC_FETCH_ADDSUB_fpf32 +# define HAVE_ATOMIC_FETCH_OP_fpf64 HAVE_ATOMIC_FETCH_ADDSUB_fpf64 +# define HAVE_ATOMIC_FETCH_OP_fpf128 HAVE_ATOMIC_FETCH_ADDSUB_fpf128 +# define HAVE_ATOMIC_FETCH_OP_fpf32x HAVE_ATOMIC_FETCH_ADDSUB_fpf32x +# define HAVE_ATOMIC_FETCH_OP_fpf64x HAVE_ATOMIC_FETCH_ADDSUB_fpf64x +#endif + /* Defer to HAVE_ATOMIC_FETCH_ADD, which some targets implement specially, even if HAVE_ATOMIC_FETCH_OP is not defined. */ #if !SIZE(HAVE_ATOMIC_FETCH_OP) @@ -44,4 +66,5 @@ #endif #include "fop_n.c" + #undef LAT_FADD_N diff --git a/libatomic/fop_n.c b/libatomic/fop_n.c index fefff3a57a4..5cba1dcb3c9 100644 --- a/libatomic/fop_n.c +++ b/libatomic/fop_n.c @@ -104,8 +104,9 @@ SIZE(C3(libat_,NAME,_fetch)) (UTYPE *mptr, UTYPE opval, int smodel) /* If this type is no larger than word-sized, fall back to a word-sized - compare-and-swap loop. */ -#if !DONE && N < WORDSIZE && defined(atomic_compare_exchange_w) + compare-and-swap loop. Avoid doing this with floating point types since the + preprocessor does not know the size of those types. */ +#if !DONE && !defined(FLOATING) && N < WORDSIZE && defined(atomic_compare_exchange_w) UTYPE SIZE(C2(libat_fetch_,NAME)) (UTYPE *mptr, UTYPE opval, int smodel) { diff --git a/libatomic/fsub_n.c b/libatomic/fsub_n.c index 49b375a543f..bc99f22797e 100644 --- a/libatomic/fsub_n.c +++ b/libatomic/fsub_n.c @@ -1,5 +1,28 @@ #define LAT_FSUB_N #define NAME sub #define OP(X,Y) ((X) - (Y)) + +/* + When compiling this file for the floating point operations, some of the names + become a bit of a misnomer. + - SIZE now logically creates a token suffixed by a "floating point suffix" + rather than suffixed by "size". + - UTYPE is now something like U_fp for double and they are typedef'd to the + corresponding floating point type. + - N is no longer a number, but instead a floating point suffix. +*/ +#if FLOATING +# define HAVE_ATOMIC_FETCH_OP_fpf HAVE_ATOMIC_FETCH_ADDSUB_fpf +# define HAVE_ATOMIC_FETCH_OP_fpf HAVE_ATOMIC_FETCH_ADDSUB_fpf +# define HAVE_ATOMIC_FETCH_OP_fp HAVE_ATOMIC_FETCH_ADDSUB_fp +# define HAVE_ATOMIC_FETCH_OP_fpl HAVE_ATOMIC_FETCH_ADDSUB_fpl +# define HAVE_ATOMIC_FETCH_OP_fpf16 HAVE_ATOMIC_FETCH_ADDSUB_fpf16 +# define HAVE_ATOMIC_FETCH_OP_fpf32 HAVE_ATOMIC_FETCH_ADDSUB_fpf32 +# define HAVE_ATOMIC_FETCH_OP_fpf64 HAVE_ATOMIC_FETCH_ADDSUB_fpf64 +# define HAVE_ATOMIC_FETCH_OP_fpf128 HAVE_ATOMIC_FETCH_ADDSUB_fpf128 +# define HAVE_ATOMIC_FETCH_OP_fpf32x HAVE_ATOMIC_FETCH_ADDSUB_fpf32x +# define HAVE_ATOMIC_FETCH_OP_fpf64x HAVE_ATOMIC_FETCH_ADDSUB_fpf64x +#endif + #include "fop_n.c" #undef LAT_FSUB_N diff --git a/libatomic/libatomic.map b/libatomic/libatomic.map index 39e7c2c6b9a..b08fb8d6bc8 100644 --- a/libatomic/libatomic.map +++ b/libatomic/libatomic.map @@ -108,3 +108,47 @@ LIBATOMIC_1.2 { atomic_flag_clear; atomic_flag_clear_explicit; } LIBATOMIC_1.1; + +LIBATOMIC_1.3 { + global: + __atomic_add_fetch_fpf; + __atomic_add_fetch_fp; + __atomic_add_fetch_fpl; + __atomic_add_fetch_fpf16b; + __atomic_add_fetch_fpf16; + __atomic_add_fetch_fpf32; + __atomic_add_fetch_fpf64; + __atomic_add_fetch_fpf128; + __atomic_add_fetch_fpf32x; + __atomic_add_fetch_fpf64x; + __atomic_fetch_add_fpf; + __atomic_fetch_add_fp; + __atomic_fetch_add_fpl; + __atomic_fetch_add_fpf16b; + __atomic_fetch_add_fpf16; + __atomic_fetch_add_fpf32; + __atomic_fetch_add_fpf64; + __atomic_fetch_add_fpf128; + __atomic_fetch_add_fpf32x; + __atomic_fetch_add_fpf64x; + __atomic_fetch_sub_fpf; + __atomic_fetch_sub_fp; + __atomic_fetch_sub_fpl; + __atomic_fetch_sub_fpf16b; + __atomic_fetch_sub_fpf16; + __atomic_fetch_sub_fpf32; + __atomic_fetch_sub_fpf64; + __atomic_fetch_sub_fpf128; + __atomic_fetch_sub_fpf32x; + __atomic_fetch_sub_fpf64x; + __atomic_sub_fetch_fpf; + __atomic_sub_fetch_fp; + __atomic_sub_fetch_fpl; + __atomic_sub_fetch_fpf16b; + __atomic_sub_fetch_fpf16; + __atomic_sub_fetch_fpf32; + __atomic_sub_fetch_fpf64; + __atomic_sub_fetch_fpf128; + __atomic_sub_fetch_fpf32x; + __atomic_sub_fetch_fpf64x; +} LIBATOMIC_1.2; diff --git a/libatomic/libatomic_i.h b/libatomic/libatomic_i.h index 861a22da152..8dc13fd459d 100644 --- a/libatomic/libatomic_i.h +++ b/libatomic/libatomic_i.h @@ -63,6 +63,31 @@ typedef unsigned U_8 __attribute__((mode(DI))); typedef unsigned U_16 __attribute__((mode(TI))); #endif +typedef float U_fpf; +typedef double U_fp; +typedef long double U_fpl; +#if HAVE_fpf16b +typedef bfloat16 U_fpf16b; +#endif +#if HAVE_fpf16 +typedef _Float16 U_fpf16; +#endif +#if HAVE_fpf32 +typedef _Float32 U_fpf32; +#endif +#if HAVE_fpf64 +typedef _Float64 U_fpf64; +#endif +#if HAVE_fpf128 +typedef _Float128 U_fpf128; +#endif +#if HAVE_fpf32x +typedef _Float32x U_fpf32x; +#endif +#if HAVE_fpf64x +typedef _Float64x U_fpf64x; +#endif + /* The widest type that we support. */ #if HAVE_INT16 # define MAX_SIZE 16 @@ -92,6 +117,28 @@ typedef U_MAX U_8; #if !HAVE_INT16 typedef U_MAX U_16; #endif +#if !HAVE_fpf16b +typedef U_MAX U_fpf16b; +#endif +#if !HAVE_fpf16 +typedef U_MAX U_fpf16; +#endif +#if !HAVE_fpf32 +typedef U_MAX U_fpf32; +#endif +#if !HAVE_fpf64 +typedef U_MAX U_fpf64; +#endif +#if !HAVE_fpf128 +typedef U_MAX U_fpf128; +#endif +#if !HAVE_fpf32x +typedef U_MAX U_fpf32x; +#endif +#if !HAVE_fpf64x +typedef U_MAX U_fpf64x; +#endif + union max_size_u { @@ -215,6 +262,17 @@ DECLARE_ALL_SIZED(4); DECLARE_ALL_SIZED(8); DECLARE_ALL_SIZED(16); +DECLARE_ALL_SIZED(fpf); +DECLARE_ALL_SIZED(fp); +DECLARE_ALL_SIZED(fpl); +DECLARE_ALL_SIZED(fpf16b); +DECLARE_ALL_SIZED(fpf16); +DECLARE_ALL_SIZED(fpf32); +DECLARE_ALL_SIZED(fpf64); +DECLARE_ALL_SIZED(fpf128); +DECLARE_ALL_SIZED(fpf32x); +DECLARE_ALL_SIZED(fpf64x); + #undef DECLARE_1 #undef DECLARE_ALL_SIZED #undef DECLARE_ALL_SIZED_ diff --git a/libatomic/testsuite/Makefile.in b/libatomic/testsuite/Makefile.in index 247268f1949..e617e8f67ac 100644 --- a/libatomic/testsuite/Makefile.in +++ b/libatomic/testsuite/Makefile.in @@ -159,6 +159,7 @@ ECHO_T = @ECHO_T@ EGREP = @EGREP@ EXEEXT = @EXEEXT@ FGREP = @FGREP@ +FPSUFFIXES = @FPSUFFIXES@ GREP = @GREP@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@