From patchwork Wed Dec 17 19:09:27 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wilco Dijkstra X-Patchwork-Id: 126748 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from vm01.sourceware.org (localhost [127.0.0.1]) by sourceware.org (Postfix) with ESMTP id 187B24BA2E05 for ; Wed, 17 Dec 2025 19:11:28 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 187B24BA2E05 Authentication-Results: sourceware.org; dkim=pass (1024-bit key, unprotected) header.d=arm.com header.i=@arm.com header.a=rsa-sha256 header.s=selector1 header.b=ii51xLEd; dkim=pass (1024-bit key) header.d=arm.com header.i=@arm.com header.a=rsa-sha256 header.s=selector1 header.b=ii51xLEd X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from MRWPR03CU001.outbound.protection.outlook.com (mail-francesouthazon11011065.outbound.protection.outlook.com [40.107.130.65]) by sourceware.org (Postfix) with ESMTPS id EB3424BA2E05 for ; Wed, 17 Dec 2025 19:10:42 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org EB3424BA2E05 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=arm.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org EB3424BA2E05 Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=40.107.130.65 ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1765998643; cv=pass; b=Z3afVzLLw5hN0DxOSyOQ1XjmBe0pcKoDTXWMctR2W8tn2dQ6BlJ9OjbsjXLAHczdhPeh8fCEeGh2a3dv3vYulklgD4P/nShq8Q8Veft3BknM9s6TxpnLuS4PKSlkeqlHBBvW6pfMhS/sM11VMPp2PSvFEReZFOHTbztB55BKo6A= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1765998643; c=relaxed/simple; bh=jWIGx/CvbAOY3I6uhj6YQ5tz0wo0/xE8Br5Ld0ovaps=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=LZ6DrNxV5JhZ6h98ZyIH0T/G8hDJOt7TIZmAwd9g6+3lZJCr40y5RIDOsYPF6LcRWicDDajx/Nw/8YQHbBJgln9iMz/9BXgva6HTyVPtA5oF5QQbCtkaB5ButCoCwNlFrEp+xUrK0TYffi4yG52QmWKjjfT9kXqXygisM/fBfFI= ARC-Authentication-Results: i=3; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org EB3424BA2E05 ARC-Seal: i=2; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=pass; b=eZH+o1bO0znZJZBQn1UGy0bVcqGUq9qH3jAdExA8b3JKgiYnHmsEQYTMZomr7n5XqP9fEy8m862N574cEkiIaBY3IfhIqZMl7PTa8ucf98709kWGLcDHiFTi8JmgzW6JI8uQQfZZ0M0nEXYWDtDDsS6/8BRGvTY7YZG3xAhgVooUS8wMfsiVwZP5L9w9f/TuYiR3JsIJPxT3RvMR8vKVLKDeBzSHccFMK/LLDpq+MUVhNDUaESqHI1Fgi156143dmI4eHhiERDWG0pmjtVOtK0IxviaiDY9Hw5C8ynNUMk0GOD8tliwQuh3ifgxdQTKMz2rxoIIDG5a+t8qZBK5UiQ== ARC-Message-Signature: i=2; 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=FAcvtDpioJSCJ6SmQiuFTqRNi9rHSRi0vyROJdqWc4Q=; b=RoG2uWlHqwVNbBqjYj5sR7ChUEJt6Ck0dMbpMtTff3IG6THXfw+kjYash6JlHeJebSKMNdqwkLlniJ+b1bdFtgGLVGxmGvuc/WKIgDSkwAME6fQKnpZ8nXbWkUuWK2kpS3AXOqp9G2yac1cFsBh4Wn0+Ern/uNreSb9zLkPneporCbs04+afzs97wgpZ8nXzhae/ve07nhJw9P0pm/picBpBN0KOvMIiUSwx9ls9j0sAp8EGyUeSjqOexUVo42JSDru3y3TM8H5iAlTTOqlldYAqbLyHMfCYni7aoJg96xbTqHI/fFrGuogNn+tfI+qGAQfZxQtwzinaAzYrC9RXGQ== ARC-Authentication-Results: i=2; mx.microsoft.com 1; spf=pass (sender ip is 4.158.2.129) smtp.rcpttodomain=linaro.org smtp.mailfrom=arm.com; dmarc=pass (p=none sp=none pct=100) action=none header.from=arm.com; dkim=pass (signature was verified) header.d=arm.com; arc=pass (0 oda=1 ltdi=1 spf=[1,1,smtp.mailfrom=arm.com] dkim=[1,1,header.d=arm.com] dmarc=[1,1,header.from=arm.com]) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=arm.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=FAcvtDpioJSCJ6SmQiuFTqRNi9rHSRi0vyROJdqWc4Q=; b=ii51xLEdI5qVvn9asy/+ZXJizGbs9Gkk/TQabdRwSIZEsMxd9U0FO4LpDCGxt7YXqyqrLd6lqw1Rvq6coYnTO3t9O3UCM+yyCLspi03rJEIwehP8C5D9kVpVaKREqtibwwLb37gAW//wafJOftYb+yHpg0CpbU2FbeU6MOTOaRY= Received: from AM8P189CA0008.EURP189.PROD.OUTLOOK.COM (2603:10a6:20b:218::13) by GV1PR08MB11246.eurprd08.prod.outlook.com (2603:10a6:150:281::5) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.9434.6; Wed, 17 Dec 2025 19:10:34 +0000 Received: from AMS0EPF000001A3.eurprd05.prod.outlook.com (2603:10a6:20b:218:cafe::89) by AM8P189CA0008.outlook.office365.com (2603:10a6:20b:218::13) with Microsoft SMTP Server (version=TLS1_3, cipher=TLS_AES_256_GCM_SHA384) id 15.20.9434.6 via Frontend Transport; Wed, 17 Dec 2025 19:10:33 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 4.158.2.129) smtp.mailfrom=arm.com; dkim=pass (signature was verified) header.d=arm.com;dmarc=pass action=none header.from=arm.com; Received-SPF: Pass (protection.outlook.com: domain of arm.com designates 4.158.2.129 as permitted sender) receiver=protection.outlook.com; client-ip=4.158.2.129; helo=outbound-uk1.az.dlp.m.darktrace.com; pr=C Received: from outbound-uk1.az.dlp.m.darktrace.com (4.158.2.129) by AMS0EPF000001A3.mail.protection.outlook.com (10.167.16.228) with Microsoft SMTP Server (version=TLS1_3, cipher=TLS_AES_256_GCM_SHA384) id 15.20.9434.6 via Frontend Transport; Wed, 17 Dec 2025 19:10:32 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=lAwVHXBaNVDmwWDDeU9MgpUP54nO6eLMjEfTKKqrSVCjI0TYhy2zoRe5oFzscoXqER6GepSfEn0yf7PmurpeQh13hL5QhtTjEf94nEbqTPq/JkrVaazENuXQpzWwhFZ2Ojtqql2HwOecC0Ct1Ig/ixNNCXZES302LwFZB3JsJyW2gkgEyQtskwQIxc1lAS49twy0KSECp485jgINzNxsIay/Z4AkIXx+C+/mJEhYiI/IuTvuBFclxb+hInzcGFPGOcezxwek8w22xzOKofuV8BjCp5Rxr8ckQTdGu4vRz941lh+zuLOW6towt9Xym5jmXd+xpr++jMut7QDPKXy/xQ== 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=FAcvtDpioJSCJ6SmQiuFTqRNi9rHSRi0vyROJdqWc4Q=; b=jW/ik0F0GWVtxhJjVsz8uIEDDx18lTPn6NAGDoOgcuRJ/sqq/V9T9REOWdcDZ/1jJvYtRPRBmMTmn+tqMB3wnrMdk9ZbepJ2wUSom45QkgMHK7j0s3x+HXQ/5UxUh1jbd6Z0GpvEZg/hA7ywAp7lpBZRPN5jajpkxgQ+qNin0LUpx11KqDki/MrZXtNCtEOj+nWyAJOStxhvSIyX4HYaJU3y7CN4jPzz8KZGY/TSWShh5Ei9JFlV4hAGm82AjgcMfZXAIj8s/09TskVSgksGhv2/a/lDGjnrhDyJ8PWwlBRTKiILn1CYXEOUpk1wgldCBfUPD5vksfu2F6oK/LrXlQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=arm.com; dmarc=pass action=none header.from=arm.com; dkim=pass header.d=arm.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=arm.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=FAcvtDpioJSCJ6SmQiuFTqRNi9rHSRi0vyROJdqWc4Q=; b=ii51xLEdI5qVvn9asy/+ZXJizGbs9Gkk/TQabdRwSIZEsMxd9U0FO4LpDCGxt7YXqyqrLd6lqw1Rvq6coYnTO3t9O3UCM+yyCLspi03rJEIwehP8C5D9kVpVaKREqtibwwLb37gAW//wafJOftYb+yHpg0CpbU2FbeU6MOTOaRY= Received: from PAWPR08MB8982.eurprd08.prod.outlook.com (2603:10a6:102:33f::20) by GV2PR08MB8511.eurprd08.prod.outlook.com (2603:10a6:150:b5::5) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.9434.6; Wed, 17 Dec 2025 19:09:27 +0000 Received: from PAWPR08MB8982.eurprd08.prod.outlook.com ([fe80::b366:6358:236e:352d]) by PAWPR08MB8982.eurprd08.prod.outlook.com ([fe80::b366:6358:236e:352d%6]) with mapi id 15.20.9434.001; Wed, 17 Dec 2025 19:09:27 +0000 From: Wilco Dijkstra To: Adhemerval Zanella Netto CC: GNU C Library , "Andreas K. Huettel" Subject: [PATCH v3] atomic: Reinstate HAVE_64B_ATOMICS configure check Thread-Topic: [PATCH v3] atomic: Reinstate HAVE_64B_ATOMICS configure check Thread-Index: AQHcb4ghL9Z+6hrr4k+3DLifvSVWwg== Date: Wed, 17 Dec 2025 19:09:27 +0000 Message-ID: Accept-Language: en-GB, en-US Content-Language: en-GB X-MS-Has-Attach: X-MS-TNEF-Correlator: msip_labels: Authentication-Results-Original: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=arm.com; x-ms-traffictypediagnostic: PAWPR08MB8982:EE_|GV2PR08MB8511:EE_|AMS0EPF000001A3:EE_|GV1PR08MB11246:EE_ X-MS-Office365-Filtering-Correlation-Id: a540c223-5261-4911-dd73-08de3d9ff354 x-checkrecipientrouted: true nodisclaimer: true X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam-Untrusted: BCL:0; ARA:13230040|1800799024|366016|376014|38070700021; X-Microsoft-Antispam-Message-Info-Original: =?iso-8859-1?q?HGO+ZGmpKwogt1CVX?= =?iso-8859-1?q?VCIkuikmN1KjOMvitMLNybCoOvEBYvOZtWjsV4tQRiLnW+gIKJpAwflKz50Y?= =?iso-8859-1?q?72khAt84lLMyrv+oSB+3+DKJwRlvmu3HG1ZAKpiWZQFzURfX065zbu6XSWrD?= =?iso-8859-1?q?I08+ZsHaH7lP78OFMfcw1fADHh5u9Gxhedhn998o2GK0sDiq8vXCJfiAjvlW?= =?iso-8859-1?q?aH7rrsNPisr+EshGfda/fV+v/quVMZ8u53J+lEDi6mR/EocBtUc0IqWhvAgQ?= =?iso-8859-1?q?UtOLPnOHG/sjHx6CEjC+9patuLfPbt8pvK59fVc6pDMqNCP/91FJDPtr/ccs?= =?iso-8859-1?q?0aBPy623y6BYmjjRtG159I/ItsnNN9zY+UyeBpBqM1SPc/kklPe8j5idkFOC?= =?iso-8859-1?q?2rcOpmFhQL33E0Cxe6Y3GkBWVTx21ZjEnMepBpixfYN0kRH4TujHBSU0FMLo?= =?iso-8859-1?q?NbrC1YnHl1ouQkxxvwruQPT1ixZoJFXBMDvgVtl+W5SgJup/E87c7W1UY6Fu?= =?iso-8859-1?q?WML9D81BuR6cIdgJja/rrntZ8xL8l3AhYBMSLnKdsr5E5j1YPkbxgApcL18K?= =?iso-8859-1?q?k8hawk6jCbKnKvIiH9BGxe5KNAkGXl82V5r75wFxid/sAOWJWGI671/uNdXM?= =?iso-8859-1?q?LpnolxeLVbM6SlwfM/f5hCJCujWmDJJg3ufTj2UO5cI2d0QXUJiMSNYoMdTJ?= =?iso-8859-1?q?QmRUN/RPg1hqBff8UlhbHoiCjO3TnuOre9DF0/9SpEPICcLW2nK+TyhbbBD+?= =?iso-8859-1?q?1quXhuQbnGGOdOj5l2QUZ+7Jc8y/GOdRmZh0G+kR0m9Iq18Eg0QChAzqiQ6u?= =?iso-8859-1?q?uNKEmiMVnAQl71R94SKgSnhwBXdAbHtadfz5pPOsJx2XLv14symB9CwC3x2K?= =?iso-8859-1?q?a1k9lLPZ86ELEkiA1y2Xoh3Jo6V6ifD+i3YxHunwqp7F3hx9bwtYZxyWq5pE?= =?iso-8859-1?q?byciv05hUzMJgl5MfZlS/3zjOBUinnczIxLoC53MY3sY1Xjv+oPM2rCZToQg?= =?iso-8859-1?q?LOYU8banrrQ0oQFf8nSnZ2OK+2vlFIgkx+7kDx0HbHmcQThZmn80a23E0qxL?= =?iso-8859-1?q?IzWa6gumKzVnVwmgyVvOApdZVZ3FNeekwJzg1/saKY0XcQjg2URKH90O6aH/?= =?iso-8859-1?q?U05/dPa0wP+B180blsq9YTomzZ+dgyEF4Ug/nCO30Q97wMCFTovlCygEnwBV?= =?iso-8859-1?q?cSzSJUO/txH7ooysvupHfJqSDnQvzW6wjLJDVk2WQkksB8g4f/BJ0doSGgi1?= =?iso-8859-1?q?v3uqxpeKMV46O3+3E3VUtAs7zx07+XYhfbuvZ12Az5FqXi9sEEJQSj0Z5oem?= =?iso-8859-1?q?aXr0p5YBMNDatMO4a+JIfXgywPwBwsEswJ/qlck3BXWG7TTXly1JDJqE9FQe?= =?iso-8859-1?q?BCzZSdEX9m3Dx0zpZW/6cdzfN4I4hpHi/4nfCyEDMxSqwfPahqYQXfyYLr6e?= =?iso-8859-1?q?u6ar8hEFwRFdudGWY2z8BMeMD7GAXpWghvVdBDIA3v/NuT9lFfWT7zGE2QdF?= =?iso-8859-1?q?ypzvZ685A6v526Kq9uF9Ndi2iuAtbcrNPMtV43o2eYtOPSkqtZmLHSpcFM/S?= =?iso-8859-1?q?cDA91+BAYkQKCG5SXiu?= X-Forefront-Antispam-Report-Untrusted: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:PAWPR08MB8982.eurprd08.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230040)(1800799024)(366016)(376014)(38070700021); DIR:OUT; SFP:1101; MIME-Version: 1.0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: GV2PR08MB8511 X-EOPAttributedMessage: 0 X-MS-Exchange-Transport-CrossTenantHeadersStripped: AMS0EPF000001A3.eurprd05.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 64d598be-94b1-4b81-f56a-08de3d9fcc66 X-Microsoft-Antispam: BCL:0; ARA:13230040|1800799024|35042699022|36860700013|14060799003|82310400026|376014; X-Microsoft-Antispam-Message-Info: =?iso-8859-1?q?thNFYwiqdDnDw5uf7/ucL4Mt7m?= =?iso-8859-1?q?lPpKhZokp9j/ZGGxeMF5K3/LNcLfdPB72/lmSQpn8X7MOepTiY/Icefqc5LW?= =?iso-8859-1?q?d/oxhiJcgeXSWIpWcOFF5Mmp8goWKU2dVZ6B6ibcYH10J8iO1+0FWbRh3FIc?= =?iso-8859-1?q?8bDWDVF3kRlhnUJxE1qEwPoCmAhkU3/tg3TyjnULstXUXP3RB9WKz6VQXwZg?= =?iso-8859-1?q?G34wtF7jPhgqaySoesQTO54tLlqeiFmTecRIErxt3fdxBQo0bYYYY0KiXcXw?= =?iso-8859-1?q?+9j+kHzc0IOEk+bsfwvLc8sYIQnNPYLs7vxs+mDTUjNJ/GTp5DleozVKymyP?= =?iso-8859-1?q?tFCzD4ofFvt5IVhlgx0s2kwM5f1omcVh+uQNEJwXQ4itbMILcoc7j9br5gAx?= =?iso-8859-1?q?KLDFQ9RH/+6/PGVIdz3eHhkU9Y9MpOL3ZzhNqfQ2FfLuHEtNZ6+ZB9SCy1Im?= =?iso-8859-1?q?574AjRvILaGaL94tv+Z+vp93mySa9HxtD7Crg6+X5py3uPCXTg6mAkUXjFg6?= =?iso-8859-1?q?QjH2FHtBxv7VjR/6OAV0dmF34kp7z6EfrddM2cyqekob8bYxBCqavoc0mD3R?= =?iso-8859-1?q?adrji8hMJc2WcvfL+b1IRhW3YR3fcaK6Anel1QY063EVuXxidM1qpg4fn2Bq?= =?iso-8859-1?q?LQ3niVLCLqsUejEIic+drkJWTHVvWd+k3zaWukA1EeSl3uFZ/6l3kNDMofa8?= =?iso-8859-1?q?jQCh0X3JWKP8rNYKInZf7ES1jXbjpIkV2U085zx+AM59Los7/92dzo8zJq5a?= =?iso-8859-1?q?aLNPpzixVTx9bIi9WlR52MS9wyQOsTahdTrvoidrqC+HVWNmRH3wdG+d4KTj?= =?iso-8859-1?q?V6vL1MDnZXDEk+PsuuOHTS8GOBQ1m9eISWfU4oxnt20/PTAQed3gdo1s78og?= =?iso-8859-1?q?qVf2WCOL3gqyIF9GOiwunK5hLgOgU7i9Pclvzopfijo3465y3dIiU6d/SaC6?= =?iso-8859-1?q?HgFHb0gh4fDKRkg0NX6rF0dVD0JQHGclbLfkk2u1BGiQ9Uobtea0t7edMXCe?= =?iso-8859-1?q?xOnN2aGTZQuP0VNCjFfMzwlfRT73CIH0FqVnQ5hOGzxFU6jiUh+xmKE7emm3?= =?iso-8859-1?q?rQevdn58PINMUl9yZ36hhxfixG/r+f0s62MeDteEj1ezagXy1BiwXqdaVHAf?= =?iso-8859-1?q?cqV8IDmY80/zA61cnYhgZcP4y1tGF7shl3Wv4e4H9KdH0kA2DuWcFeYS160+?= =?iso-8859-1?q?DcF3qMXMchTq5dM7b7r4toNMbr3GgN33wn+1mGCLkh13IDl8zr+3u5rYtD6Q?= =?iso-8859-1?q?tXn9nhSfuC9r6r7CuCC5WIJr4q0e50QFPYPPp+HT2jRQsCs4/5PiQw+rGiFr?= =?iso-8859-1?q?F5whe83OTZZnFSlBcuTWRH5weJvKZ19EhTGltS5+C4/6CwHs6toqSu0VpeZt?= =?iso-8859-1?q?9EhtGjA67wIniRh0DzcA0/JIjBanUcLnCqmr+ACrjxzf8JeJgMyhEf0X1SBx?= =?iso-8859-1?q?8iXdqWt0/JIxykesMrBbRFoDd84mw6vfHuc0L7cDKLvue6GbUHNeni6TWLjf?= =?iso-8859-1?q?5DX+k07tzfimJer0o0jw2m+M/ZMvOMwy24iZH8t1Qx5gscZuXYhtZGaPyho8?= =?iso-8859-1?q?IcJU3GvI6WoXbLRYljmb8D9Rn3ACACn3T8DWzaM4jAl4lxrzrBr+8=3D?= X-Forefront-Antispam-Report: CIP:4.158.2.129; CTRY:GB; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:outbound-uk1.az.dlp.m.darktrace.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(13230040)(1800799024)(35042699022)(36860700013)(14060799003)(82310400026)(376014); DIR:OUT; SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 17 Dec 2025 19:10:32.3652 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: a540c223-5261-4911-dd73-08de3d9ff354 X-MS-Exchange-CrossTenant-Id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=f34e5979-57d9-4aaa-ad4d-b122a662184d; Ip=[4.158.2.129]; Helo=[outbound-uk1.az.dlp.m.darktrace.com] X-MS-Exchange-CrossTenant-AuthSource: AMS0EPF000001A3.eurprd05.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: GV1PR08MB11246 X-Spam-Status: No, score=-9.7 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FORGED_SPF_HELO, GIT_PATCH_0, KAM_LOTSOFHASH, KAM_SHORT, PROLO_LEO2, RCVD_IN_DNSWL_BLOCKED, RCVD_IN_MSPIKE_H2, RCVD_IN_VALIDITY_RPBL_BLOCKED, RCVD_IN_VALIDITY_SAFE_BLOCKED, SPF_HELO_PASS, SPF_NONE, TXREP, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libc-alpha-bounces~patchwork=sourceware.org@sourceware.org v3: Fixup header guards on alpha/sparc, remove redundant -mcpu=v8 for leon3 Reinstate HAVE_64B_ATOMICS configure check that was reverted by commit 7fec8a5de6826ef9ae440238d698f0fe5a5fb372 due to BZ #33632. This was fixed by 3dd2cbfa35e0e6e0345633079bd5a83bb822c2d8 by only allowing 64-bit atomics on sem_t if its type is 8-byte aligned. Rebase and add in cleanups in include/atomic.h that were omitted. Passes buildmanyglibc (with trivial fix for leon3). OK for commit? Reviewed-by: Adhemerval Zanella diff --git a/config.h.in b/config.h.in index abc215850d00da8d8d101b699f13d996af8a60c1..2cd8c90eb663bd5d6b215ccd7ca5cfed6a683f47 100644 --- a/config.h.in +++ b/config.h.in @@ -225,6 +225,9 @@ /* Define if __builtin_fmod/__builtin_remainder is inlined on x86. */ #undef HAVE_X86_INLINE_FMOD +/* Set to 1 if 64 bit atomics are supported. */ +#undef HAVE_64B_ATOMICS + /* */ diff --git a/configure b/configure index aa92a122b1818040976f097d2ebdf7270cf9734f..0cd2269859c972ef26037992d859310c51073628 100755 --- a/configure +++ b/configure @@ -7679,6 +7679,48 @@ if test "$libc_cv_gcc_builtin_memset" = yes ; then fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for 64-bit atomic support" >&5 +printf %s "checking for 64-bit atomic support... " >&6; } +if test ${libc_cv_gcc_has_64b_atomics+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) cat > conftest.c <<\EOF +typedef struct { long long t; } X; +extern void has_64b_atomics(void); +void f(void) +{ + X x; + /* Use address of structure with 64-bit type. This avoids incorrect + implementations which return true even if long long is not 64-bit aligned. + This works on GCC and LLVM - other cases have bugs and they disagree. */ + _Static_assert (__atomic_always_lock_free (sizeof (x), &x), "no_64b_atomics"); +} +EOF +if { ac_try='${CC-cc} -O2 -S conftest.c' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 + (eval $ac_try) 2>&5 + ac_status=$? + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; +then + libc_cv_gcc_has_64b_atomics=yes +else + libc_cv_gcc_has_64b_atomics=no +fi +rm -f conftest* ;; +esac +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $libc_cv_gcc_has_64b_atomics" >&5 +printf "%s\n" "$libc_cv_gcc_has_64b_atomics" >&6; } +if test "$libc_cv_gcc_has_64b_atomics" = yes; then + printf "%s\n" "#define HAVE_64B_ATOMICS 1" >>confdefs.h + +else + printf "%s\n" "#define HAVE_64B_ATOMICS 0" >>confdefs.h + +fi + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for compiler option to disable generation of FMA instructions" >&5 printf %s "checking for compiler option to disable generation of FMA instructions... " >&6; } if test ${libc_cv_cc_nofma+y} diff --git a/configure.ac b/configure.ac index ab355fa266ea498c1ea5029f41ad6063f7e7939d..3e4a601c01fc4a82f500edc143c2994b60971bff 100644 --- a/configure.ac +++ b/configure.ac @@ -1485,6 +1485,33 @@ if test "$libc_cv_gcc_builtin_memset" = yes ; then AC_DEFINE(HAVE_BUILTIN_MEMSET) fi +AC_CACHE_CHECK(for 64-bit atomic support, libc_cv_gcc_has_64b_atomics, [dnl +cat > conftest.c <<\EOF +typedef struct { long long t; } X; +extern void has_64b_atomics(void); +void f(void) +{ + X x; + /* Use address of structure with 64-bit type. This avoids incorrect + implementations which return true even if long long is not 64-bit aligned. + This works on GCC and LLVM - other cases have bugs and they disagree. */ + _Static_assert (__atomic_always_lock_free (sizeof (x), &x), "no_64b_atomics"); +} +EOF +dnl +if AC_TRY_COMMAND([${CC-cc} -O2 -S conftest.c]); +then + libc_cv_gcc_has_64b_atomics=yes +else + libc_cv_gcc_has_64b_atomics=no +fi +rm -f conftest* ]) +if test "$libc_cv_gcc_has_64b_atomics" = yes; then + AC_DEFINE(HAVE_64B_ATOMICS, 1) +else + AC_DEFINE(HAVE_64B_ATOMICS, 0) +fi + dnl Determine how to disable generation of FMA instructions. AC_CACHE_CHECK([for compiler option to disable generation of FMA instructions], libc_cv_cc_nofma, [dnl diff --git a/include/atomic.h b/include/atomic.h index ed0dfbde3f98af4e9bb094c64c585d4b88891794..d7f9469ffe9d015007773b16227508700ce21a5f 100644 --- a/include/atomic.h +++ b/include/atomic.h @@ -27,11 +27,6 @@ - support functions like barriers. They also have the prefix "atomic_". - Architectures must provide a few lowlevel macros (the compare - and exchange definitions). All others are optional. They - should only be provided if the architecture has specific - support for the operation. - As macros are usually heavily nested and often use local variables to make sure side-effects are evaluated properly, use for macro local variables a per-macro unique prefix. This file uses @@ -42,7 +37,6 @@ #include -# undef atomic_compare_and_exchange_val_acq # define atomic_compare_and_exchange_val_acq(mem, newval, oldval) \ ({ \ __typeof (*(mem)) __atg3_old = (oldval); \ @@ -50,7 +44,6 @@ __atg3_old; \ }) -# undef atomic_compare_and_exchange_val_rel # define atomic_compare_and_exchange_val_rel(mem, newval, oldval) \ ({ \ __typeof (*(mem)) __atg3_old = (oldval); \ @@ -58,7 +51,6 @@ __atg3_old; \ }) -# undef atomic_compare_and_exchange_bool_acq # define atomic_compare_and_exchange_bool_acq(mem, newval, oldval) \ ({ \ __typeof (*(mem)) __atg3_old = (oldval); \ @@ -121,55 +113,33 @@ C11. Usually, a function named atomic_OP_MO(args) is equivalent to C11's atomic_OP_explicit(args, memory_order_MO); exceptions noted below. */ -/* We require 32b atomic operations; some archs also support 64b atomic - operations. */ -void __atomic_link_error (void); -# if USE_64B_ATOMICS == 1 -# define __atomic_check_size(mem) \ - if ((sizeof (*mem) != 4) && (sizeof (*mem) != 8)) \ - __atomic_link_error (); -# else -# define __atomic_check_size(mem) \ - if (sizeof (*mem) != 4) \ - __atomic_link_error (); -# endif -/* We additionally provide 8b and 16b atomic loads and stores; we do not yet - need other atomic operations of such sizes, and restricting the support to - loads and stores makes this easier for archs that do not have native - support for atomic operations to less-than-word-sized data. */ -# if USE_64B_ATOMICS == 1 -# define __atomic_check_size_ls(mem) \ - if ((sizeof (*mem) != 1) && (sizeof (*mem) != 2) && (sizeof (*mem) != 4) \ - && (sizeof (*mem) != 8)) \ - __atomic_link_error (); -# else -# define __atomic_check_size_ls(mem) \ - if ((sizeof (*mem) != 1) && (sizeof (*mem) != 2) && sizeof (*mem) != 4) \ - __atomic_link_error (); -# endif - -# define atomic_thread_fence_acquire() \ - __atomic_thread_fence (__ATOMIC_ACQUIRE) -# define atomic_thread_fence_release() \ - __atomic_thread_fence (__ATOMIC_RELEASE) -# define atomic_thread_fence_seq_cst() \ - __atomic_thread_fence (__ATOMIC_SEQ_CST) +/* Check atomic operations are lock free. Since this doesn't work correctly + on all targets (eg. if uint64_t is 4-byte aligned), use__HAVE_64B_ATOMICS + for 64-bit types. */ +#define __atomic_check_size(mem) \ + _Static_assert (__atomic_always_lock_free (sizeof (*(mem)), 0) && \ + !(sizeof (*(mem)) == 8 && HAVE_64B_ATOMICS == 0), \ + "atomic not lock free!") + +#define atomic_thread_fence_acquire() __atomic_thread_fence (__ATOMIC_ACQUIRE) +#define atomic_thread_fence_release() __atomic_thread_fence (__ATOMIC_RELEASE) +#define atomic_thread_fence_seq_cst() __atomic_thread_fence (__ATOMIC_SEQ_CST) # define atomic_load_relaxed(mem) \ - ({ __atomic_check_size_ls((mem)); \ + ({ __atomic_check_size((mem)); \ __atomic_load_n ((mem), __ATOMIC_RELAXED); }) # define atomic_load_acquire(mem) \ - ({ __atomic_check_size_ls((mem)); \ + ({ __atomic_check_size((mem)); \ __atomic_load_n ((mem), __ATOMIC_ACQUIRE); }) # define atomic_store_relaxed(mem, val) \ do { \ - __atomic_check_size_ls((mem)); \ + __atomic_check_size((mem)); \ __atomic_store_n ((mem), (val), __ATOMIC_RELAXED); \ } while (0) # define atomic_store_release(mem, val) \ do { \ - __atomic_check_size_ls((mem)); \ + __atomic_check_size((mem)); \ __atomic_store_n ((mem), (val), __ATOMIC_RELEASE); \ } while (0) diff --git a/include/atomic_wide_counter.h b/include/atomic_wide_counter.h index 5b1979e6019499f891603168acf5152048ace331..106701c88a38b60410cb858ce03c60ffa05f969a 100644 --- a/include/atomic_wide_counter.h +++ b/include/atomic_wide_counter.h @@ -22,7 +22,7 @@ #include #include -#if USE_64B_ATOMICS +#if HAVE_64B_ATOMICS static inline uint64_t __atomic_wide_counter_load_relaxed (__atomic_wide_counter *c) @@ -65,7 +65,7 @@ __atomic_wide_counter_fetch_xor_release (__atomic_wide_counter *c, return atomic_fetch_xor_release (&c->__value64, val); } -#else /* !USE_64B_ATOMICS */ +#else /* !HAVE_64B_ATOMICS */ uint64_t __atomic_wide_counter_load_relaxed (__atomic_wide_counter *c) attribute_hidden; @@ -98,6 +98,6 @@ __atomic_wide_counter_add_relaxed (__atomic_wide_counter *c, __atomic_wide_counter_fetch_add_relaxed (c, val); } -#endif /* !USE_64B_ATOMICS */ +#endif /* !HAVE_64B_ATOMICS */ #endif /* _ATOMIC_WIDE_COUNTER_H */ diff --git a/misc/atomic_wide_counter.c b/misc/atomic_wide_counter.c index 65f4288db29387ceb2801ee0edd5cc469854b058..7bdf4f0d2f9d22c267d5c3e037a8e6d76de1b00e 100644 --- a/misc/atomic_wide_counter.c +++ b/misc/atomic_wide_counter.c @@ -18,7 +18,7 @@ #include -#if !USE_64B_ATOMICS +#if !HAVE_64B_ATOMICS /* Values we add or xor are less than or equal to 1<<31, so we only have to make overflow-and-addition atomic wrt. to concurrent load @@ -124,4 +124,4 @@ __atomic_wide_counter_load_relaxed (__atomic_wide_counter *c) return ((uint64_t) (h & ~((unsigned int) 1 << 31)) << 31) + l; } -#endif /* !USE_64B_ATOMICS */ +#endif /* !HAVE_64B_ATOMICS */ diff --git a/nptl/pthread_cond_common.c b/nptl/pthread_cond_common.c index de3580b56fdaeeb53e8146d5479dce5e5e1f663c..60bec96ee571f8416e3cc6b2c90d0f115aea8d5c 100644 --- a/nptl/pthread_cond_common.c +++ b/nptl/pthread_cond_common.c @@ -52,7 +52,7 @@ __condvar_add_g1_start_relaxed (pthread_cond_t *cond, unsigned int val) __atomic_wide_counter_add_relaxed (&cond->__data.__g1_start, val); } -#if USE_64B_ATOMICS == 1 +#if HAVE_64B_ATOMICS == 1 static inline uint64_t __condvar_fetch_xor_wseq_release (pthread_cond_t *cond, unsigned int val) @@ -60,7 +60,7 @@ __condvar_fetch_xor_wseq_release (pthread_cond_t *cond, unsigned int val) return atomic_fetch_xor_release (&cond->__data.__wseq.__value64, val); } -#else /* !USE_64B_ATOMICS */ +#else /* !HAVE_64B_ATOMICS */ /* The xor operation needs to be an atomic read-modify-write. The write itself is not an issue as it affects just the lower-order half but not bits @@ -103,7 +103,7 @@ __condvar_fetch_xor_wseq_release (pthread_cond_t *cond, unsigned int val) return ((uint64_t) h << 31) + l2; } -#endif /* !USE_64B_ATOMICS */ +#endif /* !HAVE_64B_ATOMICS */ /* The lock that signalers use. See pthread_cond_wait_common for uses. The lock is our normal three-state lock: not acquired (0) / acquired (1) / diff --git a/stdlib/setenv.h b/stdlib/setenv.h index aed97efd4e3a6deb66bdc56e59a64f2d0b4e67c1..07ac97b9061fdc57a394bb0f2bc93de541057b23 100644 --- a/stdlib/setenv.h +++ b/stdlib/setenv.h @@ -61,7 +61,7 @@ __environ_is_from_array_list (char **ep) but given that counter wrapround is probably impossible to hit (2**32 operations in unsetenv concurrently with getenv), using seems unnecessary. */ -#if USE_64B_ATOMICS +#if HAVE_64B_ATOMICS typedef uint64_t environ_counter; #else typedef uint32_t environ_counter; diff --git a/sysdeps/alpha/atomic-machine.h b/sysdeps/alpha/atomic-machine.h index b7ce8c4726d0a6aa2ab770afc35924e5f1d6d51e..df981d5881c5444c222922e2cbd97ea773481be5 100644 --- a/sysdeps/alpha/atomic-machine.h +++ b/sysdeps/alpha/atomic-machine.h @@ -18,7 +18,7 @@ #ifndef _ALPHA_ATOMIC_MACHINE_H #define _ALPHA_ATOMIC_MACHINE_H -#include_next +#include #define atomic_write_barrier() __asm ("wmb" : : : "memory"); diff --git a/sysdeps/generic/atomic-machine.h b/sysdeps/generic/atomic-machine.h index ef72d9ba0d43994d94b9249b146de3519af0beac..9f8528c1f2a7943405d83296760bfe9c7a7d6a65 100644 --- a/sysdeps/generic/atomic-machine.h +++ b/sysdeps/generic/atomic-machine.h @@ -34,16 +34,4 @@ and adaptive mutexes to optimize spin-wait loops. */ -#include - -/* NB: The NPTL semaphore code casts a sem_t to a new_sem and issues a 64-bit - atomic operation for USE_64B_ATOMICS. However, the sem_t has 32-bit - alignment on 32-bit architectures, which prevents using 64-bit atomics even - if the ABI supports it. */ -#if __WORDSIZE == 64 -# define USE_64B_ATOMICS 1 -#else -# define USE_64B_ATOMICS 0 -#endif - #endif /* atomic-machine.h */ diff --git a/sysdeps/generic/atomic-sem_t.h b/sysdeps/generic/atomic-sem_t.h index 6205cc4f6b00d8d218eb6ef14356f9e064bbb2b6..a5d32cac001ae2a9e7ea7edf71f9698b1be2dff8 100644 --- a/sysdeps/generic/atomic-sem_t.h +++ b/sysdeps/generic/atomic-sem_t.h @@ -18,8 +18,8 @@ #include #include -#if USE_64B_ATOMICS && (SEM_T_ALIGN >= 8 \ - || defined HAVE_UNALIGNED_64B_ATOMICS) +#if HAVE_64B_ATOMICS && (SEM_T_ALIGN >= 8 \ + || defined HAVE_UNALIGNED_64B_ATOMICS) # define USE_64B_ATOMICS_ON_SEM_T 1 #else # define USE_64B_ATOMICS_ON_SEM_T 0 diff --git a/sysdeps/nptl/rseq-access.h b/sysdeps/nptl/rseq-access.h index 451cbf2743f32b2d22a586fe67fe99c06b0f5a40..17e7a68e0ba119cce18cfb672d58cc10529f76bc 100644 --- a/sysdeps/nptl/rseq-access.h +++ b/sysdeps/nptl/rseq-access.h @@ -28,7 +28,7 @@ /* Static assert for types that can't be loaded/stored atomically on the current architecture. */ -#if USE_64B_ATOMICS +#if HAVE_64B_ATOMICS #define __RSEQ_ASSERT_ATOMIC(member) \ _Static_assert (sizeof (RSEQ_SELF()->member) == 1 \ || sizeof (RSEQ_SELF()->member) == 4 \ diff --git a/sysdeps/riscv/atomic-machine.h b/sysdeps/riscv/atomic-machine.h index e375c6665e978393654040044f096ece2ce3e592..b6494b3c83703b46c40e8a47e9011d96202dd770 100644 --- a/sysdeps/riscv/atomic-machine.h +++ b/sysdeps/riscv/atomic-machine.h @@ -21,8 +21,6 @@ #ifdef __riscv_atomic -#include_next - /* Miscellaneous. */ # define asm_amo(which, ordering, mem, value) ({ \ diff --git a/sysdeps/sparc/atomic-machine.h b/sysdeps/sparc/atomic-machine.h index 2ffcbb2fcf3f3ed4b56c9b87556d48b69c2bad10..92b3ebdf6e16447cd5035084e7e574cddf0ea456 100644 --- a/sysdeps/sparc/atomic-machine.h +++ b/sysdeps/sparc/atomic-machine.h @@ -17,9 +17,7 @@ . */ #ifndef _SPARC_ATOMIC_MACHINE_H -#define _SPARC_ATOMIC_MACHINE_H 1 - -#include_next +#define _SPARC_ATOMIC_MACHINE_H #ifdef __sparc_v9__ # define atomic_full_barrier() \ @@ -34,4 +32,4 @@ extern void __cpu_relax (void); # define atomic_spin_nop() __cpu_relax () #endif -#endif /* _ATOMIC_MACHINE_H */ +#endif diff --git a/sysdeps/unix/sysv/linux/sparc/sparc32/Makefile b/sysdeps/unix/sysv/linux/sparc/sparc32/Makefile index 167307cc78a95e86fa6f06ead1feb906980d361b..133704a57f3859057a984c104fb566fec50cdf30 100644 --- a/sysdeps/unix/sysv/linux/sparc/sparc32/Makefile +++ b/sysdeps/unix/sysv/linux/sparc/sparc32/Makefile @@ -9,12 +9,6 @@ ifeq ($(subdir),stdlib) gen-as-const-headers += ucontext_i.sym endif -# When I get this to work, this is the right thing -ifeq ($(subdir),elf) -CFLAGS-rtld.c += -mcpu=v8 -#rtld-routines += dl-sysdepsparc -endif # elf - ifeq ($(subdir),math) # These 2 routines are normally in libgcc{.a,_s.so.1}. # However, sparc32 -mlong-double-128 libgcc relies on diff --git a/sysdeps/x86/atomic-machine.h b/sysdeps/x86/atomic-machine.h index cfa6b62d323fb72b2be1e55e2ed2c2baf6431f00..0681f57987939ee44a6cfc2e2cee0c573435b1e2 100644 --- a/sysdeps/x86/atomic-machine.h +++ b/sysdeps/x86/atomic-machine.h @@ -19,12 +19,6 @@ #ifndef _X86_ATOMIC_MACHINE_H #define _X86_ATOMIC_MACHINE_H 1 -#ifdef __x86_64__ -# define USE_64B_ATOMICS 1 -#else -# define USE_64B_ATOMICS 0 -#endif - #define atomic_spin_nop() __asm ("pause") #endif /* atomic-machine.h */