From patchwork Mon Aug 5 16:10:33 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Jose E. Marchesi" X-Patchwork-Id: 1969115 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=oracle.com header.i=@oracle.com header.a=rsa-sha256 header.s=corp-2023-11-20 header.b=DhJMmCWF; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=oracle.onmicrosoft.com header.i=@oracle.onmicrosoft.com header.a=rsa-sha256 header.s=selector2-oracle-onmicrosoft-com header.b=kBpghKYR; 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 4Wd1dY3NG9z1yZl for ; Tue, 6 Aug 2024 02:11:13 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 39487385C6C7 for ; Mon, 5 Aug 2024 16:11:11 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mx0b-00069f02.pphosted.com (mx0b-00069f02.pphosted.com [205.220.177.32]) by sourceware.org (Postfix) with ESMTPS id 11B7A385840F for ; Mon, 5 Aug 2024 16:10:42 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 11B7A385840F Authentication-Results: sourceware.org; dmarc=pass (p=reject dis=none) header.from=oracle.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=oracle.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 11B7A385840F Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=205.220.177.32 ARC-Seal: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1722874244; cv=pass; b=Ma34zZ5v3rLZ3AUOH3W/nSdPWifatmm7iEN6VMVWKGQIGldu7tcfu4tVRiPTCeBiCpf2YQz2G+twj3AUzWKmtLzqDECm56GbOU7BEs67bihOzTCJ12PqBCzSuiwrRtbKsHyDlDEecaAXSQHBkkPvRHZrTiST1VTZgg1TjmXNcXY= ARC-Message-Signature: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1722874244; c=relaxed/simple; bh=uYlGsBMGFc89ckX4DyFIUZiSi2pxV6O6JrVXlXysOeY=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-Id: MIME-Version; b=kizHnLQQRXrPRHEBcQxoPppdrQQO1eLFkVWJcIZkWR5xdr4wk+QDKv02GNebl02lyJbG/IPV4i01R0UGl8o1Wq2SnCqp7gnxKOG0wCuOGEPOt32jm4lQVjNX+dZIZdb7Vy4uLF/Awpwh9r0K/KO9wXYzbs6/iM6ljYJZQnUn1Y8= ARC-Authentication-Results: i=2; server2.sourceware.org Received: from pps.filterd (m0333520.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 475FtaWg005152 for ; Mon, 5 Aug 2024 16:10:41 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h= from:to:subject:date:message-id:content-transfer-encoding :content-type:mime-version; s=corp-2023-11-20; bh=R/APQqx+sh/G2G yn0DiDlf5dHNA8sAyoIvG6jt8gq6k=; b=DhJMmCWFpMnOK3vDt4mRKaUGtuM9G8 B6zW5rECDSHJG0/ljWwez0pTIfLBHO7JUc2xeTiJqndXH9oOVCswNcihdjLjmTNN uUbHerK31HVPMYzMoZuEIFq6e9/uPywSySjze343Ch54jZkJqTTS1oVkx0eANmZC RDIZWapxi9IFBvaaZDSYH5mf7mPJo6bpfVjC1uHvcMfSz8CeulWPUM9UkuqawR2s aLPekdg19hjj+yurqDVHKgozxBqUPHBSXQl6yXFRkIIWtZQuI+qDychVEJ8NjcSq Cn3/8A0kbhfXFeJAXMjk9eJamiAFRna/d03Yx3dbftCA2bm095sgBEYg== Received: from iadpaimrmta02.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta02.appoci.oracle.com [147.154.18.20]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 40sckcb236-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Mon, 05 Aug 2024 16:10:41 +0000 (GMT) Received: from pps.filterd (iadpaimrmta02.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta02.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 475Eu7Un016944 for ; Mon, 5 Aug 2024 16:10:40 GMT Received: from nam10-mw2-obe.outbound.protection.outlook.com (mail-mw2nam10lp2044.outbound.protection.outlook.com [104.47.55.44]) by iadpaimrmta02.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 40sb08r5cw-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Mon, 05 Aug 2024 16:10:40 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=Yedd/eCF2cl6ZbvCnofa8ulfO78qSxLyTAFObv9rOVCp5J9YzgAj+rG+z0XeL75Jg7A0QPp3NNEbh7/Eo8SHc1Iz5BkodaytMZRRzlEsbGNkS1JTVZCaiuHA3PMMlW3FUkp9Etc6fwVtcsV7aY6b8Xu/9FnFn9Y4yfPrtwmZLTmgw+3dT48ZScUP/9t3l8sZAND3RpX0BhY/qquGMZw8FeAXyoGpqniqOo5nq4+GWmfvF9VkSfzvfzew3ebmsc5amKO4Vh1SAS/oje8RJvBI1IhWdvNzWerVHtTCbAq+Q7dPF13E0F5dE0cISLdN5Yw+w286qYt0ow63oWggCMut3A== 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=R/APQqx+sh/G2Gyn0DiDlf5dHNA8sAyoIvG6jt8gq6k=; b=B28U+UqrCt1/gMZH84PHv4N35a2Ltel7GPCkmH96fPfaRRRN1dRzWig3DqxRnCS2aVOprvJtS4mppcHCMadqUtLNuu+aZZqdqefb6pWtxyWWukkA5v0zy+rPFvMcvgCpo7k2Eb4oXCrLIjhjyaNIp5bq5ojNJKANS5r2hxvP5poia1r4EOS9jW2rhgk54fTav7TXcMUIrlC+V4YqQVvdqvyUihbVGFCt0r8LDHBiJFxpjONAT2ZT5RAV780d02hfO6cGr2MNO+63dWoumhzM8xHnlguJek+uN0g6yLtJ0XIvXZ11RVF2aUqqI3L+D83KEIMO3U/uSo+Su4vz64kjNQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=oracle.com; dmarc=pass action=none header.from=oracle.com; dkim=pass header.d=oracle.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.onmicrosoft.com; s=selector2-oracle-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=R/APQqx+sh/G2Gyn0DiDlf5dHNA8sAyoIvG6jt8gq6k=; b=kBpghKYRqMFoyYjPzzTkVAhOgPBnzTzXwWMLrjnv4aDIytg4aotm0aOoBYLg3k9XvNd6AG/M7drDq2aCm5k1mcljFk0q0roUoGlgPvM2x2tsCp29P1YGZsGgfUkgqtKZkt3YJ9S5ZBBNSOryQc5Np6SQCeA5UXzlGRHyt8XjAsI= Received: from LV8PR10MB7822.namprd10.prod.outlook.com (2603:10b6:408:1e8::6) by DS0PR10MB8150.namprd10.prod.outlook.com (2603:10b6:8:203::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7828.23; Mon, 5 Aug 2024 16:10:37 +0000 Received: from LV8PR10MB7822.namprd10.prod.outlook.com ([fe80::4808:df01:d7ce:3c1e]) by LV8PR10MB7822.namprd10.prod.outlook.com ([fe80::4808:df01:d7ce:3c1e%7]) with mapi id 15.20.7828.023; Mon, 5 Aug 2024 16:10:36 +0000 From: "Jose E. Marchesi" To: gcc-patches@gcc.gnu.org Subject: [COMMITTED, BPF] bpf: do not emit BPF non-fetching atomic instructions Date: Mon, 5 Aug 2024 18:10:33 +0200 Message-Id: <20240805161033.18249-1-jose.marchesi@oracle.com> X-Mailer: git-send-email 2.30.2 X-ClientProxiedBy: LO4P265CA0194.GBRP265.PROD.OUTLOOK.COM (2603:10a6:600:318::9) To LV8PR10MB7822.namprd10.prod.outlook.com (2603:10b6:408:1e8::6) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: LV8PR10MB7822:EE_|DS0PR10MB8150:EE_ X-MS-Office365-Filtering-Correlation-Id: 66a0f81e-c7a6-421d-a7bb-08dcb5692447 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|366016|1800799024|376014; X-Microsoft-Antispam-Message-Info: CUnSmq/bh+4cAgFfX7CmoLlwe5Z8/RdG/6RklhmhT9uJtBozsO4wwnaDq+OdA3s8UUksDJNGKh0d4xtFFRPlgb4J70MT6P2c3OylNfnNBJmc6Yljp/gH5mrmRV7Mjvw4x8RIZVHdymsCDbxAxijlq9nJ0v3NdJ0kosyc/Xgfd0CX7h1eOm7MXLQPPExy6EaP7FGQ3GYJmeaJEbwuI92OIH2N6LpuSliH3IXVKySXW2omlGPhcZjv+isjIAkHzUBPrIXuk3hUrOrOIFvjmzcbKj6BqxDs3Q0ZZ26Ly5Tu10mrCTOos851dNkJ6P0eVO9aV5KfkVttI6eZF6akjHacfCjbW7hVei+U8lWRBCl7jWRNi/98j28PNM1fDwK5aJIBE/iqREg4ZKZ8x4+lhcBnCHH4cKQ8qfM3anpDj86wYTNkUqrvhLIU17ASMKyQOj4SboOrZ5RADZKJ0WP3b/1KTaTPg/sfmzisn//HznuPXgLsZ99BeOU3HlodOdFmqRMqN6nxDc0ztxxks9RhdHWeupQjMUf/5O8+y4oW3NqANQVnsxODT273acqaxE29gXM1vSwqK5o4aWgCXkUhXPoox08ghmh7g68gQbM+ABu6GGd2vvPJlK4Wvp32YHKCk/o22E8shs4Yl2+U7KekFoe5RPT6TrP9XJt+VEzbkFWfeRQe6FLHqLx3yJ5tM5Wo+iFY066tlP6rlQ5ssmVYkFSywQl3szE88V6xKonDZDSDbUJIpwxjHklj7THw1fA/FONoGxuH/wBOLiwk6Z51GaQODliNgsAg6n4VomGTtDyGGc7/aa5sQ+y21F6NxUsdpe9rLcUjbjtGPALoc2kT2hGDrfFxlsCtrnxu0/uAaN/MLZOCEmVmasr1c7UT3/+oEcgwBnq/pPjeKoKjgRi51XDRF0bZR/s/6FWoGUrJ6qVdhPcqAvbRphHnEjRIzj+zesZsrvF5IMAvnsoe6nRSa+4sKBdTxtPE/UF48o0WSvI5edQoffH3T/5yemZqd029PcU5OgNJ+GqUCsQU6VRL2sCcG6hS5ap1DLp9/47IqJVaq0XwFSLVSGkoAnbrdeQMrouZ3oBkcwDQZyJeKvmmiQevTrCSpGwBDvQ5pmF+YddhDubTIUOX+GX/T7dHkbqP4C8xDHxJNDOyqJ6zBNY7wcQc5BzhjkI+ddIbESjtFLa2jPaIjbxR/UGBzQMTFLavUFjeof0KeqAixCQmZErzgz3iRCpjaX7ZHLHlNs1C7SSoX7yFQ9p/rlzHB+/jSJ/B8nEf0PzdFaBt5fXB7pslXsZKWQLVV7xEQxvRk+0asS0ECjEArqFc57Ipu4vg6hVfZJvi X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:LV8PR10MB7822.namprd10.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230040)(366016)(1800799024)(376014); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: WWLEiKkXrhVJL4Op5/eunUPRPzdQIemvbI+FbmQ4KLI2ljhDkHu2srRqSAE+ajfOu9VhmtAd2S5ySmB6IRZSSugZBCHMCaTW8VxRvLbYW8KxJ3aQHjnYI6ejQJq8B/cmsRz8ltNHBPhXcnmLTxBAxakFzgNPbRvtbSyENOkVwoYB6eJ3RrDdGijPhZaOvChkru7fi/f4EU8AUDtkH+SmxD96+u9CzK9spjg01YEAZO+qw0SfFixKoQt1dHL9R8vgRf1mfR79cV6mNRNJakiMBYxPRE7yKFguBXV18A6emdCr8250oETXOqfi7igHvl1/LqlHeThbP13pcjMVngDA3fhw9GscbvKfDKBcxOo0oZdHZCN5heMFA+sKT68inyvCzu59d7T5WgqzkqpC3TchHemKzvwvPeAZKw1xiRkC6OzsvGmp6FCb+tPHVQWXUb/Hg9k0Zid9lLbUMSiKWYuQdoY+UvXhJWALByjCP4rJuwc9FqM5NqF6rf8HiaziqYMQCIYODGmRvPPTDkCKS4v1LS3OziZOtY8qQVl7VoK5w1QlGeZuoWMquNkVg2eXoII6qNkZ2GVJgFZfixeueN0Qx6f2QUizyYP9bSR8pI/NOI+kcmdEp+6bFGrOD3s+bu7SV3xhBbJ64U8Hp5BPzGDtBrcrZbGyY0GGvSWuMHEYodJV9xazEm1+51GZl9a8gbMfHjR5YFUGyDdRsvzoxQgamPrfMKZn7gCMiIwvzgbB+Jn76tqGII810mO+VTkDpsUlQBRBle3+2e/duDivCDLRDwDUyXq0+DbwHD6HkT2aDqbh06pGYjrtb7M2ty5L++PWBSxbMqdRWOioITPrf5EGw5J3uFghpC1nuNHLKYsz9TrfN20C6zzKMbjd9JCA5Ng8n3bTNitQmT4HsVoMkFzL0UNZxxKuf7qoDNelRWhsFAFe/BxME5Dm6YUwixYmq8d32z5hUpKoXQzeAR49W3LMIWbvpqcXoDThFiA0FuIOEJwi35AhRtYLQbWwi4jheMuTTm074YaXoC99C1lB8xh9bNY1ChkD2jKcppeDEzvNU/BfZVtYmtZFNOGbgZx3Ap+dveKe3HBK0UtJSg0+xcOTIAfXkmsD2tH6SUONklrxb6m0R3BMop/s4OoTcPUmyu4F/ykLM0JMv/LDNyalXOizGtfgPrMYLv5P8HIRfcKmup9uij+JxqaFLUkkoWjE4bzEGGBkPbylXv6mfCiiAjJSSpNkgFkDl4wcQpFFFOhrZnx3r6G9gvvmLkvg/NoWKsFFw8n6imPkIcLz8gnw9O2iUwjf5//98SsWXGDch0ukQPoyFott7BWeSKgfMzDeUk9UhOuUL0FTz+y2rI0Cvauk83mYhyxrgE02j09SAeeU1Zj00PqGbnSEAS/u9suBD1oXoZB86WaNCEOaMDTffzrJi9Ba/N0IJo3sRdG/8+ZcGhn/3DHkTR82gKXninjYJp5WWvFFZ9ZXEkDFKcl6JPD00ClZ2y3zmNK/dj6J7mAKJydwrj+6b++94b6dhv6YxoKlxM1RSSEqxzKcJwtmd3dnFlrlRQ+bH/oKQGevLN98xxEhVXDDikxn38DUTZCmlI/ic+xzl6tKrpgPOnWGM1SXJg== X-MS-Exchange-AntiSpam-ExternalHop-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-ExternalHop-MessageData-0: 8DrUS9p7PQJYkyGniyLnKbg2j6BNyn26AVnZJkBG4WGAQyd30diq5deDJjE9v/q+dtAE0sOWjicpB4p+9BYmV6i2m7DEfsIvaPHxxtj615WsfY4IZfYbCKjYRinlOADiE8q9alInBdFUfuCcU75xcVRyY1NIv/FYGxVcEyxCKiCmCeTiptvFrP0bR9G+/syUoDUXmInlinc0Sk8QFzQdmcNihf3tvAijtBcmIyvcRe6XUnOeccpiN8+6VrAi/IAOhMSbifxPjTJxw0rtTTP7pun1oFxwzbl2HKSgcLKlDOA3Al3GgsHxISG3BD3YpcwrLrdc0zMV5m+TCKo5Q6WioJJArSe8eWw5y1shdYGg1yKRTrulzhqRcxyx4hfd3KICfsSxBrc2W0LuGtixuI+4V4UlAsLzTFKyV7rM9eM2hCQWOPKnFrXtr4l1AIgYfEgqCLubyNizpl7OTdcBh4g7oh2ToQgmIzUqg9/8H5CEz8UMwOCfaTcfY+zo1QRT71u4PnfAG5a7xWHh2Jwi95ha4ETE7sx5y+duRF2AcYIrfQbYs5RI5xuI7b3JtazYt6QlY/jpEqKqTmGQ89gGDXVzbPbYZFMPoRz3M5xss+eS2bY= X-OriginatorOrg: oracle.com X-MS-Exchange-CrossTenant-Network-Message-Id: 66a0f81e-c7a6-421d-a7bb-08dcb5692447 X-MS-Exchange-CrossTenant-AuthSource: LV8PR10MB7822.namprd10.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 05 Aug 2024 16:10:36.6262 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 4e2c6054-71cb-48f1-bd6c-3a9705aca71b X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: dKGoFHzskmg56u3eTm/YuaLpTBi4sA9NzEJeH+Lsa+Zt+sjSuPrsSAqxu09z8AayeDViNkkK7n2AHEvzgWYu2hrhfU27fQlNdbk4kPPff1s= X-MS-Exchange-Transport-CrossTenantHeadersStamped: DS0PR10MB8150 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.28.16 definitions=2024-08-05_04,2024-08-02_01,2024-05-17_01 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 phishscore=0 suspectscore=0 adultscore=0 bulkscore=0 malwarescore=0 mlxlogscore=999 mlxscore=0 spamscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2407110000 definitions=main-2408050115 X-Proofpoint-GUID: 5nBYM2zJJ2EnfWBItjsn6GLFZ1dQT1cZ X-Proofpoint-ORIG-GUID: 5nBYM2zJJ2EnfWBItjsn6GLFZ1dQT1cZ X-Spam-Status: No, score=-12.3 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, 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 When GCC finds a call to one of the __atomic_OP_fetch built-ins in which the return value is not used it optimizes it into the corresponding non-fetching atomic operation. Up to now we had definitions in gcc/config/bpf/atomic.md to implement both atomic_OP and atomic_fetch_OP sets of insns: atomic_add -> aadd (aka xadd) atomic_and -> aand atomic_or -> aor atomic_xor -> axor atomic_fetch_add -> afadd atomic_fetch_and -> afand atomic_fetch_or -> afor atomic_fetch_xor -> afxor This was not correct, because as it happens the non-fetching BPF atomic instructions imply different memory ordering semantics than the fetching BPF atomic instructions, and they cannot be used interchangeably, as it would be expected. This patch modifies config/bpf/atomic.md in order to not define the atomic_{add,and,or,xor} insns. This makes GCC to implement them in terms of the corresponding fetching operations; this is less efficient, but correct. It also updates the expected results in the corresponding tests, which are also updated to cover cases where the value resulting from the __atomic_fetch_* operations is actually used. Tested in bpf-unknown-none target in x86_64-linux-gnu host. gcc/ChangeLog * config/bpf/atomic.md ("atomic_add"): Remove insn. ("atomic_and"): Likewise ("atomic_or"): Likewise. ("atomic_xor"): Likewise. gcc/testsuite/ChangeLog * gcc.target/bpf/atomic-op-1.c (test_used_atomic_add): New function. (test_used_atomic_sub): Likewise. (test_used_atomic_and): Likewise. (test_used_atomic_nand): Likewise. (test_used_atomic_or): Likewise. (test_used_atomic_xor): Likewise. * gcc.target/bpf/atomic-op-2.c (test_used_atomic_add): Likewise. (test_used_atomic_sub): Likewise. (test_used_atomic_and): Likewise. (test_used_atomic_nand): Likewise. (test_used_atomic_or): Likewise. (test_used_atomic_xor): Likewise. * gcc.target/bpf/sync-fetch-and-add.c: Expected results updated. --- gcc/config/bpf/atomic.md | 59 +++++-------------- gcc/testsuite/gcc.target/bpf/atomic-op-1.c | 53 +++++++++++++++-- gcc/testsuite/gcc.target/bpf/atomic-op-2.c | 53 +++++++++++++++-- .../gcc.target/bpf/sync-fetch-and-add.c | 4 +- 4 files changed, 111 insertions(+), 58 deletions(-) diff --git a/gcc/config/bpf/atomic.md b/gcc/config/bpf/atomic.md index be4511bb51b..4e94c0352fe 100644 --- a/gcc/config/bpf/atomic.md +++ b/gcc/config/bpf/atomic.md @@ -22,50 +22,21 @@ (define_mode_iterator AMO [SI DI]) ;;; Plain atomic modify operations. -;; Non-fetching atomic add predates all other BPF atomic insns. -;; Use xadd{w,dw} for compatibility with older GAS without support -;; for v3 atomics. Newer GAS supports "aadd[32]" in line with the -;; other atomic operations. -(define_insn "atomic_add" - [(set (match_operand:AMO 0 "memory_operand" "+m") - (unspec_volatile:AMO - [(plus:AMO (match_dup 0) - (match_operand:AMO 1 "register_operand" "r")) - (match_operand:SI 2 "const_int_operand")] ;; Memory model. - UNSPEC_AADD))] - "" - "{xadd\t%0,%1|lock *( *)%w0 += %w1}" - [(set_attr "type" "atomic")]) - -(define_insn "atomic_and" - [(set (match_operand:AMO 0 "memory_operand" "+m") - (unspec_volatile:AMO - [(and:AMO (match_dup 0) - (match_operand:AMO 1 "register_operand" "r")) - (match_operand:SI 2 "const_int_operand")] ;; Memory model. - UNSPEC_AAND))] - "bpf_has_v3_atomics" - "{aand\t%0,%1|lock *( *)%w0 &= %w1}") - -(define_insn "atomic_or" - [(set (match_operand:AMO 0 "memory_operand" "+m") - (unspec_volatile:AMO - [(ior:AMO (match_dup 0) - (match_operand:AMO 1 "register_operand" "r")) - (match_operand:SI 2 "const_int_operand")] ;; Memory model. - UNSPEC_AOR))] - "bpf_has_v3_atomics" - "{aor\t%0,%1|lock *( *)%w0 %|= %w1}") - -(define_insn "atomic_xor" - [(set (match_operand:AMO 0 "memory_operand" "+m") - (unspec_volatile:AMO - [(xor:AMO (match_dup 0) - (match_operand:AMO 1 "register_operand" "r")) - (match_operand:SI 2 "const_int_operand")] ;; Memory model. - UNSPEC_AXOR))] - "bpf_has_v3_atomics" - "{axor\t%0,%1|lock *( *)%w0 ^= %w1}") +;; The BPF instruction set provides non-fetching atomic instructions +;; that could be used to implement the corresponding named insns: +;; +;; atomic_add -> aadd (aka xadd) +;; atomic_and -> aand +;; atomic_or -> aor +;; atomic_xor -> axor +;; +;; However, we are not including insns for these here because the +;; non-fetching BPF atomic instruction imply different memory ordering +;; semantics than the fetching BPF atomic instruction used to +;; implement the atomic_fetch_* insns below (afadd, afand, afor, +;; afxor) and they cannot be used interchangeably, as it is expected +;; by GCC when it uses a non-fetching variant as an optimization of a +;; fetching operation where the returned value is not used. ;;; Feching (read-modify-store) versions of atomic operations. diff --git a/gcc/testsuite/gcc.target/bpf/atomic-op-1.c b/gcc/testsuite/gcc.target/bpf/atomic-op-1.c index 5c87dcbffe6..b7d3d83fea7 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-op-1.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-op-1.c @@ -1,7 +1,12 @@ -/* Test 64-bit non-fetch atomic operations. */ +/* Test 64-bit fetch and non-fetch atomic operations. */ /* { dg-do compile } */ /* { dg-options "-mv3-atomics -O2 -masm=normal" } */ +/* Note that GCC optimizes __atomic_add_fetch calls whose return value is not + used into non-fetching operations that, in BPF, generate fetching + instructions anyway. See note in gcc/config/bpf/atomic.md on this + regard. */ + long val; void @@ -10,40 +15,76 @@ test_atomic_add (long x) __atomic_add_fetch (&val, x, __ATOMIC_ACQUIRE); } +long +test_used_atomic_add (long x) +{ + return __atomic_add_fetch (&val, x, __ATOMIC_ACQUIRE); +} + void test_atomic_sub (long x) { __atomic_add_fetch (&val, x, __ATOMIC_ACQUIRE); } +long +test_used_atomic_sub (long x) +{ + return __atomic_add_fetch (&val, x, __ATOMIC_ACQUIRE); +} + void test_atomic_and (long x) { __atomic_and_fetch (&val, x, __ATOMIC_ACQUIRE); } +long +test_used_atomic_and (long x) +{ + return __atomic_and_fetch (&val, x, __ATOMIC_ACQUIRE); +} + void test_atomic_nand (long x) { __atomic_nand_fetch (&val, x, __ATOMIC_ACQUIRE); } +long +test_used_atomic_nand (long x) +{ + return __atomic_nand_fetch (&val, x, __ATOMIC_ACQUIRE); +} + void test_atomic_or (long x) { __atomic_or_fetch (&val, x, __ATOMIC_ACQUIRE); } +long +test_used_atomic_or (long x) +{ + return __atomic_or_fetch (&val, x, __ATOMIC_ACQUIRE); +} + void test_atomic_xor (long x) { __atomic_xor_fetch (&val, x, __ATOMIC_ACQUIRE); } -/* sub implemented in terms of add, and we output xadd to support older GAS. */ -/* { dg-final { scan-assembler-times "xadddw\t" 2 } } */ -/* { dg-final { scan-assembler-times "aand\t" 1 } } */ +long +test_used_atomic_xor (long x) +{ + return __atomic_xor_fetch (&val, x, __ATOMIC_ACQUIRE); +} + +/* sub implemented in terms of add. */ +/* { dg-final { scan-assembler-times "afadd\t" 4 } } */ +/* { dg-final { scan-assembler-times "afand\t" 2 } } */ /* nand must use an exchange loop */ /* { dg-final { scan-assembler "acmp\t" } } */ -/* { dg-final { scan-assembler-times "aor\t" 1 } } */ -/* { dg-final { scan-assembler-times "axor\t" 1 } } */ +/* { dg-final { scan-assembler-times "afor\t" 2 } } */ +/* { dg-final { scan-assembler-times "afxor\t" 2 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/atomic-op-2.c b/gcc/testsuite/gcc.target/bpf/atomic-op-2.c index 8331d33465f..902142db164 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-op-2.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-op-2.c @@ -1,7 +1,12 @@ -/* Test 32-bit non-fetch atomic operations. */ +/* Test 32-bit fetch and non-fetch atomic operations. */ /* { dg-do compile } */ /* { dg-options "-mv3-atomics -O2 -masm=normal" } */ +/* Note that GCC optimizes __atomic_add_fetch calls whose return value is not + used into non-fetching operations that, in BPF, generate fetching + instructions anyway. See note in gcc/config/bpf/atomic.md on this + regard. */ + int val; void @@ -10,40 +15,76 @@ test_atomic_add (int x) __atomic_add_fetch (&val, x, __ATOMIC_ACQUIRE); } +long +test_used_atomic_add (int x) +{ + return __atomic_add_fetch (&val, x, __ATOMIC_ACQUIRE); +} + void test_atomic_sub (int x) { __atomic_add_fetch (&val, x, __ATOMIC_ACQUIRE); } +long +test_used_atomic_sub (int x) +{ + return __atomic_add_fetch (&val, x, __ATOMIC_ACQUIRE); +} + void test_atomic_and (int x) { __atomic_and_fetch (&val, x, __ATOMIC_ACQUIRE); } +long +test_used_atomic_and (int x) +{ + return __atomic_and_fetch (&val, x, __ATOMIC_ACQUIRE); +} + void test_atomic_nand (int x) { __atomic_nand_fetch (&val, x, __ATOMIC_ACQUIRE); } +long +test_used_atomic_nand (int x) +{ + return __atomic_nand_fetch (&val, x, __ATOMIC_ACQUIRE); +} + void test_atomic_or (int x) { __atomic_or_fetch (&val, x, __ATOMIC_ACQUIRE); } +long +test_used_atomic_or (int x) +{ + return __atomic_or_fetch (&val, x, __ATOMIC_ACQUIRE); +} + void test_atomic_xor (int x) { __atomic_xor_fetch (&val, x, __ATOMIC_ACQUIRE); } -/* sub implemented in terms of add, and we output xadd to support older GAS. */ -/* { dg-final { scan-assembler-times "xaddw\t" 2 } } */ -/* { dg-final { scan-assembler-times "aand32\t" 1 } } */ +long +test_used_atomic_xor (int x) +{ + return __atomic_xor_fetch (&val, x, __ATOMIC_ACQUIRE); +} + +/* sub implemented in terms of add. */ +/* { dg-final { scan-assembler-times "afadd32" 4 } } */ +/* { dg-final { scan-assembler-times "afand32\t" 2 } } */ /* nand must use an exchange loop */ /* { dg-final { scan-assembler "acmp32\t" } } */ -/* { dg-final { scan-assembler-times "aor32\t" 1 } } */ -/* { dg-final { scan-assembler-times "axor32\t" 1 } } */ +/* { dg-final { scan-assembler-times "afor32\t" 2 } } */ +/* { dg-final { scan-assembler-times "afxor32\t" 2 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/sync-fetch-and-add.c b/gcc/testsuite/gcc.target/bpf/sync-fetch-and-add.c index 6902aabd337..fe4f81a3f06 100644 --- a/gcc/testsuite/gcc.target/bpf/sync-fetch-and-add.c +++ b/gcc/testsuite/gcc.target/bpf/sync-fetch-and-add.c @@ -11,5 +11,5 @@ foo () __sync_fetch_and_add((int *)val, (int)delta); } -/* { dg-final { scan-assembler "xadddw\t.*" } } */ -/* { dg-final { scan-assembler "xaddw\t.*" } } */ +/* { dg-final { scan-assembler "afadd\t.*" } } */ +/* { dg-final { scan-assembler "afadd32\t.*" } } */