From patchwork Tue Sep 10 13:51:53 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Qing Zhao X-Patchwork-Id: 1983244 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=oracle.com header.i=@oracle.com header.a=rsa-sha256 header.s=corp-2023-11-20 header.b=Xgdrst5E; dkim=pass (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=NgJ4ukp4; 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 4X34rx5Ychz1y1C for ; Tue, 10 Sep 2024 23:52:33 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 9EAFC385841E for ; Tue, 10 Sep 2024 13:52:29 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mx0a-00069f02.pphosted.com (mx0a-00069f02.pphosted.com [205.220.165.32]) by sourceware.org (Postfix) with ESMTPS id 051883858D39; Tue, 10 Sep 2024 13:52:03 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 051883858D39 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 051883858D39 Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=205.220.165.32 ARC-Seal: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1725976327; cv=pass; b=jnB4LVDV6dpOX44L2X7qhw3fHRXpqkiZqQtZBfjWGuIy4vW8VGQhGtLcYAv8VbZPu0ubX5mCsVyLcmAu30OkdwfKlmM4PmSf/PHhKBpc8mMnIILrzyrCSO6ZSEaDZ4xzMJSJy0xDglx2BGGKmhuGrPTQ0szffxFj4/KtzmvuA1s= ARC-Message-Signature: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1725976327; c=relaxed/simple; bh=TM5CZV1j+9SuzWsV7pIiArRv41YdHSJR1Zt/uA8DAGE=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-Id: MIME-Version; b=CTZXATmp4F/BMKe/lSVCPe1W9NpKXgOST8W4MWzY9MJx+UAmhtoK/+s2mxWkxhJCiosVeyr4PzGnrbAhf+cjfzP3dpebj7Zgzv2qJOxWqmn+QhEfHR2r/vQKQYBixBxBtV+HbeeWjbETlmql26TEOHluaRpY2EJ3PPD9OVQCRQw= ARC-Authentication-Results: i=2; server2.sourceware.org Received: from pps.filterd (m0246629.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 48ABMi5i019113; Tue, 10 Sep 2024 13:52:02 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h= from:to:cc:subject:date:message-id:content-transfer-encoding :content-type:mime-version; s=corp-2023-11-20; bh=nSqX4KiZUFebpo 6i9yIs8cNyyIwLW4+TC7LTdpelWEU=; b=Xgdrst5EIrLs/cNGOyz4AU2sOPUYYA SueJ4WjahAxpfDUy/23j916xYZ+2GbnspkpE9zCqUI56JDlVznov6QSmekBeUQFQ y0II4qGimh8dS98H+4/d6Epz5/Ind8tX6mdK4qGDOwhVuPboP7F+8E7bGvH7/yby jXM9hr0ygwP+McSEqFGu5s81+lnUuKTsxsF5NrTulaAxSNX9I2OSmTRzVBdOQEM7 7R3G6E2adU73MshLlBA+nGWxjZVBAkVV0PrB1IZn8adT5jqFZUdCdW2JW99+3+oL pQDvAqnARSg9TO+qG4LCHeiWbrfFZr4C8kgo73d0NbRs2H7EdGYf87qw== Received: from iadpaimrmta03.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta03.appoci.oracle.com [130.35.103.27]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 41geq9nhk0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Tue, 10 Sep 2024 13:52:01 +0000 (GMT) Received: from pps.filterd (iadpaimrmta03.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta03.imrmtpd1.prodappiadaev1.oraclevcn.com (8.18.1.2/8.18.1.2) with ESMTP id 48ADh3xr006219; Tue, 10 Sep 2024 13:52:00 GMT Received: from nam11-co1-obe.outbound.protection.outlook.com (mail-co1nam11lp2176.outbound.protection.outlook.com [104.47.56.176]) by iadpaimrmta03.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 41gd98kg9f-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Tue, 10 Sep 2024 13:52:00 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=j0zcwt3Uj+M3Z8HkfCRz75rOyzDyipFuvBJVGzDvcp7ZIp6bu0eJ43ZlVKM+KuXGbFeqhUTRCSG4IVbb6ib1lbydLpkUJBO708hsKTVc+7Jf6gnSy2ew0b6H5DhINxx5ReD2LQwsSIARqmV24wSPmZgq4ckqRxHBhtWCNGHJrQ8cA81rOLNfkeu3uC/+nJRu/cHjalLlgU22ORWDPZXX+amXupcI3j7Xj96qkUDIdvvTYeY3roX3WrlaeZkByyEHwkXDDcyZRsdOo65ty7Jn8xJN+AGNuw4ZU+8f4Bs9wpLXHo0FJHRrG9IE0DF3q5oZzxsSRtXgTtc3eC7EWy2sEQ== 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=nSqX4KiZUFebpo6i9yIs8cNyyIwLW4+TC7LTdpelWEU=; b=PRz9LWytRJa1t9q0v/O3wDQGqrQTeuVe7xMnrg65AMER+6mfeXHI0rqcjQDMFziyVwwm4o45p+BJ6IO+GUEJG2bcfTeRiUNzmZK+XmWXN6uln0JtjLYbXzWg7/JsPj0oONuEnswS32bi++QJrnYpdEHeFEDInyrWZk7Bk6p3LJL6aHI/upUptOZWG0/YEm4BKueGBZTQetv8ZNyoqDuU/boBCESdyPBqwaq8bZrIh/ENasKIDoqCRYimtY0b1Ok3KZQtfRNGta6GuTtWyYsHRZOV23TZkGh2EW9K5l9GFQN2kwixrLTMIeRt16bXVfGL5xNY1BjJwsHaEPRF8lDupg== 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=nSqX4KiZUFebpo6i9yIs8cNyyIwLW4+TC7LTdpelWEU=; b=NgJ4ukp4IhhZcR2wHY5I7+9LW/9RqKvDh/cfQu9KoA+MmCO8ceBXLirC1/uVUPzuwfhn3Bi6bTuRMx8JMlprzLyHLoGr3DlQ/fbFV79FO7YH+4+Tyrla6N6z0ot+3g6NUjG0krK3wfehpTq3WQTj+M4xw6s5FxeaBrAz0Ui2dmM= Received: from CY8PR10MB6538.namprd10.prod.outlook.com (2603:10b6:930:5a::17) by MW5PR10MB5874.namprd10.prod.outlook.com (2603:10b6:303:19c::20) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7939.10; Tue, 10 Sep 2024 13:51:56 +0000 Received: from CY8PR10MB6538.namprd10.prod.outlook.com ([fe80::8a:61cd:764a:e47]) by CY8PR10MB6538.namprd10.prod.outlook.com ([fe80::8a:61cd:764a:e47%4]) with mapi id 15.20.7962.008; Tue, 10 Sep 2024 13:51:56 +0000 From: Qing Zhao To: josmyers@redhat.com, uecker@tugraz.at, jakub@redhat.com Cc: keescook@chromium.org, isanbard@gmail.com, siddhesh@gotplt.org, sjames@gcc.gnu.org, gcc-patches@gcc.gnu.org, Qing Zhao Subject: [PATCH v2] Provide new GCC builtin __builtin_counted_by_ref [PR116016] Date: Tue, 10 Sep 2024 13:51:53 +0000 Message-Id: <20240910135153.2371650-1-qing.zhao@oracle.com> X-Mailer: git-send-email 2.31.1 X-ClientProxiedBy: MN0PR04CA0014.namprd04.prod.outlook.com (2603:10b6:208:52d::20) To CY8PR10MB6538.namprd10.prod.outlook.com (2603:10b6:930:5a::17) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: CY8PR10MB6538:EE_|MW5PR10MB5874:EE_ X-MS-Office365-Filtering-Correlation-Id: 035fe932-bc21-42b3-3227-08dcd19fbc13 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|376014|1800799024|366016; X-Microsoft-Antispam-Message-Info: FJsvo+9h1WetShBxAnRvT1TaRWWIlk4MLhKnnrrWCFCvmgHO3PAf8yRLnHrDgyDcuWq4tg1or5WyULp/ox+8zVmItpA5MUbN/rcaLoK2ZIHaIzLpyxoq4F41vnc6CLQG/cdHRpgfuHNVGwKuA/L5rNlSqjIIyG1v2SM3C8rO9bQTV78IJOx8cXJ+WoA4G4OWXQG55pSIg9emOuMe7me/RqLP8LQcrtwo2HsVOrABExzf0+mJKJGmb9ZHDj0qL56SFfxaWqpADIgiwz1IUB7bQEfQIrM42Pv1ba/2ePhPA67QUR07ElDC69yYRRYFkkoDcHFGnl+GvFNT2EUkF8afLwLcPIe+A23uzf0fs8+ff77yyJJozZSpTrcn7gKIk8E81yqepgoSBS33+UTitNorL8IKWvnS6uQX/siAJVvRp7K7GEoCY4bJnxW2T6SaRWuAhPS5tYB4f0SyCkWsqX6ARmxZMdHYHiM58A3HBh3+4YVGL8tyM9PEPzlMH9lNWBNlARx4ZoOLy5i36904TaRk0kepfR7kJxw3aQ/fFqse2aDQzeAO140rViXmDXv0Z2WIFSyOoXlgfSUVBUUg2VRbrkzOcQJXD88Ewsgus7eLulnQWnrcPBOzvUAzaB6LGDPKkbfpArlG4LiqOptYzmd/WI79zaaxlnPeF8UJlgAEfmr1GmhrozRl/fSuCCfoVrY2StJuK6Zlc36anebYXwHwLVgCXBbKuwVEKvtoPFzInJM5JTTSxe5q4Ix9NpylUrf2PcZE8wUZy4XD+ehdyk4M9/QLX/ITGXmVGKGlkJ6js0yycBYu2bm/uT7Agw2ym/bdUg8a1eDC0uSv5vU4e81YWoa2Facn6gUCYXy/8yCwYz1NYGEpBU9NtTPbDaeE+s2IODs0cKBae6qEyRC6rVzLdu5QiGpE46/2BcmdIvSrKZh5AF1XuM8COnm0US+RW75bRttUNSOmJCn9B20fDbXpX2xXvJ0hs1g4pCjrJ8cT0gpiy4UcZ6A3d38PBPAg+P4q/RSAjX8PV77rWiXL288RoyBpEHxJB2kDjcyImZYAB1FCh965ds5UZTcqh6s7E3E8jl6SEfyiFplVvv1YEA904rGd2owYvu51mvmPeXH+qSkHeRUszm8FPGE0lduqZr7TTynYxZDKINeNX/NctmV4PlmeQtD9NP3wR14g+ErEV6/IPOvrNDH7N5Ou1P9W+rmEZ/2Ll04R5b8yfCls+nBnuUIfjfZCDDSMiW4s5wt8rvS+DRzqfzV0CoOQitSRZ7j9CWWxiW5JgiaPXww7bKDGGa13P67jwtvu3BjHqm/ldNs= X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:CY8PR10MB6538.namprd10.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230040)(376014)(1800799024)(366016); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: iokgbIiqaip7BH5vg3pkz0anryFPwrKEcfHzzE8oTo2QJkhdWVYmmny7l9sZy3QCANKgoGUAsQ/JxeV7+HmVQCJbAozzq1SEv9YOE7T9AkyMOAH7N+rpJTBXniXYtJp55B86nBF7/l+ByFfuA65TKyqJGd4Iu6/wCNo23ivEwKmo0biQMvqvX0M3bjUUcqDjbbtgmnj4AsYJl6MCKxv+jGsOBC+E38sQy5KPnEFp6up8THjly3O/Mgc0o4jxxDezkd6M0MLXjmcIn1DN37X/3hyPIG8LW65Sx5BXFlq67/58N0L7fpIN6tOMEKMSpsRiTiNcPRyTIDbOWFAkIaqQiNV0uk8e/GpnwR47mz08AzqgB8+6Va8oPSZxjAr6QiKHYHkSPI/Yi173YiH/xwCNOFPXXpUGeHYanp1Nz/xysy+LxiVi/J4p8ZCHGW61qW0UavXeJk2+UiCRcaOB0fcFbs+5fjRFQ8MnevL0Re111mq5B8s5Q/1O5IYjT5m+8QwfmLHWBC6GuwZSLhoEgMfFUcTGvIpEGlUibzGFfIe69g+vAcZrhzElWM5MYpeWmpHEhZBs525S8XvkHf3eKd3Xrx9T4SHTpkZCEgaGXEX7vko1pzOlUiLsuuSbql54majqiJw54tyemhRWPv/J+sqsjp1bh1sf/OkaaOXliou68UKeC4rQ3dM6FI7L8vGgQdDFAO14B6NVTeUJZrFsH1t2Q8vfprEtEmpUng/UjDU44iIsTkE4DvS2kbLz4e4pEz5x+yKq4VAyHH6xABirZFnSmS3mcB358/vHfc7KPZ4uRqz5dupF1FZC10pH9ynV+qjrKOYOyXXw0H7iCc84ZskDHcn8ms2DBvUXqsJ44JDZwZKofO8ygXBhzGJneM9KnlVFwSO2loUhfHOXdcOWc/5lGPjah+u+ywWOStQsjnXx9kBtmToxUonZ1zqrpil+NdePbMHb4dmDrD65MkOm3IoKnP0pwrYBRDEGzRBh4tWoeZfEZ2qiIVRunUioitr7nJXIIc/Jjes1aBQm8RB72JGZDiajSuTe82CeuyBO9t1ZvqkVDofXQ+E982Fl7lpmaOmuSBOy5VmlQVfpjnKJt0rpbBqvb/22Hz/FXBrdwhIMS6MutnjgR1vyKHWeLi4m+QimmCM4+KwF34LetsJI+y13xqNiJ0KqgQYwHWldy9Z+RUGA2ge5Qusuh8cSk/LvvxKQwBjVd+V9GUc28Kj4DaQPtjZ63+Yt+Hdt8VSJH+orhKxHBbeJ+glK/zYgy5Vleo5nAWx3aU0t953Ea+vkFHi9JUkyrj2NJD78FYbFOQfQHJ6pF+K1AWP6IagEqXa6ZpA40U/DFABGRz92+LOU/AvJNqf5bsfphlrMtY087z6zt9U0gH6r/YHPME25TspE8jaIOQhzRSnpmIbtIo+OikOFfgcb5PuspLiWisbgspDvjtwxWRADNJpF6xkockNz5nDptgb5QAgHGdAqo6mSMMq554642a9Pb6QGjMZrJSOYSk8NjxL06evNNO1Oi5mN6GP3Eo3QUR/7UmTtqFwd0Am9sbEjQBnWKZOMr8UZD6BpfZAmlNmdxkmAPC2wI2X6RNJ7 X-MS-Exchange-AntiSpam-ExternalHop-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-ExternalHop-MessageData-0: Xywif0tX7jxu7J4oj3j3A3B77wR88BTg0TK2KDGXCtN+FgL3rE3JPN/agxIcPxEKIcjTlss5N9+a4EhQA/8/8yreufvNDlM9Zmh3+ia7LteAgSNNDC60+JdPIyt2A42EEgns0myEplPYAKC1AM9AMknHPF6Mw2tf68lT/0FzOuJ2HIUNiaYMHBg4Pk2HzkDi0PnLDisTgVXoLlasD3R0VxcRwvQ2Y5yY6GNSFEEQUNmlbhWVsML/vD+qpPBbrUkKd/zOf+HfXciRq7HWTQybmKJNs8vpQ3bvb/XVTSkvlHvrAyJ7YQhsh6KD1r+1eI+USKqF0C0J8c7Fh0jnZntwegWw+TPCzBfdHHzUXGCKQSjU8mIOP9EuqmqK9BXJZvbj9nt7C1BiKu8RK6ku96IBuBxWJUNHidVkRkeWH4Ovtwub4uRrsNxt7PzCsygIBaTZAUyPbtm0c3IKCu7HVcDlsTALNtqqKy9B6VpSdGtyJ5vCzJ3Xgbu27dBljc0IUgg3plPnHmSpFPIv2CjoWZg88R+9GFtAQwzclewRTGXpNKRHuaeUuJor+7JyTiC9k1DfKdzmBUDYaBpm6X9pkrSPJ2ZSY1b9lFfN67JJjLEVc0M= X-OriginatorOrg: oracle.com X-MS-Exchange-CrossTenant-Network-Message-Id: 035fe932-bc21-42b3-3227-08dcd19fbc13 X-MS-Exchange-CrossTenant-AuthSource: CY8PR10MB6538.namprd10.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 10 Sep 2024 13:51:56.6576 (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: 9BQC00xuwv2x2rAxQtSteFey9uGOUlRK5vZ/n8Lh8sZrTw0HILhjRGy/DDxlOpfc0mlhBs1sgciUlFASbVTcww== X-MS-Exchange-Transport-CrossTenantHeadersStamped: MW5PR10MB5874 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-10_04,2024-09-09_02,2024-09-02_01 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 spamscore=0 malwarescore=0 mlxlogscore=999 bulkscore=0 adultscore=0 phishscore=0 suspectscore=0 mlxscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2408220000 definitions=main-2409100102 X-Proofpoint-ORIG-GUID: fofkwpvIi2EoCZ6-kFSdQS21TWwH0XBU X-Proofpoint-GUID: fofkwpvIi2EoCZ6-kFSdQS21TWwH0XBU X-Spam-Status: No, score=-11.2 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H3, 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 Hi, This is the 2nd version of the patch after the long discussion. We finally decided to keep the previous design that returns a pointer to the counted_by object. Compared to the first version, the major changes are: 1. change the name of the builtin from __builtin_get_counted_by to __builtin_counted_by_ref in order to reflect the fact that the returned value of it is a reference to the object. 2. make typeof(__builtin_counted_by_ref) working. 3. update the testing case to use the new builtin inside _Generic. bootstrapped and regress tested on both X86 and aarch64. no issue. Okay for the trunk? thanks. Qing. ==================================== With the addition of the 'counted_by' attribute and its wide roll-out within the Linux kernel, a use case has been found that would be very nice to have for object allocators: being able to set the counted_by counter variable without knowing its name. For example, given: struct foo { ... int counter; ... struct bar array[] __attribute__((counted_by (counter))); } *p; The existing Linux object allocators are roughly: #define alloc(P, FAM, COUNT) ({ \ typeof(P) __p; \ size_t __size = sizeof(*P) + sizeof(*P->FAM) * COUNT; \ __p = kmalloc(__size, GFP); \ P = __p; \ }) Right now, any addition of a counted_by annotation must also include an open-coded assignment of the counter variable after the allocation: p = alloc(p, array, how_many); p->counter = how_many; In order to avoid the tedious and error-prone work of manually adding the open-coded counted-by intializations everywhere in the Linux kernel, a new GCC builtin __builtin_counted_by_ref will be very useful to be added to help the adoption of the counted-by attribute. -- Built-in Function: TYPE __builtin_counted_by_ref (PTR) The built-in function '__builtin_counted_by_ref' checks whether the array object pointed by the pointer PTR has another object associated with it that represents the number of elements in the array object through the 'counted_by' attribute (i.e. the counted-by object). If so, returns a pointer to the corresponding counted-by object. If such counted-by object does not exist, returns a NULL pointer. This built-in function is only available in C for now. The argument PTR must be a pointer to an array. The TYPE of the returned value must be a pointer type pointing to the corresponding type of the counted-by object or VOID pointer type in case of a NULL pointer being returned. With this new builtin, the central allocator could be updated to: #define alloc(P, FAM, COUNT) ({ \ typeof(P) __p; \ size_t __size = sizeof(*P) + sizeof(*P->FAM) * COUNT; \ __p = kmalloc(__size, GFP); \ typeof(_Generic(__builtin_counted_by_ref(__p->FAM), \ void *: (size_t *)NULL, \ default: __builtin_counted_by_ref(__p->FAM))) \ ret = __builtin_counted_by_ref(__p->FAM); \ if (ret) \ *ret = COUNT; \ P = __p; \ }) And then structs can gain the counted_by attribute without needing additional open-coded counter assignments for each struct, and unannotated structs could still use the same allocator. PR c/116016 gcc/c-family/ChangeLog: * c-common.cc: Add new __builtin_counted_by_ref. * c-common.h (enum rid): Add RID_BUILTIN_COUNTED_BY_REF. gcc/c/ChangeLog: * c-decl.cc (names_builtin_p): Add RID_BUILTIN_COUNTED_BY_REF. * c-parser.cc (has_counted_by_object): New routine. (get_counted_by_ref): New routine. (c_parser_postfix_expression): Handle New RID_BUILTIN_COUNTED_BY_REF. * c-tree.h: New global in_builtin_counted_by_ref. * c-typeck.cc (build_component_ref): Enable generating .ACCESS_WITH_SIZE inside typeof when inside builtin_counted_by_ref. gcc/ChangeLog: * doc/extend.texi: Add documentation for __builtin_counted_by_ref. gcc/testsuite/ChangeLog: * gcc.dg/builtin-counted-by-ref-1.c: New test. * gcc.dg/builtin-counted-by-ref.c: New test. --- gcc/c-family/c-common.cc | 1 + gcc/c-family/c-common.h | 1 + gcc/c/c-decl.cc | 1 + gcc/c/c-parser.cc | 77 +++++++++++++++ gcc/c/c-tree.h | 1 + gcc/c/c-typeck.cc | 7 +- gcc/doc/extend.texi | 55 +++++++++++ .../gcc.dg/builtin-counted-by-ref-1.c | 97 +++++++++++++++++++ gcc/testsuite/gcc.dg/builtin-counted-by-ref.c | 58 +++++++++++ 9 files changed, 297 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/builtin-counted-by-ref-1.c create mode 100644 gcc/testsuite/gcc.dg/builtin-counted-by-ref.c diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc index e7e371fd26f..15b90bae8b5 100644 --- a/gcc/c-family/c-common.cc +++ b/gcc/c-family/c-common.cc @@ -430,6 +430,7 @@ const struct c_common_resword c_common_reswords[] = { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY }, { "__builtin_complex", RID_BUILTIN_COMPLEX, D_CONLY }, { "__builtin_convertvector", RID_BUILTIN_CONVERTVECTOR, 0 }, + { "__builtin_counted_by_ref", RID_BUILTIN_COUNTED_BY_REF, D_CONLY }, { "__builtin_has_attribute", RID_BUILTIN_HAS_ATTRIBUTE, 0 }, { "__builtin_launder", RID_BUILTIN_LAUNDER, D_CXXONLY }, { "__builtin_shuffle", RID_BUILTIN_SHUFFLE, 0 }, diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h index 027f077d51b..4400d2c5d43 100644 --- a/gcc/c-family/c-common.h +++ b/gcc/c-family/c-common.h @@ -110,6 +110,7 @@ enum rid RID_TYPES_COMPATIBLE_P, RID_BUILTIN_COMPLEX, RID_BUILTIN_SHUFFLE, RID_BUILTIN_SHUFFLEVECTOR, RID_BUILTIN_CONVERTVECTOR, RID_BUILTIN_TGMATH, RID_BUILTIN_HAS_ATTRIBUTE, RID_BUILTIN_ASSOC_BARRIER, RID_BUILTIN_STDC, + RID_BUILTIN_COUNTED_BY_REF, RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128, /* TS 18661-3 keywords, in the same sequence as the TI_* values. */ diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc index aa7f69d1b7b..1145dde9bb1 100644 --- a/gcc/c/c-decl.cc +++ b/gcc/c/c-decl.cc @@ -11788,6 +11788,7 @@ names_builtin_p (const char *name) case RID_BUILTIN_SHUFFLE: case RID_BUILTIN_SHUFFLEVECTOR: case RID_BUILTIN_STDC: + case RID_BUILTIN_COUNTED_BY_REF: case RID_CHOOSE_EXPR: case RID_OFFSETOF: case RID_TYPES_COMPATIBLE_P: diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc index aff5af17430..0feddf72f95 100644 --- a/gcc/c/c-parser.cc +++ b/gcc/c/c-parser.cc @@ -10647,6 +10647,35 @@ c_parser_predefined_identifier (c_parser *parser) return expr; } +/* Check whether the ARRAY_REF has an counted-by object associated with it + through the "counted_by" attribute. */ +static bool +has_counted_by_object (tree array_ref) +{ + /* Currently, only when the array_ref is an indirect_ref to a call to the + .ACCESS_WITH_SIZE, return true. + More cases can be included later when the counted_by attribute is + extended to other situations. */ + if ((TREE_CODE (array_ref) == INDIRECT_REF) + && is_access_with_size_p (TREE_OPERAND (array_ref, 0))) + return true; + return false; +} + +/* Get the reference to the counted-by object associated with the ARRAY_REF. */ +static tree +get_counted_by_ref (tree array_ref) +{ + /* Currently, only when the array_ref is an indirect_ref to a call to the + .ACCESS_WITH_SIZE, get the corresponding counted_by ref. + More cases can be included later when the counted_by attribute is + extended to other situations. */ + if ((TREE_CODE (array_ref) == INDIRECT_REF) + && is_access_with_size_p (TREE_OPERAND (array_ref, 0))) + return CALL_EXPR_ARG (TREE_OPERAND (array_ref, 0), 1); + return NULL_TREE; +} + /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2, C11 6.5.1-6.5.2). Compound literals aren't handled here; callers have to call c_parser_postfix_expression_after_paren_type on encountering them. @@ -11741,6 +11770,54 @@ c_parser_postfix_expression (c_parser *parser) set_c_expr_source_range (&expr, loc, close_paren_loc); break; } + case RID_BUILTIN_COUNTED_BY_REF: + { + vec *cexpr_list; + c_expr_t *e_p; + location_t close_paren_loc; + + in_builtin_counted_by_ref = true; + + c_parser_consume_token (parser); + if (!c_parser_get_builtin_args (parser, + "__builtin_counted_by_ref", + &cexpr_list, false, + &close_paren_loc)) + { + expr.set_error (); + goto error_exit; + } + if (vec_safe_length (cexpr_list) != 1) + { + error_at (loc, "wrong number of arguments to " + "%<__builtin_counted_by_ref%>"); + expr.set_error (); + goto error_exit; + } + + e_p = &(*cexpr_list)[0]; + + if (TREE_CODE (TREE_TYPE (e_p->value)) != ARRAY_TYPE) + { + error_at (loc, "the argument must be an array" + "%<__builtin_counted_by_ref%>"); + expr.set_error (); + goto error_exit; + } + + if (has_counted_by_object ((*cexpr_list)[0].value)) + expr.value + = get_counted_by_ref ((*cexpr_list)[0].value); + else + expr.value + = build_int_cst (build_pointer_type (void_type_node), 0); + + set_c_expr_source_range (&expr, loc, close_paren_loc); + +error_exit: + in_builtin_counted_by_ref = false; + break; + } case RID_BUILTIN_SHUFFLE: { vec *cexpr_list; diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h index 57befb94c08..1e8a090d3b6 100644 --- a/gcc/c/c-tree.h +++ b/gcc/c/c-tree.h @@ -737,6 +737,7 @@ extern int c_type_dwarf_attribute (const_tree, int); extern int in_alignof; extern int in_sizeof; extern int in_typeof; +extern bool in_builtin_counted_by_ref; extern bool c_in_omp_for; extern bool c_omp_array_section_p; diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc index 58b2724b39e..ed9444e2077 100644 --- a/gcc/c/c-typeck.cc +++ b/gcc/c/c-typeck.cc @@ -74,6 +74,9 @@ int in_sizeof; /* The level of nesting inside "typeof". */ int in_typeof; +/* inside "builtin_counted_by_ref". */ +bool in_builtin_counted_by_ref; + /* True when parsing OpenMP loop expressions. */ bool c_in_omp_for; @@ -2848,7 +2851,9 @@ build_component_ref (location_t loc, tree datum, tree component, bool use_datum_quals; tree counted_by_type = NULL_TREE; /* Do not handle counted_by when in typeof and alignof operator. */ - handle_counted_by = handle_counted_by && !in_typeof && !in_alignof; + handle_counted_by = handle_counted_by + && !(in_typeof && !in_builtin_counted_by_ref) + && !in_alignof; tree counted_by_ref = handle_counted_by ? build_counted_by_ref (datum, subdatum, &counted_by_type) diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index 2d795ba7e59..268e50677d7 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -15287,6 +15287,61 @@ initializers of variables usable in constant expressions. For more details refer to the latest revision of the C++ standard. @enddefbuiltin +@defbuiltin{@var{type} __builtin_counted_by_ref (@var{ptr})} +The built-in function @code{__builtin_counted_by_ref} checks whether the array +object pointed by the pointer @var{ptr} has another object associated with it +that represents the number of elements in the array object through the +@code{counted_by} attribute (i.e. the counted-by object). If so, returns a +pointer to the corresponding counted-by object. +If such counted-by object does not exist, returns a NULL pointer. + +This built-in function is only available in C for now. + +The argument @var{ptr} must be a pointer to an array. +The @var{type} of the returned value must be a pointer type pointing to the +corresponding type of the counted-by object or a VOID pointer type in case +of a NULL pointer being returned. + +For example: + +@smallexample +struct foo1 @{ + int counter; + struct bar1 array[] __attribute__((counted_by (counter))); +@} *p; + +struct foo2 @{ + int other; + struct bar2 array[]; +@} *q; +@end smallexample + +@noindent +the following call to the built-in + +@smallexample +__builtin_counted_by_ref (p->array) +@end smallexample + +@noindent +returns: + +@smallexample +&p->counter with type @code{int *}. +@end smallexample + +@noindent +However, the following call to the built-in + +@smallexample +__builtin_counted_by_ref (q->array) +@end smallexample + +@noindent +returns a void NULL pointer. + +@enddefbuiltin + @defbuiltin{void __builtin_clear_padding (@var{ptr})} The built-in function @code{__builtin_clear_padding} function clears padding bits inside of the object representation of object pointed by diff --git a/gcc/testsuite/gcc.dg/builtin-counted-by-ref-1.c b/gcc/testsuite/gcc.dg/builtin-counted-by-ref-1.c new file mode 100644 index 00000000000..0939708510a --- /dev/null +++ b/gcc/testsuite/gcc.dg/builtin-counted-by-ref-1.c @@ -0,0 +1,97 @@ +/* Test the code generation for the new __builtin_counted_by_ref. */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +#include + +struct annotated { + char b; + int c[] __attribute ((counted_by (b))); +} *array_annotated; + +struct flex { + short b; + int c[]; +} *array_flex; + +struct nested_annotated { + struct { + union { + int b; + float f; + }; + int n; + }; + char c[] __attribute__ ((counted_by (b))); +} *array_nested_annotated; + +struct nested_flex { + struct { + union { + unsigned int b; + float f; + }; + int n; + }; + char c[]; +} *array_nested_flex; + +#define MY_ALLOC(P, FAM, COUNT) ({ \ + typeof(P) __p; \ + size_t __size = sizeof(*P) + sizeof(*P->FAM) * COUNT; \ + __p = (typeof(P)) __builtin_malloc(__size); \ + __builtin_memset(__p, 0, __size); \ + typeof(_Generic(__builtin_counted_by_ref(__p->FAM), \ + void *: (size_t *)NULL, \ + default: __builtin_counted_by_ref(__p->FAM))) \ + ret = __builtin_counted_by_ref(__p->FAM); \ + if (ret) \ + *ret = COUNT; \ + if (sizeof (__builtin_counted_by_ref (__p->FAM)) != sizeof (char *)) \ + __builtin_abort (); \ + P = __p; \ +}) + +int count; + +int main(int argc, char *argv[]) +{ + MY_ALLOC(array_annotated, c, 10); + if (array_annotated->b != 10) + __builtin_abort (); + + MY_ALLOC(array_flex, c, 20); + if (array_flex->b == 20) + __builtin_abort (); + + MY_ALLOC(array_nested_annotated, c, 30); + if (array_nested_annotated->b != 30) + __builtin_abort (); + + MY_ALLOC(array_nested_flex, c, 40); + if (array_nested_flex->b == 40) + __builtin_abort (); + + count = array_annotated->b * 2 + array_nested_annotated->b * 3; + struct annotated * annotated_p; + struct flex * flex_p; + struct nested_annotated * nested_annotated_p; + struct nested_flex * nested_flex_p; + + MY_ALLOC(annotated_p, c, count); + if (annotated_p->b != count) + __builtin_abort (); + + MY_ALLOC(flex_p, c, count * 2); + if (flex_p->b == count * 2) + __builtin_abort (); + + MY_ALLOC(nested_annotated_p, c, count * 3); + if (nested_annotated_p->b != count * 3) + __builtin_abort (); + + MY_ALLOC(nested_flex_p, c, count * 4); + if (nested_flex_p->b == count * 4) + __builtin_abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/builtin-counted-by-ref.c b/gcc/testsuite/gcc.dg/builtin-counted-by-ref.c new file mode 100644 index 00000000000..78650a5d20e --- /dev/null +++ b/gcc/testsuite/gcc.dg/builtin-counted-by-ref.c @@ -0,0 +1,58 @@ +/* Testing the correct usage of the new __builtin_counted_by_ref. */ +/* { dg-do compile } */ +/* { dg-options "-O" } */ + +#include + +struct annotated { + size_t b; + int other; + int c[] __attribute ((counted_by (b))); +} *array_annotated; + +struct flex { + size_t b; + int other; + int c[]; +} *array_flex; + +#define MY_ALLOC(P, FAM, COUNT) ({ \ + typeof(P) __p; \ + size_t __size = sizeof(*P) + sizeof(*P->FAM) * COUNT; \ + __p = (typeof(P)) __builtin_malloc(__size); \ + typeof(_Generic(__builtin_counted_by_ref(__p->FAM), \ + void *: (size_t *)NULL, \ + default: __builtin_counted_by_ref(__p->FAM))) \ + ret = __builtin_counted_by_ref(__p->FAM); \ + if (ret) \ + *ret = COUNT; \ + P = __p; \ +}) + +extern char c_count; +extern short s_count; +extern int i_count; +extern long l_count; +extern float f_count; + +extern int * foo (); + +int main(int argc, char *argv[]) +{ + /* The good usages. */ + MY_ALLOC(array_annotated, c, 10); + MY_ALLOC(array_flex, c, 20); + MY_ALLOC(array_annotated, c, c_count); + MY_ALLOC(array_flex, c, i_count); + MY_ALLOC(array_annotated, c, l_count); + MY_ALLOC(array_flex, c, c_count * 3); + MY_ALLOC(array_annotated, c, l_count * i_count); + + /* The bad usages, issue errors. */ + __builtin_counted_by_ref (); /* { dg-error "wrong number of arguments to" } */ + __builtin_counted_by_ref (array_annotated->c, 10); /* { dg-error "wrong number of arguments to" } */ + __builtin_counted_by_ref (array_annotated->other); /* { dg-error "the argument must be an array" } */ + __builtin_counted_by_ref (foo()); /* { dg-error "the argument must be an array" } */ + + return 0; +}