From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx0b-00069f02.pphosted.com (mx0b-00069f02.pphosted.com [205.220.177.32]) by sourceware.org (Postfix) with ESMTPS id D4EFE385DDC1 for ; Tue, 11 Jun 2024 19:02:59 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org D4EFE385DDC1 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 D4EFE385DDC1 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=1718132586; cv=pass; b=UN8ZeNbUYKWy6Q+lMiVtPYYGVrFQQ48RzWRmKfvq5R1MorFbIUtZCdeViY4gdEUdtW4bkd7wur2MzsCJ7axG7XIF0i28aKIQcvjyoyr+7fxABNQc9YSZ2gtlD+9f2B7sHDzM4cMnr43ir4ZuEcQce3aFlZeyTtK0T79H5myszgY= ARC-Message-Signature: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1718132586; c=relaxed/simple; bh=EXcQduL4hvGRZKoZEPDlIGrZbqjK8hCJ3e9i7qdT4Zc=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=bgRPFyvjUXa2+o562Q57JtTjTnlJev2yZE66BnsZsESM4MfT1JTN0QFP5FBoNqNQ6t2mjLGmFctmBtcRRSKoh1GgNjL+Ly441jsDxxt2uXSjYVdoGW7/qBj24pLL/U9vyrjRkfkmEkO43AGaVAMSpQHohQwsommH8uPZ6kUCOgk= 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 45BG1LDh026881 for ; Tue, 11 Jun 2024 19:02:59 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h= from:to:cc:subject:date:message-id:in-reply-to:references :content-transfer-encoding:content-type:mime-version; s= corp-2023-11-20; bh=at4RT2eJLtLmq4pnkb83IgPg0WiZiSyIrBHbyhEYwPk=; b= Aqt6vQtuhgPttmd2hpX+4roAIpnblulNw/7dVe9IfoNZRibA2e1adYugRgOJ6D3N nCLGR/COWHld+INvmvpNggVkFlVorahLHHQqDLfJsFEAXz7vFA+icn1kTu7NHwX7 fU5cvobVsr7E4DAiK65WbsOnE7BWBBMCA1TzpjePIUv4vO97vZF+eedoyiv4Tw5S meyM2nFo3t5apxSxlPIB4Xp/WAt4fJFjHaNPNH+2vsiGMzTcw/WzbDw7iXdbmxaZ TRq/7CPJ3eoFd9TL/CVSXSpqmsD0lTC2uhC6x+KTMsFpQTcqWiaSsjuB85Biq+oj KZlJ1EcCU8glbp2MmVEb4g== Received: from iadpaimrmta02.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta02.appoci.oracle.com [147.154.18.20]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3ymh1gdmw2-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Tue, 11 Jun 2024 19:02:58 +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 45BIEno1036760 for ; Tue, 11 Jun 2024 19:02:57 GMT Received: from nam04-dm6-obe.outbound.protection.outlook.com (mail-dm6nam04lp2040.outbound.protection.outlook.com [104.47.73.40]) by iadpaimrmta02.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3yncdwppep-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Tue, 11 Jun 2024 19:02:57 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=DsPmdi4lCs5OBzyQoSwA4FatK/T9ZzOoSpYaXYtNtDHOr7WmF2q2nmcxGn+02OUiD5DKbnfuqrELyqQ+ZSFN3cZ9AUJY/oQSx126i5JPpa6prvAiJM36Vg/9WJo97BEzOLbCiyXXgTZNHxbMh9r6MeYG6wPNrFRb3O5x9gh4jbZMQBlB2dyg4C8vwSFuce/3ncUueoOKmonTnStNY6gKRYRCa2N7Kj65SeK6JqDTRKEa9kvP72W9Z97uruyYcwPZ90TrkVQnEoxoyVcPcq3jn7QUBAVsbtqMLNoKE1AYkXia8KzJTiGIBZ8QnvFd3HGYhOGKUq16+xzVqn7ePR61lA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=at4RT2eJLtLmq4pnkb83IgPg0WiZiSyIrBHbyhEYwPk=; b=m2y4N2m33mxlYwbJLBpKD5CNIZtbn1YcFI7FKO9nd3zykS6NggN7uwsMCK41b13LOwU94/DyjrFpw1eiVBhi6fs5PgLhrNt9IkzqTYmZp0efSZnZMJ+JCMEHkvygqV733skm/F3I356aquyE2S5tLdUA2EhEkj+T44q7922+W7dgoy+5K2EVK4Urc7xlSreR80NU8gmPYffeadQNCM52uDhYdJa+izhmc4C2Ugijtsz6h9DELp1LiWAAtKsXhauBi21h+7MlCI3Gz7TS8V8Gn61wy7EpfI6hzjXVhRqNHB87bFAe7WtPjH1rGKA99535ypwdSAzHCFCrNqRFOIKpZw== 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=at4RT2eJLtLmq4pnkb83IgPg0WiZiSyIrBHbyhEYwPk=; b=VrF33WohN5bpPCagEJEadVqvkw5hMxN3fF3tLUhdxi1Vsh51O9EgPrldwZkdloD3X1CnAG8y3bjHzPRLj8uAvgFhGHoacpW3rBMZ/aHiWPHJwr2mikLjV1DZFBUtVyNbgvYij038gpjHlbPI9LvfypU31/YXjyOOLdYHwx6t6lQ= Received: from DS0PR10MB7953.namprd10.prod.outlook.com (2603:10b6:8:1a1::22) by CH2PR10MB4134.namprd10.prod.outlook.com (2603:10b6:610:a7::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7633.39; Tue, 11 Jun 2024 19:02:54 +0000 Received: from DS0PR10MB7953.namprd10.prod.outlook.com ([fe80::5b2d:d28c:8773:c84]) by DS0PR10MB7953.namprd10.prod.outlook.com ([fe80::5b2d:d28c:8773:c84%5]) with mapi id 15.20.7633.036; Tue, 11 Jun 2024 19:02:54 +0000 From: David Faust To: gcc-patches@gcc.gnu.org Cc: indu.bhagat@oracle.com, jose.marchesi@oracle.com, cupertino.miranda@oracle.com Subject: [PATCH v4 2/6] ctf: use pointers instead of IDs internally Date: Tue, 11 Jun 2024 12:01:41 -0700 Message-ID: <20240611190145.115887-3-david.faust@oracle.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240611190145.115887-1-david.faust@oracle.com> References: <20240611190145.115887-1-david.faust@oracle.com> Content-Transfer-Encoding: 8bit Content-Type: text/plain X-ClientProxiedBy: MW4PR03CA0030.namprd03.prod.outlook.com (2603:10b6:303:8f::35) To DS0PR10MB7953.namprd10.prod.outlook.com (2603:10b6:8:1a1::22) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DS0PR10MB7953:EE_|CH2PR10MB4134:EE_ X-MS-Office365-Filtering-Correlation-Id: 597966aa-620e-4743-5bac-08dc8a491925 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230032|1800799016|366008|376006; X-Microsoft-Antispam-Message-Info: =?us-ascii?Q?iVXVb4N7mgM8PZsdyyh89MFgdpLJb0l5DwzFIGbP8LrfmjtzqoX4QZJUhrM2?= =?us-ascii?Q?iRhBUgIo1oucPNS09b4+YqeY1et7iPGaVSWq/RMWLuZkOVIcmhny5DBcya3v?= =?us-ascii?Q?wqllxc7wtPhVj9iAjuK7vxHt1ve7swPEQ0YkuWzMwDGahmwSCvtlId9CZbET?= =?us-ascii?Q?h4op4m1Fe+bhbWKhIQYHvRIWToP2z0djBFA0NrD1w/uo4vS4jG9iXMYya2AM?= =?us-ascii?Q?DtUEphKyOlKehnklpqh0NtaEGxVv2hYdV+3G+dIK2Sb3RmTOFzj6bLhRiEuI?= =?us-ascii?Q?tyRQGnY/+rX+CA2+axShmO2jz0++cN/v8cQLSqtRkQyRposyo0vQibXqViWY?= =?us-ascii?Q?ISggXZkIKYFa8eDPaNXF8Isy/px+Li7iDghRRFaQZ6gcsdW3iyF6c/SQGSJR?= =?us-ascii?Q?+k29o5jOjC55stxm3HzaS1QPlv8Kb8p/A97USWNct9+umHuj9I2Ses1oE4jN?= =?us-ascii?Q?Jk99sJUUv8xtW5C1b9o1gJ9wCWYF9+V9YhjElgBqhpyBqc4f+GbukErBxGHd?= =?us-ascii?Q?A+IcQafB/vv3wqh5LRAajR8qmTDXak/tXYoVOdPmcoezgR13BshZwKE0MW9/?= =?us-ascii?Q?Xb9Ronv/KSI5dTPgxInju2h3RhiPolZ9RCPWkxKFXRJm0bCDY7whQTWVxZ5m?= =?us-ascii?Q?p+aLfKxejvkct4xja/gaNQaQ0Q2OeDD9o6JFFSpRhiYluorSjAnhAjne19Aa?= =?us-ascii?Q?YW1Dn4B8qIeOslnlDgXmQ0wQe0Hfd1ynmtWC+Ygzk+fv4Gohqu1aaUiYaNpw?= =?us-ascii?Q?/bOXAIzzGLP7CczI7n2SoJ0fHZ1lUYkgH53b3xmMi/z+Xdka3gp4BWyNsUta?= =?us-ascii?Q?Wt7CdAk9Pn1oOCIEsulrEAcHclrhBi2uv2d+PEKC75s/bG7/LZ8eHIPUdTpY?= =?us-ascii?Q?oYCtZt1aOSXe21inBQH/XDMd5LLV4Hw3aJcNL7rFSaxLZ2CmUeL1owm/VUOC?= =?us-ascii?Q?5crCswrw11qbwHI6JnX7BnpfI3Dgrujj1W4d4qnrdlo2spA3yD3Nc94sJ8ea?= =?us-ascii?Q?phAEzl3Rjfv1n6449Cr9TbxL0BJBKEflbKLXqXHcGxRXdz3v8PGwnvDz/WWw?= =?us-ascii?Q?p2EpeLy0IN/tqUrhMZcYKshsu++WI/ttItowhzev05VIi2ssATJQRviOu/Un?= =?us-ascii?Q?ruz0wwuVl9QW/LT2WsTU/rLhtfsQ5yvS+Dad47BfsjiZIP8Gywd+XWY21XqH?= =?us-ascii?Q?WKB0w7Q+eyBGs4+joeQNPNz6muBjI27mDWWyuHEDAhSKUVUliePzhcxDcOVd?= =?us-ascii?Q?urSnhooKbWLcpKs5a/EmXt+uZakI3x7mKcwdbTVNe4wCgdrE7Od3TmbCuF9u?= =?us-ascii?Q?M4DuHJwI8a4RlCmI16EyQtDo?= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:DS0PR10MB7953.namprd10.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230032)(1800799016)(366008)(376006);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?ZdBB0tHvAelaAE2hN/A+09m45CmSUWw6MQ4d0sp0PYN6ZYONICRMxcQvEoyi?= =?us-ascii?Q?NZ4S4oRlEMDbokTEWNOIpN0FihsmsKfzyZYnZkRcQ6QFbdepOyX0vi1PuH8G?= =?us-ascii?Q?E2Nnotnc7PkVsrnfcwu9LFI8gx5lUTH3VTYITbqxVMuLCF9ipJXoLtEWBhwX?= =?us-ascii?Q?dqS+iE9rB7+9IROVIpV1rHJKVsLFQo2cU7V30He0nu2scUyf873QrfQKBlU7?= =?us-ascii?Q?p9a0eJnRdQVJjOnkLdNKxAZswqgWs2Poo02i+5tpc2KkHoYsO/SydQaep2MW?= =?us-ascii?Q?JR//CuHSufVp5imJOFA/dnnnRTk/uve09k+F2Td6zoRdUrlD5JNEYnPC8+zl?= =?us-ascii?Q?vAyDSoZ84k2LpK0mMVAp1YV0zVPs44ioXTYXemnxQu3KcY/QwqVrAhqUVAkH?= =?us-ascii?Q?5P6BaF6KMLMfIQbxjNMZXhs3ZncxdctaQr+RK8z1jsC9d5xe6zoXjy1mLuOs?= =?us-ascii?Q?WYrKo9Z5FaM2rvk4PzfbM8uniBsr5J/ayMfGBzFbS5R/pnH2J8IW3wXKQWEd?= =?us-ascii?Q?ZC3a1mN4noBkYG1wiucpV8aZtO+LY1oeF+qSjGn6+llsBeV/GVRo1uye9ubl?= =?us-ascii?Q?v+BeD59Td2V4EJXaJ5IEvi5dKcSLKt3q7LtZL4BhZX62Z3Z2fRFdNylWu71k?= =?us-ascii?Q?Pmkfor7tNQJAUP7WshsKiGC5k+aR2V4QXHLvBK7CQ6CHhTkjEMAurzzYx866?= =?us-ascii?Q?icruc0wc+p0RC+NN2ti/WxUxqCG6fpjCO2w6n0x9KiORqLo7ReiO5/JPZjZ9?= =?us-ascii?Q?bgQPxPkhGq4voXvfPVx00gvyC4p/r9HYVsyaMg5J2z74bKrmqrhJOgFlpN9d?= =?us-ascii?Q?c7gd3y2aWEmamNbVpNe4pWvo0lr55Y0tOK45P11biECnJOMMshK3ItnHbe7j?= =?us-ascii?Q?0FB4CC1ExpubcWEE5XKXF10xTus4V1Rj7FzZDWBJ5eYS48uqGx7GT7qw0mJn?= =?us-ascii?Q?xd56qH3VKw93gIL1hpsEN+7EBEmeoHz8M+XGy0K1zpldpo7lcfC9QCmgqB25?= =?us-ascii?Q?FyVOtm34nGEMf8jE5HCcGusQxcDG0Jov8AknMwFMtejxen5PcmVPhwTMQPou?= =?us-ascii?Q?sQhoKa9U/m23KR3gFMvtobQ7h2QNq1EJ3uoCCo5EUXCRSKBbZtaTbm5CV8kJ?= =?us-ascii?Q?2WuKH/V7n6qLXpmuLI+hDtC1UUCdQUdgHUDtjetLuzKCZ5OaHul6yYuAYBl3?= =?us-ascii?Q?o3C3yyha35xJMD/vW3ccUFLt30zR70FwwZfqvNop2vBut1NNggBGBY9LIYTW?= =?us-ascii?Q?+UkE8+cJhKWQR5u3KLoMUyizzsb0yJ3wGFAA8myZUKWJJbjN0Q+2TrD7lNb/?= =?us-ascii?Q?ZpdmGk+RGr4+AuCzJJ6A35yIVopbnAg+HZR/jKHvL6oBaaK7nKumujKAYM+i?= =?us-ascii?Q?wtXd0GQYmPtaBGD90h6ArWsdZfMlP4R6lrG7M5DBRvkxxz3bMVScQNmV/BSQ?= =?us-ascii?Q?20tG6ZNsl1kCsxj/hbyJLNeqTH4n3wOsA8BQfJmFkYAbwve5+Gn94+81gE8b?= =?us-ascii?Q?8/q7wPvsoW0EsnHSHFzJJOHGe7eNEZ0NwpfciWzU4n0HPxO7tufDA5hBGVMh?= =?us-ascii?Q?wGpb8gLUT+ICJUEMoWPubjrmUttAe9EiLvu8OQdBaGJOEfSYLWfTQDUhC96k?= =?us-ascii?Q?Ig=3D=3D?= X-MS-Exchange-AntiSpam-ExternalHop-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-ExternalHop-MessageData-0: K7+uYzKtjdTeAPoA8azSwZo6UmT+ss+4o1/hKjx2MZcRH05YcufKO/x+eeXj1AAr4ZNn2jAqyDNpbJvPTywHELGwjtPUJY49/PWVLNUIQSDTOjeP73FPzTvc4Tc4S9UmRyDjQq8nvQF1QgP2aSb2Gyzci/A4vbCIhIt9/uIoKFcKBTGSl5JKHrMCIV6zytuE4LXGRs3SB98unN1fd6ARJn6xTBB3dIMx3UmL0Ifob55EVc/SGcj8ZVn2Gx453rq/PVogRLxiQKZmAobGQVgFyqUzvSNkt2bQzx2PBs6uL3p+btxK+8vTBjhJSO40XYRl93NMnyP9aEBpkbPU5Xu0g3hYFbBY36g6TaOJo83ITGoEPxYWMT+ohoXFy307FaXDJoe9JTY9ettNHws0X1YXSbKVvtw0fXR0R/njy2bIuAWeARw9YLmiJ2vGpt1zZVfP2S+KnHjIysaUg03T75AisOOmIokeE8EnfvgSzLOcICJ0mTnLrakk5KL4t5CReftbn5jgBvadn749DFUx9eTEsje6hjG1ikl6Tebefb2PU6U4zqL7FjQWxiJiSLJxSBt2WBPlJXLuTvYWDAmQGOPQUttu7Y1u5yIQCE8QY1UacWc= X-OriginatorOrg: oracle.com X-MS-Exchange-CrossTenant-Network-Message-Id: 597966aa-620e-4743-5bac-08dc8a491925 X-MS-Exchange-CrossTenant-AuthSource: DS0PR10MB7953.namprd10.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 11 Jun 2024 19:02:54.1082 (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: AemJMgsEwa1yRnIyFcCQJ6fkbeywwWjNR0sEKsb0VUH9/mdAbJ3bfYDi7EsULRYRnztYabkcd3zHvM9MP9jqjA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: CH2PR10MB4134 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-06-11_09,2024-06-11_01,2024-05-17_01 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 spamscore=0 phishscore=0 adultscore=0 mlxscore=0 bulkscore=0 malwarescore=0 mlxlogscore=999 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2405010000 definitions=main-2406110130 X-Proofpoint-ORIG-GUID: rE_USV6AMJEcDWPWiL6Vyw-fK58vjlAd X-Proofpoint-GUID: rE_USV6AMJEcDWPWiL6Vyw-fK58vjlAd X-Spam-Status: No, score=-13.7 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_DNSWL_LOW,RCVD_IN_MSPIKE_H4,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE,TXREP,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: This patch replaces all inter-type references in the ctfc internal data structures with pointers, rather than the references-by-ID which were used previously. A couple of small updates in the BPF backend are included to make it compatible with the change. This change is only to the in-memory representation of various CTF structures to make them easier to work with in various cases. It is outwardly transparent; there is no change in emitted CTF. gcc/ * btfout.cc (BTF_VOID_TYPEID, BTF_INIT_TYPEID): Move defines to include/btf.h. (btf_dvd_emit_preprocess_cb, btf_emit_preprocess) (btf_dmd_representable_bitfield_p, btf_asm_array, btf_asm_varent) (btf_asm_sou_member, btf_asm_func_arg, btf_init_postprocess): Adapt to structural changes in ctf_* structs. * ctfc.h (struct ctf_dtdef): Add forward declaration. (ctf_dtdef_t, ctf_dtdef_ref): Move typedefs earlier. (struct ctf_arinfo, struct ctf_funcinfo, struct ctf_sliceinfo) (struct ctf_itype, struct ctf_dmdef, struct ctf_func_arg) (struct ctf_dvdef): Use pointers instead of type IDs for references to other types and use typedefs where appropriate. (struct ctf_dtdef): Add ref_type member. (ctf_type_exists): Use pointer instead of type ID. (ctf_add_reftype, ctf_add_enum, ctf_add_slice, ctf_add_float) (ctf_add_integer, ctf_add_unknown, ctf_add_pointer) (ctf_add_array, ctf_add_forward, ctf_add_typedef) (ctf_add_function, ctf_add_sou, ctf_add_enumerator) (ctf_add_variable): Likewise. Return pointer instead of ID. (ctf_lookup_tree_type): Return pointer to type instead of ID. * ctfc.cc: Analogous changes. * ctfout.cc (ctf_asm_type, ctf_asm_slice, ctf_asm_varent) (ctf_asm_sou_lmember, ctf_asm_sou_member, ctf_asm_func_arg) (output_ctf_objt_info): Adapt to changes. * dwarf2ctf.cc (gen_ctf_type, gen_ctf_void_type) (gen_ctf_unknown_type, gen_ctf_base_type, gen_ctf_pointer_type) (gen_ctf_subrange_type, gen_ctf_array_type, gen_ctf_typedef) (gen_ctf_modifier_type, gen_ctf_sou_type, gen_ctf_function_type) (gen_ctf_enumeration_type, gen_ctf_variable, gen_ctf_function) (gen_ctf_type, ctf_do_die): Likewise. * config/bpf/btfext-out.cc (struct btf_ext_core_reloc): Use pointer instead of type ID. (bpf_core_reloc_add, bpf_core_get_sou_member_index) (output_btfext_core_sections): Adapt to above changes. * config/bpf/core-builtins.cc (process_type): Likewise. include/ * btf.h (BTF_VOID_TYPEID, BTF_INIT_TYPEID): Move defines here, from gcc/btfout.cc. --- gcc/btfout.cc | 40 +++-- gcc/config/bpf/btfext-out.cc | 14 +- gcc/config/bpf/core-builtins.cc | 3 +- gcc/ctfc.cc | 151 +++++++++---------- gcc/ctfc.h | 90 +++++------ gcc/ctfout.cc | 22 ++- gcc/dwarf2ctf.cc | 257 +++++++++++++++----------------- include/btf.h | 5 + 8 files changed, 290 insertions(+), 292 deletions(-) diff --git a/gcc/btfout.cc b/gcc/btfout.cc index d5e9f3bd43d3..9d73478ba9a6 100644 --- a/gcc/btfout.cc +++ b/gcc/btfout.cc @@ -61,11 +61,6 @@ static char btf_info_section_label[MAX_BTF_LABEL_BYTES]; #define BTF_INFO_SECTION_LABEL "Lbtf" #endif -/* BTF encodes void as type id 0. */ - -#define BTF_VOID_TYPEID 0 -#define BTF_INIT_TYPEID 1 - #define BTF_INVALID_TYPEID 0xFFFFFFFF /* Mapping of CTF variables to the IDs they will be assigned when they are @@ -626,7 +621,8 @@ btf_dvd_emit_preprocess_cb (ctf_dvdef_ref *slot, ctf_container_ref arg_ctfc) return 1; /* Do not add variables which refer to unsupported types. */ - if (!voids.contains (var->dvd_type) && btf_removed_type_p (var->dvd_type)) + if (!voids.contains (var->dvd_type->dtd_type) + && btf_removed_type_p (var->dvd_type->dtd_type)) return 1; arg_ctfc->ctfc_vars_list[num_vars_added] = var; @@ -716,7 +712,7 @@ btf_emit_preprocess (ctf_container_ref ctfc) static bool btf_dmd_representable_bitfield_p (ctf_container_ref ctfc, ctf_dmdef_t *dmd) { - ctf_dtdef_ref ref_type = ctfc->ctfc_types_list[dmd->dmd_type]; + ctf_dtdef_ref ref_type = ctfc->ctfc_types_list[dmd->dmd_type->dtd_type]; if (CTF_V2_INFO_KIND (ref_type->dtd_data.ctti_info) == CTF_K_SLICE) { @@ -913,8 +909,8 @@ btf_asm_type (ctf_container_ref ctfc, ctf_dtdef_ref dtd) static void btf_asm_array (ctf_container_ref ctfc, ctf_arinfo_t arr) { - btf_asm_type_ref ("bta_elem_type", ctfc, arr.ctr_contents); - btf_asm_type_ref ("bta_index_type", ctfc, arr.ctr_index); + btf_asm_type_ref ("bta_elem_type", ctfc, arr.ctr_contents->dtd_type); + btf_asm_type_ref ("bta_index_type", ctfc, arr.ctr_index->dtd_type); dw2_asm_output_data (4, arr.ctr_nelems, "bta_nelems"); } @@ -927,7 +923,7 @@ btf_asm_varent (ctf_container_ref ctfc, ctf_dvdef_ref var) (*(btf_var_ids->get (var)) + num_types_added + 1), var->dvd_name); dw2_asm_output_data (4, BTF_TYPE_INFO (BTF_KIND_VAR, 0, 0), "btv_info"); - btf_asm_type_ref ("btv_type", ctfc, var->dvd_type); + btf_asm_type_ref ("btv_type", ctfc, var->dvd_type->dtd_type); dw2_asm_output_data (4, var->dvd_visibility, "btv_linkage"); } @@ -937,8 +933,8 @@ btf_asm_varent (ctf_container_ref ctfc, ctf_dvdef_ref var) static void btf_asm_sou_member (ctf_container_ref ctfc, ctf_dmdef_t * dmd, unsigned int idx) { - ctf_dtdef_ref ref_type = ctfc->ctfc_types_list[dmd->dmd_type]; - ctf_id_t base_type = dmd->dmd_type; + ctf_dtdef_ref ref_type = ctfc->ctfc_types_list[dmd->dmd_type->dtd_type]; + ctf_id_t base_type = dmd->dmd_type->dtd_type; uint64_t sou_offset = dmd->dmd_offset; dw2_asm_output_data (4, dmd->dmd_name_offset, @@ -959,7 +955,7 @@ btf_asm_sou_member (ctf_container_ref ctfc, ctf_dmdef_t * dmd, unsigned int idx) sou_offset |= ((bits & 0xff) << 24); /* Refer to the base type of the slice. */ - base_type = ref_type->dtd_u.dtu_slice.cts_type; + base_type = ref_type->dtd_u.dtu_slice.cts_type->dtd_type; } else { @@ -1003,9 +999,11 @@ btf_asm_func_arg (ctf_container_ref ctfc, ctf_func_arg_t * farg, else dw2_asm_output_data (4, 0, "farg_name"); - btf_asm_type_ref ("farg_type", ctfc, (btf_removed_type_p (farg->farg_type) - ? BTF_VOID_TYPEID - : farg->farg_type)); + ctf_id_t ref_id = BTF_VOID_TYPEID; + if (farg->farg_type && !btf_removed_type_p (farg->farg_type->dtd_type)) + ref_id = farg->farg_type->dtd_type; + + btf_asm_type_ref ("farg_type", ctfc, ref_id); } /* Asm'out a BTF_KIND_FUNC type. */ @@ -1381,7 +1379,7 @@ btf_init_postprocess (void) to create the const modifier type (if needed) now, before making the types list. So we can't avoid iterating with FOR_EACH_VARIABLE here, and then again when creating the DATASEC entries. */ - ctf_id_t constvoid_id = CTF_NULL_TYPEID; + ctf_dtdef_ref constvoid_dtd = NULL; varpool_node *var; FOR_EACH_VARIABLE (var) { @@ -1400,10 +1398,10 @@ btf_init_postprocess (void) continue; /* Create the 'const' modifier type for void. */ - if (constvoid_id == CTF_NULL_TYPEID) - constvoid_id = ctf_add_reftype (tu_ctfc, CTF_ADD_ROOT, - dvd->dvd_type, CTF_K_CONST, NULL); - dvd->dvd_type = constvoid_id; + if (constvoid_dtd == NULL) + constvoid_dtd = ctf_add_reftype (tu_ctfc, CTF_ADD_ROOT, + dvd->dvd_type, CTF_K_CONST, NULL); + dvd->dvd_type = constvoid_dtd; } } diff --git a/gcc/config/bpf/btfext-out.cc b/gcc/config/bpf/btfext-out.cc index 7ec438fd1d10..b3df7b555d5f 100644 --- a/gcc/config/bpf/btfext-out.cc +++ b/gcc/config/bpf/btfext-out.cc @@ -134,7 +134,7 @@ struct GTY ((chain_next ("%h.next"))) btf_ext_lineinfo /* Internal representation of a BPF CO-RE relocation record. */ struct GTY ((chain_next ("%h.next"))) btf_ext_core_reloc { - unsigned int bpfcr_type; /* BTF type ID of container. */ + ctf_dtdef_ref bpfcr_type; /* BTF type involved in relocation. */ unsigned int bpfcr_astr_off; /* Offset of access string in .BTF string table. */ rtx_code_label * bpfcr_insn_label; /* RTX label attached to instruction @@ -296,13 +296,14 @@ bpf_core_reloc_add (const tree type, const char * section_name, struct btf_ext_core_reloc *bpfcr = bpf_create_core_reloc (section_name, &sec); ctf_container_ref ctfc = ctf_get_tu_ctfc (); + ctf_dtdef_ref dtd = ctf_lookup_tree_type (ctfc, type); /* Buffer the access string in the auxiliary strtab. */ bpfcr->bpfcr_astr_off = 0; gcc_assert (accessor != NULL); bpfcr->bpfcr_astr_off = btf_ext_add_string (accessor); - bpfcr->bpfcr_type = get_btf_id (ctf_lookup_tree_type (ctfc, type)); + bpfcr->bpfcr_type = dtd; bpfcr->bpfcr_insn_label = label; bpfcr->bpfcr_kind = kind; @@ -341,7 +342,8 @@ bpf_core_get_sou_member_index (ctf_container_ref ctfc, const tree node) for (dmd = dtd->dtd_u.dtu_members; dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd)) { - bool field_has_btf = get_btf_id (dmd->dmd_type) <= BTF_MAX_TYPE; + bool field_has_btf = (dmd->dmd_type + && dmd->dmd_type->dtd_type <= BTF_MAX_TYPE); if (field == node) return field_has_btf ? i : -1; @@ -574,8 +576,10 @@ output_btfext_core_sections (void) false); char *str = xstrdup (pp_formatted_text (&pp)); - dw2_asm_output_data (4, bpfcr->bpfcr_type, "bpfcr_type (%s)", - str); + uint32_t type_id = bpfcr->bpfcr_type + ? bpfcr->bpfcr_type->dtd_type + : BTF_VOID_TYPEID; + dw2_asm_output_data (4, type_id, "bpfcr_type (%s)", str); dw2_asm_output_data (4, bpfcr->bpfcr_astr_off + str_aux_off, "bpfcr_astr_off (\"%s\")", bpfcr->info.accessor_str); diff --git a/gcc/config/bpf/core-builtins.cc b/gcc/config/bpf/core-builtins.cc index 829acea98f79..232bebcadbd5 100644 --- a/gcc/config/bpf/core-builtins.cc +++ b/gcc/config/bpf/core-builtins.cc @@ -1021,7 +1021,8 @@ process_type (struct cr_builtins *data) && data->default_value != NULL) { ctf_container_ref ctfc = ctf_get_tu_ctfc (); - unsigned int btf_id = get_btf_id (ctf_lookup_tree_type (ctfc, ret.type)); + ctf_dtdef_ref dtd = ctf_lookup_tree_type (ctfc, ret.type); + unsigned int btf_id = dtd ? dtd->dtd_type : BTF_VOID_TYPEID; data->rtx_default_value = expand_normal (build_int_cst (integer_type_node, btf_id)); } diff --git a/gcc/ctfc.cc b/gcc/ctfc.cc index 67711606ab85..8da37f260458 100644 --- a/gcc/ctfc.cc +++ b/gcc/ctfc.cc @@ -373,9 +373,9 @@ ctf_add_cuname (ctf_container_ref ctfc, const char * filename) ctf_dvd_lookup, as applicable, to ascertain that the CTF type or the CTF variable respectively does not already exist, and then add it. */ -static ctf_id_t +static ctf_dtdef_ref ctf_add_generic (ctf_container_ref ctfc, uint32_t flag, const char * name, - ctf_dtdef_ref * rp, dw_die_ref die) + dw_die_ref die) { ctf_dtdef_ref dtd; ctf_id_t type; @@ -397,18 +397,16 @@ ctf_add_generic (ctf_container_ref ctfc, uint32_t flag, const char * name, ctf_dtd_insert (ctfc, dtd); - *rp = dtd; - return type; + return dtd; } -static ctf_id_t +static ctf_dtdef_ref ctf_add_encoded (ctf_container_ref ctfc, uint32_t flag, const char * name, const ctf_encoding_t * ep, uint32_t kind, dw_die_ref die) { ctf_dtdef_ref dtd; - ctf_id_t type; - type = ctf_add_generic (ctfc, flag, name, &dtd, die); + dtd = ctf_add_generic (ctfc, flag, name, die); dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, flag, 0); @@ -424,83 +422,79 @@ ctf_add_encoded (ctf_container_ref ctfc, uint32_t flag, const char * name, ctfc->ctfc_num_stypes++; - return type; + return dtd; } -ctf_id_t -ctf_add_reftype (ctf_container_ref ctfc, uint32_t flag, ctf_id_t ref, +ctf_dtdef_ref +ctf_add_reftype (ctf_container_ref ctfc, uint32_t flag, ctf_dtdef_ref ref, uint32_t kind, dw_die_ref die) { ctf_dtdef_ref dtd; - ctf_id_t type; - gcc_assert (ref <= CTF_MAX_TYPE); + gcc_assert (ref != NULL); - type = ctf_add_generic (ctfc, flag, NULL, &dtd, die); + dtd = ctf_add_generic (ctfc, flag, NULL, die); dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, flag, 0); /* Caller of this API must guarantee that a CTF type with id = ref already exists. This will also be validated for us at link-time. */ - dtd->dtd_data.ctti_type = (uint32_t) ref; + dtd->dtd_data.ctti_type = (uint32_t) ref->dtd_type; + dtd->ref_type = ref; ctfc->ctfc_num_stypes++; - return type; + return dtd; } -ctf_id_t +ctf_dtdef_ref ctf_add_forward (ctf_container_ref ctfc, uint32_t flag, const char * name, uint32_t kind, dw_die_ref die) { ctf_dtdef_ref dtd; - ctf_id_t type = 0; - type = ctf_add_generic (ctfc, flag, name, &dtd, die); + dtd = ctf_add_generic (ctfc, flag, name, die); dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_FORWARD, flag, 0); dtd->dtd_data.ctti_type = kind; ctfc->ctfc_num_stypes++; - return type; + return dtd; } -ctf_id_t +ctf_dtdef_ref ctf_add_typedef (ctf_container_ref ctfc, uint32_t flag, const char * name, - ctf_id_t ref, dw_die_ref die) + ctf_dtdef_ref ref, dw_die_ref die) { ctf_dtdef_ref dtd; - ctf_id_t type; - gcc_assert (ref <= CTF_MAX_TYPE); + gcc_assert (ref != NULL); /* Nameless Typedefs are not expected. */ gcc_assert ((name != NULL) && strcmp (name, "")); - type = ctf_add_generic (ctfc, flag, name, &dtd, die); + dtd = ctf_add_generic (ctfc, flag, name, die); dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_TYPEDEF, flag, 0); - /* Caller of this API must guarantee that a CTF type with id = ref already - exists. This will also be validated for us at link-time. */ - dtd->dtd_data.ctti_type = (uint32_t) ref; + dtd->dtd_data.ctti_type = (uint32_t) ref->dtd_type; + dtd->ref_type = ref; gcc_assert (dtd->dtd_type != dtd->dtd_data.ctti_type); ctfc->ctfc_num_stypes++; - return type; + return dtd; } -ctf_id_t -ctf_add_slice (ctf_container_ref ctfc, uint32_t flag, ctf_id_t ref, +ctf_dtdef_ref +ctf_add_slice (ctf_container_ref ctfc, uint32_t flag, ctf_dtdef_ref ref, uint32_t bit_offset, uint32_t bit_size, dw_die_ref die) { ctf_dtdef_ref dtd; - ctf_id_t type; uint32_t roundup_nbytes; gcc_assert ((bit_size <= 255) && (bit_offset <= 255)); - gcc_assert (ref <= CTF_MAX_TYPE); + gcc_assert (ref != NULL); - type = ctf_add_generic (ctfc, flag, NULL, &dtd, die); + dtd = ctf_add_generic (ctfc, flag, NULL, die); dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_SLICE, flag, 0); @@ -512,51 +506,48 @@ ctf_add_slice (ctf_container_ref ctfc, uint32_t flag, ctf_id_t ref, dtd->dtd_data.ctti_size = roundup_nbytes ? (1 << ceil_log2 (roundup_nbytes)) : 0; - /* Caller of this API must guarantee that a CTF type with id = ref already - exists. This will also be validated for us at link-time. */ - dtd->dtd_u.dtu_slice.cts_type = (uint32_t) ref; + dtd->dtd_u.dtu_slice.cts_type = ref; dtd->dtd_u.dtu_slice.cts_bits = bit_size; dtd->dtd_u.dtu_slice.cts_offset = bit_offset; ctfc->ctfc_num_stypes++; - return type; + return dtd; } -ctf_id_t +ctf_dtdef_ref ctf_add_float (ctf_container_ref ctfc, uint32_t flag, const char * name, const ctf_encoding_t * ep, dw_die_ref die) { return (ctf_add_encoded (ctfc, flag, name, ep, CTF_K_FLOAT, die)); } -ctf_id_t +ctf_dtdef_ref ctf_add_integer (ctf_container_ref ctfc, uint32_t flag, const char * name, const ctf_encoding_t * ep, dw_die_ref die) { return (ctf_add_encoded (ctfc, flag, name, ep, CTF_K_INTEGER, die)); } -ctf_id_t +ctf_dtdef_ref ctf_add_unknown (ctf_container_ref ctfc, uint32_t flag, const char * name, const ctf_encoding_t * ep, dw_die_ref die) { return (ctf_add_encoded (ctfc, flag, name, ep, CTF_K_UNKNOWN, die)); } -ctf_id_t -ctf_add_pointer (ctf_container_ref ctfc, uint32_t flag, ctf_id_t ref, +ctf_dtdef_ref +ctf_add_pointer (ctf_container_ref ctfc, uint32_t flag, ctf_dtdef_ref ref, dw_die_ref die) { return (ctf_add_reftype (ctfc, flag, ref, CTF_K_POINTER, die)); } -ctf_id_t +ctf_dtdef_ref ctf_add_array (ctf_container_ref ctfc, uint32_t flag, const ctf_arinfo_t * arp, dw_die_ref die) { ctf_dtdef_ref dtd; - ctf_id_t type; gcc_assert (arp); @@ -564,7 +555,7 @@ ctf_add_array (ctf_container_ref ctfc, uint32_t flag, const ctf_arinfo_t * arp, arp->ctr_index are already added. This will also be validated for us at link-time. */ - type = ctf_add_generic (ctfc, flag, NULL, &dtd, die); + dtd = ctf_add_generic (ctfc, flag, NULL, die); dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_ARRAY, flag, 0); dtd->dtd_data.ctti_size = 0; @@ -572,15 +563,14 @@ ctf_add_array (ctf_container_ref ctfc, uint32_t flag, const ctf_arinfo_t * arp, ctfc->ctfc_num_stypes++; - return type; + return dtd; } -ctf_id_t +ctf_dtdef_ref ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, const char * name, HOST_WIDE_INT size, bool eunsigned, dw_die_ref die) { ctf_dtdef_ref dtd; - ctf_id_t type; /* In the compiler, no need to handle the case of promoting forwards to enums. This comment is simply to note a divergence from libctf. */ @@ -595,7 +585,7 @@ ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, const char * name, = CTF_TYPE_INFO (CTF_K_FORWARD, CTF_ADD_NONROOT, 0); } - type = ctf_add_generic (ctfc, flag, name, &dtd, die); + dtd = ctf_add_generic (ctfc, flag, name, die); dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_ENUM, flag, 0); @@ -608,21 +598,21 @@ ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, const char * name, ctfc->ctfc_num_stypes++; - return type; + return dtd; } int -ctf_add_enumerator (ctf_container_ref ctfc, ctf_id_t enid, const char * name, - HOST_WIDE_INT value, dw_die_ref die) +ctf_add_enumerator (ctf_container_ref ctfc, ctf_dtdef_ref enum_dtd, + const char * name, HOST_WIDE_INT value, dw_die_ref die) { ctf_dmdef_t * dmd; uint32_t kind, vlen, root; - /* Callers of this API must make sure that CTF_K_ENUM with enid has been - addded. This will also be validated for us at link-time. */ + /* The associated CTF type of kind CTF_K_ENUM must already exist. + This will also be validated for us at link-time. */ ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, die); gcc_assert (dtd); - gcc_assert (dtd->dtd_type == enid); + gcc_assert (dtd == enum_dtd); gcc_assert (name); kind = CTF_V2_INFO_KIND (dtd->dtd_data.ctti_info); @@ -646,7 +636,7 @@ ctf_add_enumerator (ctf_container_ref ctfc, ctf_id_t enid, const char * name, /* Buffer the strings in the CTF string table. */ dmd->dmd_name = ctf_add_string (ctfc, name, &(dmd->dmd_name_offset)); - dmd->dmd_type = CTF_NULL_TYPEID; + dmd->dmd_type = NULL; dmd->dmd_offset = 0; dmd->dmd_value = value; @@ -662,7 +652,7 @@ ctf_add_enumerator (ctf_container_ref ctfc, ctf_id_t enid, const char * name, int ctf_add_member_offset (ctf_container_ref ctfc, dw_die_ref sou, - const char * name, ctf_id_t type, + const char * name, ctf_dtdef_ref type, uint64_t bit_offset) { ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, sou); @@ -702,7 +692,7 @@ ctf_add_member_offset (ctf_container_ref ctfc, dw_die_ref sou, } int -ctf_add_variable (ctf_container_ref ctfc, const char * name, ctf_id_t ref, +ctf_add_variable (ctf_container_ref ctfc, const char * name, ctf_dtdef_ref ref, dw_die_ref die, unsigned int external_vis, dw_die_ref die_var_decl) { @@ -747,16 +737,16 @@ ctf_add_variable (ctf_container_ref ctfc, const char * name, ctf_id_t ref, int ctf_add_function_arg (ctf_container_ref ctfc, dw_die_ref func, - const char * name, ctf_id_t type) + const char * name, ctf_dtdef_ref arg_dtd) { - ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, func); + ctf_dtdef_ref func_dtd = ctf_dtd_lookup (ctfc, func); ctf_func_arg_t * farg; uint32_t vlen; /* The function to which argument is being added must already exist. */ - gcc_assert (dtd); + gcc_assert (func_dtd); /* The number of args must have been non-zero. */ - vlen = CTF_V2_INFO_VLEN (dtd->dtd_data.ctti_info); + vlen = CTF_V2_INFO_VLEN (func_dtd->dtd_data.ctti_info); gcc_assert (vlen); farg = ggc_cleared_alloc (); @@ -766,9 +756,9 @@ ctf_add_function_arg (ctf_container_ref ctfc, dw_die_ref func, these strings to avoid unnecessary bloat in CTF section in CTF V3. */ farg->farg_name = ctf_add_string (ctfc, name, &(farg->farg_name_offset), CTF_AUX_STRTAB); - farg->farg_type = type; + farg->farg_type = arg_dtd; - ctf_farg_list_append (&dtd->dtd_u.dtu_argv, farg); + ctf_farg_list_append (&func_dtd->dtd_u.dtu_argv, farg); /* For aux_str, keep ctfc_aux_strlen updated for debugging. */ if ((name != NULL) && strcmp (name, "")) @@ -777,13 +767,12 @@ ctf_add_function_arg (ctf_container_ref ctfc, dw_die_ref func, return 0; } -ctf_id_t +ctf_dtdef_ref ctf_add_function (ctf_container_ref ctfc, uint32_t flag, const char * name, const ctf_funcinfo_t * ctc, dw_die_ref die, bool from_global_func, int linkage) { ctf_dtdef_ref dtd; - ctf_id_t type; uint32_t vlen; gcc_assert (ctc); @@ -791,27 +780,27 @@ ctf_add_function (ctf_container_ref ctfc, uint32_t flag, const char * name, vlen = ctc->ctc_argc; gcc_assert (vlen <= CTF_MAX_VLEN); - type = ctf_add_generic (ctfc, flag, name, &dtd, die); + dtd = ctf_add_generic (ctfc, flag, name, die); dtd->from_global_func = from_global_func; dtd->linkage = linkage; dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_FUNCTION, flag, vlen); + dtd->ref_type = ctc->ctc_return; /* Caller must make sure CTF types for ctc->ctc_return are already added. */ - dtd->dtd_data.ctti_type = (uint32_t) ctc->ctc_return; + dtd->dtd_data.ctti_type = (uint32_t) ctc->ctc_return->dtd_type; /* Caller must make sure CTF types for function arguments are already added via ctf_add_function_arg () API. */ ctfc->ctfc_num_stypes++; - return type; + return dtd; } -ctf_id_t +ctf_dtdef_ref ctf_add_sou (ctf_container_ref ctfc, uint32_t flag, const char * name, uint32_t kind, size_t size, dw_die_ref die) { ctf_dtdef_ref dtd; - ctf_id_t type = 0; gcc_assert ((kind == CTF_K_STRUCT) || (kind == CTF_K_UNION)); @@ -828,7 +817,7 @@ ctf_add_sou (ctf_container_ref ctfc, uint32_t flag, const char * name, = CTF_TYPE_INFO (CTF_K_FORWARD, CTF_ADD_NONROOT, 0); } - type = ctf_add_generic (ctfc, flag, name, &dtd, die); + dtd = ctf_add_generic (ctfc, flag, name, die); dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, flag, 0); @@ -845,32 +834,32 @@ ctf_add_sou (ctf_container_ref ctfc, uint32_t flag, const char * name, ctfc->ctfc_num_stypes++; } - return type; + return dtd; } -/* Given a TREE_TYPE node, return the CTF type ID for that type. */ +/* Given a TREE_TYPE node, return the CTF type object for that type. */ -ctf_id_t +ctf_dtdef_ref ctf_lookup_tree_type (ctf_container_ref ctfc, const tree type) { dw_die_ref die = lookup_type_die (type); if (die == NULL) - return CTF_NULL_TYPEID; + return NULL; ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, die); if (dtd == NULL) - return CTF_NULL_TYPEID; + return NULL; - return dtd->dtd_type; + return dtd; } /* Check if CTF for TYPE has already been generated. Mainstay for de-duplication. If CTF type already exists, returns TRUE and updates - the TYPE_ID for the caller. */ + the CTF type object DTD for the caller. */ bool ctf_type_exists (ctf_container_ref ctfc, dw_die_ref type, - ctf_id_t * type_id) + ctf_dtdef_ref * dtd) { bool exists = false; ctf_dtdef_ref ctf_type_seen = ctf_dtd_lookup (ctfc, type); @@ -879,7 +868,7 @@ ctf_type_exists (ctf_container_ref ctfc, dw_die_ref type, { exists = true; /* CTF type for this type exists. */ - *type_id = ctf_type_seen->dtd_type; + *dtd = ctf_type_seen; } return exists; diff --git a/gcc/ctfc.h b/gcc/ctfc.h index e7bd93901cfa..b2060eaf7e9b 100644 --- a/gcc/ctfc.h +++ b/gcc/ctfc.h @@ -48,6 +48,10 @@ along with GCC; see the file COPYING3. If not see typedef uint64_t ctf_id_t; +struct ctf_dtdef; +typedef struct ctf_dtdef ctf_dtdef_t; +typedef ctf_dtdef_t * ctf_dtdef_ref; + /* CTF string table element (list node). */ typedef struct GTY ((chain_next ("%h.cts_next"))) ctf_string @@ -81,8 +85,8 @@ typedef struct GTY (()) ctf_encoding typedef struct GTY (()) ctf_arinfo { - ctf_id_t ctr_contents; /* Type of array contents. */ - ctf_id_t ctr_index; /* Type of array index. */ + ctf_dtdef_ref ctr_contents; /* Type of array contents. */ + ctf_dtdef_ref ctr_index; /* Type of array index. */ unsigned int ctr_nelems; /* Number of elements. */ } ctf_arinfo_t; @@ -90,14 +94,14 @@ typedef struct GTY (()) ctf_arinfo typedef struct GTY (()) ctf_funcinfo { - ctf_id_t ctc_return; /* Function return type. */ - unsigned int ctc_argc; /* Number of typed arguments to function. */ - unsigned int ctc_flags; /* Function attributes (see below). */ + ctf_dtdef_ref ctc_return; /* Function return type. */ + unsigned int ctc_argc; /* Number of typed arguments to function. */ + unsigned int ctc_flags; /* Function attributes (see below). */ } ctf_funcinfo_t; typedef struct GTY (()) ctf_sliceinfo { - unsigned int cts_type; /* Reference CTF type. */ + ctf_dtdef_ref cts_type; /* Reference CTF type. */ unsigned short cts_offset; /* Offset in bits of the first bit. */ unsigned short cts_bits; /* Size in bits. */ } ctf_sliceinfo_t; @@ -130,7 +134,7 @@ typedef struct GTY (()) ctf_itype typedef struct GTY ((chain_next ("%h.dmd_next"))) ctf_dmdef { const char * dmd_name; /* Name of this member. */ - ctf_id_t dmd_type; /* Type of this member (for sou). */ + ctf_dtdef_ref dmd_type; /* Type of this member (for sou). */ uint32_t dmd_name_offset; /* Offset of the name in str table. */ uint64_t dmd_offset; /* Offset of this member in bits (for sou). */ HOST_WIDE_INT dmd_value; /* Value of this member (for enum). */ @@ -143,7 +147,7 @@ typedef struct GTY ((chain_next ("%h.dmd_next"))) ctf_dmdef typedef struct GTY (()) ctf_func_arg { - ctf_id_t farg_type; /* Type identifier of the argument. */ + ctf_dtdef_ref farg_type; /* Type of the argument. */ const char * farg_name; /* Name of the argument. */ uint32_t farg_name_offset; /* Offset of the name in str table. */ struct ctf_func_arg * farg_next;/* A list node. */ @@ -158,6 +162,7 @@ struct GTY ((for_user)) ctf_dtdef dw_die_ref dtd_key; /* Type key for hashing. */ const char * dtd_name; /* Name associated with definition (if any). */ ctf_id_t dtd_type; /* Type identifier for this definition. */ + ctf_dtdef_ref ref_type; /* Type referred to by this type (if any). */ ctf_itype_t dtd_data; /* Type node. */ bool from_global_func; /* Whether this type was added from a global function. */ @@ -178,7 +183,7 @@ struct GTY ((for_user)) ctf_dtdef } dtd_u; }; -typedef struct ctf_dtdef ctf_dtdef_t; +#define ctf_type_id(dtd) ((uint32_t) dtd->dtd_type) /* Variable definition for CTF generation. */ @@ -188,13 +193,11 @@ struct GTY ((for_user)) ctf_dvdef const char * dvd_name; /* Name associated with variable. */ uint32_t dvd_name_offset; /* Offset of the name in str table. */ unsigned int dvd_visibility; /* External visibility. 0=static,1=global. */ - ctf_id_t dvd_type; /* Type of variable. */ + ctf_dtdef_ref dvd_type; /* Type of variable. */ }; typedef struct ctf_dvdef ctf_dvdef_t; - typedef ctf_dvdef_t * ctf_dvdef_ref; -typedef ctf_dtdef_t * ctf_dtdef_ref; /* Location information for CTF Types and CTF Variables. */ @@ -390,7 +393,7 @@ extern void btf_finalize (void); extern ctf_container_ref ctf_get_tu_ctfc (void); -extern bool ctf_type_exists (ctf_container_ref, dw_die_ref, ctf_id_t *); +extern bool ctf_type_exists (ctf_container_ref, dw_die_ref, ctf_dtdef_ref *); extern void ctf_add_cuname (ctf_container_ref, const char *); @@ -404,41 +407,42 @@ extern bool ctf_dvd_ignore_lookup (const ctf_container_ref ctfc, extern const char * ctf_add_string (ctf_container_ref, const char *, uint32_t *, int); -extern ctf_id_t ctf_add_reftype (ctf_container_ref, uint32_t, ctf_id_t, - uint32_t, dw_die_ref); -extern ctf_id_t ctf_add_enum (ctf_container_ref, uint32_t, const char *, - HOST_WIDE_INT, bool, dw_die_ref); -extern ctf_id_t ctf_add_slice (ctf_container_ref, uint32_t, ctf_id_t, - uint32_t, uint32_t, dw_die_ref); -extern ctf_id_t ctf_add_float (ctf_container_ref, uint32_t, const char *, - const ctf_encoding_t *, dw_die_ref); -extern ctf_id_t ctf_add_integer (ctf_container_ref, uint32_t, const char *, - const ctf_encoding_t *, dw_die_ref); -extern ctf_id_t ctf_add_unknown (ctf_container_ref, uint32_t, const char *, - const ctf_encoding_t *, dw_die_ref); -extern ctf_id_t ctf_add_pointer (ctf_container_ref, uint32_t, ctf_id_t, - dw_die_ref); -extern ctf_id_t ctf_add_array (ctf_container_ref, uint32_t, - const ctf_arinfo_t *, dw_die_ref); -extern ctf_id_t ctf_add_forward (ctf_container_ref, uint32_t, const char *, - uint32_t, dw_die_ref); -extern ctf_id_t ctf_add_typedef (ctf_container_ref, uint32_t, const char *, - ctf_id_t, dw_die_ref); -extern ctf_id_t ctf_add_function (ctf_container_ref, uint32_t, const char *, - const ctf_funcinfo_t *, dw_die_ref, bool, int); -extern ctf_id_t ctf_add_sou (ctf_container_ref, uint32_t, const char *, - uint32_t, size_t, dw_die_ref); - -extern int ctf_add_enumerator (ctf_container_ref, ctf_id_t, const char *, +extern ctf_dtdef_ref ctf_add_reftype (ctf_container_ref, uint32_t, + ctf_dtdef_ref, uint32_t, dw_die_ref); +extern ctf_dtdef_ref ctf_add_enum (ctf_container_ref, uint32_t, const char *, + HOST_WIDE_INT, bool, dw_die_ref); +extern ctf_dtdef_ref ctf_add_slice (ctf_container_ref, uint32_t, ctf_dtdef_ref, + uint32_t, uint32_t, dw_die_ref); +extern ctf_dtdef_ref ctf_add_float (ctf_container_ref, uint32_t, const char *, + const ctf_encoding_t *, dw_die_ref); +extern ctf_dtdef_ref ctf_add_integer (ctf_container_ref, uint32_t, const char *, + const ctf_encoding_t *, dw_die_ref); +extern ctf_dtdef_ref ctf_add_unknown (ctf_container_ref, uint32_t, const char *, + const ctf_encoding_t *, dw_die_ref); +extern ctf_dtdef_ref ctf_add_pointer (ctf_container_ref, uint32_t, + ctf_dtdef_ref, dw_die_ref); +extern ctf_dtdef_ref ctf_add_array (ctf_container_ref, uint32_t, + const ctf_arinfo_t *, dw_die_ref); +extern ctf_dtdef_ref ctf_add_forward (ctf_container_ref, uint32_t, const char *, + uint32_t, dw_die_ref); +extern ctf_dtdef_ref ctf_add_typedef (ctf_container_ref, uint32_t, const char *, + ctf_dtdef_ref, dw_die_ref); +extern ctf_dtdef_ref ctf_add_function (ctf_container_ref, uint32_t, + const char *, const ctf_funcinfo_t *, + dw_die_ref, bool, int); +extern ctf_dtdef_ref ctf_add_sou (ctf_container_ref, uint32_t, const char *, + uint32_t, size_t, dw_die_ref); + +extern int ctf_add_enumerator (ctf_container_ref, ctf_dtdef_ref, const char *, HOST_WIDE_INT, dw_die_ref); extern int ctf_add_member_offset (ctf_container_ref, dw_die_ref, const char *, - ctf_id_t, uint64_t); + ctf_dtdef_ref, uint64_t); extern int ctf_add_function_arg (ctf_container_ref, dw_die_ref, - const char *, ctf_id_t); -extern int ctf_add_variable (ctf_container_ref, const char *, ctf_id_t, + const char *, ctf_dtdef_ref); +extern int ctf_add_variable (ctf_container_ref, const char *, ctf_dtdef_ref, dw_die_ref, unsigned int, dw_die_ref); -extern ctf_id_t ctf_lookup_tree_type (ctf_container_ref, const tree); +extern ctf_dtdef_ref ctf_lookup_tree_type (ctf_container_ref, const tree); extern ctf_id_t get_btf_id (ctf_id_t); typedef bool (*funcs_traverse_callback) (ctf_dtdef_ref, void *); diff --git a/gcc/ctfout.cc b/gcc/ctfout.cc index ee082b5fd016..157afbac4f48 100644 --- a/gcc/ctfout.cc +++ b/gcc/ctfout.cc @@ -380,7 +380,8 @@ ctf_asm_type (ctf_dtdef_ref type) static void ctf_asm_slice (ctf_dtdef_ref type) { - dw2_asm_output_data (4, type->dtd_u.dtu_slice.cts_type, "cts_type"); + dw2_asm_output_data (4, ctf_type_id (type->dtd_u.dtu_slice.cts_type), + "cts_type"); dw2_asm_output_data (2, type->dtd_u.dtu_slice.cts_offset, "cts_offset"); dw2_asm_output_data (2, type->dtd_u.dtu_slice.cts_bits, "cts_bits"); } @@ -390,8 +391,10 @@ ctf_asm_slice (ctf_dtdef_ref type) static void ctf_asm_array (ctf_dtdef_ref dtd) { - dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_contents, "cta_contents"); - dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_index, "cta_index"); + dw2_asm_output_data (4, ctf_type_id (dtd->dtd_u.dtu_arr.ctr_contents), + "cta_contents"); + dw2_asm_output_data (4, ctf_type_id (dtd->dtd_u.dtu_arr.ctr_index), + "cta_index"); dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_nelems, "cta_nelems"); } @@ -403,7 +406,7 @@ ctf_asm_varent (ctf_dvdef_ref var) /* Output the reference to the name in the string table. */ dw2_asm_output_data (4, var->dvd_name_offset, "ctv_name"); /* Output the type index. */ - dw2_asm_output_data (4, var->dvd_type, "ctv_typeidx"); + dw2_asm_output_data (4, ctf_type_id (var->dvd_type), "ctv_typeidx"); } /* Asm'out a member of CTF struct or union, represented by ctf_lmember_t. */ @@ -414,7 +417,7 @@ ctf_asm_sou_lmember (ctf_dmdef_t * dmd) dw2_asm_output_data (4, dmd->dmd_name_offset, "ctlm_name"); dw2_asm_output_data (4, CTF_OFFSET_TO_LMEMHI (dmd->dmd_offset), "ctlm_offsethi"); - dw2_asm_output_data (4, dmd->dmd_type, "ctlm_type"); + dw2_asm_output_data (4, ctf_type_id (dmd->dmd_type), "ctlm_type"); dw2_asm_output_data (4, CTF_OFFSET_TO_LMEMLO (dmd->dmd_offset), "ctlm_offsetlo"); } @@ -426,7 +429,7 @@ ctf_asm_sou_member (ctf_dmdef_t * dmd) { dw2_asm_output_data (4, dmd->dmd_name_offset, "ctm_name"); dw2_asm_output_data (4, dmd->dmd_offset, "ctm_offset"); - dw2_asm_output_data (4, dmd->dmd_type, "ctm_type"); + dw2_asm_output_data (4, ctf_type_id (dmd->dmd_type), "ctm_type"); } /* Asm'out an enumerator constant. */ @@ -443,7 +446,10 @@ ctf_asm_enum_const (ctf_dmdef_t * dmd) static void ctf_asm_func_arg (ctf_func_arg_t * farg) { - dw2_asm_output_data (4, farg->farg_type, "dtu_argv"); + /* farg_type may be NULL, indicating varargs. */ + dw2_asm_output_data (4, farg->farg_type + ? ctf_type_id (farg->farg_type) + : 0, "dtu_argv"); } /* CTF writeout to asm file. */ @@ -537,7 +543,7 @@ output_ctf_obj_info (ctf_container_ref ctfc) var = ctfc->ctfc_gobjts_list[i]; /* CTF type ID corresponding to the type of the variable. */ - dw2_asm_output_data (4, var->dvd_type, "objtinfo_var_type"); + dw2_asm_output_data (4, ctf_type_id (var->dvd_type), "objtinfo_var_type"); } } diff --git a/gcc/dwarf2ctf.cc b/gcc/dwarf2ctf.cc index 8f9e2fada9e3..00b876e2fe2c 100644 --- a/gcc/dwarf2ctf.cc +++ b/gcc/dwarf2ctf.cc @@ -29,7 +29,7 @@ along with GCC; see the file COPYING3. If not see /* Forward declarations for some routines defined in this file. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_type (ctf_container_ref, dw_die_ref); /* All the DIE structures we handle come from the DWARF information @@ -156,7 +156,7 @@ ctf_get_die_loc_col (dw_die_ref die) /* Generate CTF for the void type. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_void_type (ctf_container_ref ctfc) { ctf_encoding_t ctf_encoding = {0, 0, 0}; @@ -174,10 +174,10 @@ gen_ctf_void_type (ctf_container_ref ctfc) /* Generate CTF type of unknown kind. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_unknown_type (ctf_container_ref ctfc) { - ctf_id_t unknown_type_id; + ctf_dtdef_ref dtd; /* In CTF, the unknown type is encoded as a 0 byte sized type with kind CTF_K_UNKNOWN. Create an encoding object merely to reuse the underlying @@ -187,11 +187,11 @@ gen_ctf_unknown_type (ctf_container_ref ctfc) gcc_assert (ctf_unknown_die != NULL); /* Type de-duplication. */ - if (!ctf_type_exists (ctfc, ctf_unknown_die, &unknown_type_id)) - unknown_type_id = ctf_add_unknown (ctfc, CTF_ADD_ROOT, "unknown", - &ctf_encoding, ctf_unknown_die); + if (!ctf_type_exists (ctfc, ctf_unknown_die, &dtd)) + dtd = ctf_add_unknown (ctfc, CTF_ADD_ROOT, "unknown", + &ctf_encoding, ctf_unknown_die); - return unknown_type_id; + return dtd; } /* Sizes of entities can be given in bytes or bits. This function @@ -217,10 +217,10 @@ ctf_die_bitsize (dw_die_ref die) Important: the caller of this API must make sure that duplicate types are not added. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type) { - ctf_id_t type_id = CTF_NULL_TYPEID; + ctf_dtdef_ref dtd = NULL; ctf_encoding_t ctf_encoding = {0, 0, 0}; @@ -236,8 +236,8 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type) ctf_encoding.cte_bits = 0; gcc_assert (name_string); - type_id = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string, - &ctf_encoding, type); + dtd = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string, + &ctf_encoding, type); break; case DW_ATE_boolean: @@ -246,8 +246,8 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type) ctf_encoding.cte_bits = bit_size; gcc_assert (name_string); - type_id = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string, - &ctf_encoding, type); + dtd = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string, + &ctf_encoding, type); break; case DW_ATE_float: { @@ -269,7 +269,7 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type) break; ctf_encoding.cte_bits = bit_size; - type_id = ctf_add_float (ctfc, CTF_ADD_ROOT, name_string, + dtd = ctf_add_float (ctfc, CTF_ADD_ROOT, name_string, &ctf_encoding, type); break; @@ -291,7 +291,7 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type) ctf_encoding.cte_format |= CTF_INT_SIGNED; ctf_encoding.cte_bits = bit_size; - type_id = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string, + dtd = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string, &ctf_encoding, type); break; @@ -315,7 +315,7 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type) break; ctf_encoding.cte_bits = bit_size; - type_id = ctf_add_float (ctfc, CTF_ADD_ROOT, name_string, + dtd = ctf_add_float (ctfc, CTF_ADD_ROOT, name_string, &ctf_encoding, type); break; } @@ -324,41 +324,40 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type) break; } - return type_id; + return dtd; } /* Generate CTF for a pointer type. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_pointer_type (ctf_container_ref ctfc, dw_die_ref ptr_type) { - ctf_id_t type_id = CTF_NULL_TYPEID; - ctf_id_t ptr_type_id = CTF_NULL_TYPEID; + ctf_dtdef_ref pointed_dtd, pointer_dtd; dw_die_ref pointed_type_die = ctf_get_AT_type (ptr_type); - type_id = gen_ctf_type (ctfc, pointed_type_die); + pointed_dtd = gen_ctf_type (ctfc, pointed_type_die); /* Type de-duplication. Consult the ctfc_types hash again before adding the CTF pointer type because there can be cases where a pointer type may have been added by the gen_ctf_type call above. */ - if (ctf_type_exists (ctfc, ptr_type, &ptr_type_id)) - return ptr_type_id; + if (!ctf_type_exists (ctfc, ptr_type, &pointer_dtd)) + pointer_dtd = ctf_add_pointer (ctfc, CTF_ADD_ROOT, pointed_dtd, ptr_type); - ptr_type_id = ctf_add_pointer (ctfc, CTF_ADD_ROOT, type_id, ptr_type); - return ptr_type_id; + return pointer_dtd; } /* Recursively generate CTF for array dimensions starting at DIE C (of type DW_TAG_subrange_type) until DIE LAST (of type DW_TAG_subrange_type) is - reached. ARRAY_ELEMS_TYPE_ID is base type for the array. */ + reached. ARRAY_ELEMS_TYPE is the CTF type object for the type of the + array elements. */ -static ctf_id_t -gen_ctf_subrange_type (ctf_container_ref ctfc, ctf_id_t array_elems_type_id, +static ctf_dtdef_ref +gen_ctf_subrange_type (ctf_container_ref ctfc, ctf_dtdef_ref array_elems_type, dw_die_ref c, dw_die_ref last) { ctf_arinfo_t arinfo; - ctf_id_t array_node_type_id = CTF_NULL_TYPEID; + ctf_dtdef_ref array_dtd; dw_attr_node *upper_bound_at; dw_die_ref array_index_type; @@ -398,30 +397,29 @@ gen_ctf_subrange_type (ctf_container_ref ctfc, ctf_id_t array_elems_type_id, arinfo.ctr_index = gen_ctf_type (ctfc, array_index_type); if (c == last) - arinfo.ctr_contents = array_elems_type_id; + arinfo.ctr_contents = array_elems_type; else - arinfo.ctr_contents = gen_ctf_subrange_type (ctfc, array_elems_type_id, + arinfo.ctr_contents = gen_ctf_subrange_type (ctfc, array_elems_type, dw_get_die_sib (c), last); - if (!ctf_type_exists (ctfc, c, &array_node_type_id)) - array_node_type_id = ctf_add_array (ctfc, CTF_ADD_ROOT, &arinfo, c); + if (!ctf_type_exists (ctfc, c, &array_dtd)) + array_dtd = ctf_add_array (ctfc, CTF_ADD_ROOT, &arinfo, c); - return array_node_type_id; + return array_dtd; } /* Generate CTF for an ARRAY_TYPE. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_array_type (ctf_container_ref ctfc, dw_die_ref array_type) { dw_die_ref first, last, array_elems_type; - ctf_id_t array_elems_type_id = CTF_NULL_TYPEID; - ctf_id_t array_type_id = CTF_NULL_TYPEID; + ctf_dtdef_ref array_dtd, elem_dtd; int vector_type_p = get_AT_flag (array_type, DW_AT_GNU_vector); if (vector_type_p) - return array_elems_type_id; + return NULL; /* Find the first and last array dimension DIEs. */ last = dw_get_die_child (array_type); @@ -429,41 +427,36 @@ gen_ctf_array_type (ctf_container_ref ctfc, /* Type de-duplication. Consult the ctfc_types before adding CTF type for the first dimension. */ - if (!ctf_type_exists (ctfc, first, &array_type_id)) + if (!ctf_type_exists (ctfc, first, &array_dtd)) { array_elems_type = ctf_get_AT_type (array_type); /* First, register the type of the array elements if needed. */ - array_elems_type_id = gen_ctf_type (ctfc, array_elems_type); + elem_dtd = gen_ctf_type (ctfc, array_elems_type); - array_type_id = gen_ctf_subrange_type (ctfc, array_elems_type_id, first, - last); + array_dtd = gen_ctf_subrange_type (ctfc, elem_dtd, first, last); } - return array_type_id; + return array_dtd; } /* Generate CTF for a typedef. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_typedef (ctf_container_ref ctfc, dw_die_ref tdef) { - ctf_id_t tdef_type_id, tid; + ctf_dtdef_ref tdef_dtd, dtd; const char *tdef_name = get_AT_string (tdef, DW_AT_name); dw_die_ref tdef_type = ctf_get_AT_type (tdef); - tid = gen_ctf_type (ctfc, tdef_type); + dtd = gen_ctf_type (ctfc, tdef_type); /* Type de-duplication. This is necessary because the ctf for the typedef may have been already added due to the gen_ctf_type call above. */ - if (!ctf_type_exists (ctfc, tdef, &tdef_type_id)) - { - tdef_type_id = ctf_add_typedef (ctfc, CTF_ADD_ROOT, - tdef_name, - tid, - tdef); - } - return tdef_type_id; + if (!ctf_type_exists (ctfc, tdef, &tdef_dtd)) + tdef_dtd = ctf_add_typedef (ctfc, CTF_ADD_ROOT, tdef_name, dtd, tdef); + + return tdef_dtd; } /* Generate CTF for a type modifier. @@ -472,14 +465,16 @@ gen_ctf_typedef (ctf_container_ref ctfc, dw_die_ref tdef) supported by CTF, then this function skips the modifier die and continues with the underlying type. - For all other cases, this function returns a CTF_NULL_TYPEID; -*/ + If the modifier is supported by CTF, then this function constructs and + returns an appropate CTF type representing the modifier. + + For all other cases, this function returns NULL. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_modifier_type (ctf_container_ref ctfc, dw_die_ref modifier) { uint32_t kind = CTF_K_MAX; - ctf_id_t modifier_type_id, qual_type_id; + ctf_dtdef_ref dtd, modifier_dtd; dw_die_ref qual_type = ctf_get_AT_type (modifier); switch (dw_get_die_tag (modifier)) @@ -489,37 +484,35 @@ gen_ctf_modifier_type (ctf_container_ref ctfc, dw_die_ref modifier) case DW_TAG_restrict_type: kind = CTF_K_RESTRICT; break; case DW_TAG_atomic_type: break; default: - return CTF_NULL_TYPEID; + return NULL; } /* Register the type for which this modifier applies. */ - qual_type_id = gen_ctf_type (ctfc, qual_type); + dtd = gen_ctf_type (ctfc, qual_type); /* Skip generating a CTF modifier record for _Atomic as there is no representation for it. */ if (dw_get_die_tag (modifier) == DW_TAG_atomic_type) - return qual_type_id; + return dtd; gcc_assert (kind != CTF_K_MAX); /* Now register the modifier itself. */ - if (!ctf_type_exists (ctfc, modifier, &modifier_type_id)) - modifier_type_id = ctf_add_reftype (ctfc, CTF_ADD_ROOT, - qual_type_id, kind, - modifier); + if (!ctf_type_exists (ctfc, modifier, &modifier_dtd)) + modifier_dtd = ctf_add_reftype (ctfc, CTF_ADD_ROOT, dtd, kind, modifier); - return modifier_type_id; + return modifier_dtd; } /* Generate CTF for a struct type. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind) { uint32_t bit_size = ctf_die_bitsize (sou); int declaration_p = get_AT_flag (sou, DW_AT_declaration); const char *sou_name = get_AT_string (sou, DW_AT_name); - ctf_id_t sou_type_id; + ctf_dtdef_ref sou_dtd; /* An incomplete structure or union type is represented in DWARF by a structure or union DIE that does not have a size attribute and @@ -531,10 +524,10 @@ gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind) /* This is a complete struct or union type. Generate a CTF type for it if it doesn't exist already. */ - if (!ctf_type_exists (ctfc, sou, &sou_type_id)) - sou_type_id = ctf_add_sou (ctfc, CTF_ADD_ROOT, - sou_name, kind, bit_size / 8, - sou); + if (!ctf_type_exists (ctfc, sou, &sou_dtd)) + sou_dtd = ctf_add_sou (ctfc, CTF_ADD_ROOT, + sou_name, kind, bit_size / 8, + sou); /* Now process the struct members. */ { @@ -547,7 +540,7 @@ gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind) const char *field_name; dw_die_ref field_type; HOST_WIDE_INT field_location; - ctf_id_t field_type_id; + ctf_dtdef_ref field_dtd; c = dw_get_die_sib (c); @@ -556,7 +549,7 @@ gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind) field_location = ctf_get_AT_data_member_location (c); /* Generate the field type. */ - field_type_id = gen_ctf_type (ctfc, field_type); + field_dtd = gen_ctf_type (ctfc, field_type); /* If this is a bit-field, then wrap the field type generated above with a CTF slice. */ @@ -610,29 +603,29 @@ gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind) surely something to look at for the next format version bump for CTF. */ if (bitsize <= 255 && (bitpos - field_location) <= 255) - field_type_id = ctf_add_slice (ctfc, CTF_ADD_NONROOT, - field_type_id, + field_dtd = ctf_add_slice (ctfc, CTF_ADD_NONROOT, + field_dtd, bitpos - field_location, bitsize, c); else - field_type_id = gen_ctf_unknown_type (ctfc); + field_dtd = gen_ctf_unknown_type (ctfc); } /* Add the field type to the struct or union type. */ ctf_add_member_offset (ctfc, sou, field_name, - field_type_id, + field_dtd, field_location); } while (c != dw_get_die_child (sou)); } - return sou_type_id; + return sou_dtd; } /* Generate CTF for a function type. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function, bool from_global_func) { @@ -643,17 +636,16 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function, uint32_t num_args = 0; int linkage = get_AT_flag (function, DW_AT_external); - ctf_id_t return_type_id; - ctf_id_t function_type_id; + ctf_dtdef_ref return_dtd, function_dtd; /* First, add the return type. */ - return_type_id = gen_ctf_type (ctfc, return_type); - func_info.ctc_return = return_type_id; + return_dtd = gen_ctf_type (ctfc, return_type); + func_info.ctc_return = return_dtd; /* Type de-duplication. Consult the ctfc_types hash before adding the CTF function type. */ - if (ctf_type_exists (ctfc, function, &function_type_id)) - return function_type_id; + if (ctf_type_exists (ctfc, function, &function_dtd)) + return function_dtd; /* Do a first pass on the formals to determine the number of arguments, and whether the function type gets a varargs. */ @@ -681,12 +673,12 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function, func_info.ctc_argc = num_args; /* Type de-duplication has already been performed by now. */ - function_type_id = ctf_add_function (ctfc, CTF_ADD_ROOT, - function_name, - (const ctf_funcinfo_t *)&func_info, - function, - from_global_func, - linkage); + function_dtd = ctf_add_function (ctfc, CTF_ADD_ROOT, + function_name, + (const ctf_funcinfo_t *)&func_info, + function, + from_global_func, + linkage); /* Second pass on formals: generate the CTF types corresponding to them and add them as CTF function args. */ @@ -694,7 +686,7 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function, dw_die_ref c; unsigned int i = 0; const char *arg_name; - ctf_id_t arg_type; + ctf_dtdef_ref arg_type; c = dw_get_die_child (function); if (c) @@ -706,7 +698,7 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function, { gcc_assert (i == num_args - 1); /* Add an argument with type 0 and no name. */ - ctf_add_function_arg (ctfc, function, "", 0); + ctf_add_function_arg (ctfc, function, "", NULL); } else if (dw_get_die_tag (c) == DW_TAG_formal_parameter) { @@ -723,12 +715,12 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function, while (c != dw_get_die_child (function)); } - return function_type_id; + return function_dtd; } /* Generate CTF for an enumeration type. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration) { const char *enum_name = get_AT_string (enumeration, DW_AT_name); @@ -736,7 +728,7 @@ gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration) unsigned int signedness = get_AT_unsigned (enumeration, DW_AT_encoding); int declaration_p = get_AT_flag (enumeration, DW_AT_declaration); - ctf_id_t enumeration_type_id; + ctf_dtdef_ref enum_dtd; /* If this is an incomplete enum, generate a CTF forward for it and be done. */ @@ -756,10 +748,10 @@ gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration) } /* Generate a CTF type for the enumeration. */ - enumeration_type_id = ctf_add_enum (ctfc, CTF_ADD_ROOT, - enum_name, bit_size / 8, - (signedness == DW_ATE_unsigned), - enumeration); + enum_dtd = ctf_add_enum (ctfc, CTF_ADD_ROOT, + enum_name, bit_size / 8, + (signedness == DW_ATE_unsigned), + enumeration); /* Process the enumerators. */ { @@ -787,13 +779,13 @@ gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration) else value_wide_int = AT_int (enumerator_value); - ctf_add_enumerator (ctfc, enumeration_type_id, + ctf_add_enumerator (ctfc, enum_dtd, enumerator_name, value_wide_int, enumeration); } while (c != dw_get_die_child (enumeration)); } - return enumeration_type_id; + return enum_dtd; } /* Add a CTF variable record for the given input DWARF DIE. */ @@ -804,7 +796,7 @@ gen_ctf_variable (ctf_container_ref ctfc, dw_die_ref die) const char *var_name = get_AT_string (die, DW_AT_name); dw_die_ref var_type = ctf_get_AT_type (die); unsigned int external_vis = get_AT_flag (die, DW_AT_external); - ctf_id_t var_type_id; + ctf_dtdef_ref var_dtd; /* Avoid duplicates. */ if (ctf_dvd_lookup (ctfc, die)) @@ -822,11 +814,10 @@ gen_ctf_variable (ctf_container_ref ctfc, dw_die_ref die) dw_die_ref decl = get_AT_ref (die, DW_AT_specification); /* Add the type of the variable. */ - var_type_id = gen_ctf_type (ctfc, var_type); + var_dtd = gen_ctf_type (ctfc, var_type); /* Generate the new CTF variable and update global counter. */ - (void) ctf_add_variable (ctfc, var_name, var_type_id, die, external_vis, - decl); + (void) ctf_add_variable (ctfc, var_name, var_dtd, die, external_vis, decl); /* Skip updating the number of global objects at this time. This is updated later after pre-processing as some CTF variable records although generated now, will not be emitted later. [PR105089]. */ @@ -837,10 +828,10 @@ gen_ctf_variable (ctf_container_ref ctfc, dw_die_ref die) static void gen_ctf_function (ctf_container_ref ctfc, dw_die_ref die) { - ctf_id_t function_type_id; + ctf_dtdef_ref function_dtd; /* Type de-duplication. Consult the ctfc_types hash before adding the CTF function type. */ - if (ctf_type_exists (ctfc, die, &function_type_id)) + if (ctf_type_exists (ctfc, die, &function_dtd)) return; /* Add the type of the function and update the global functions @@ -857,43 +848,43 @@ gen_ctf_function (ctf_container_ref ctfc, dw_die_ref die) this function returns the type id of the existing type. If the given DIE is not recognized as a type, then this function - returns CTF_NULL_TYPEID. */ + returns NULL. */ -static ctf_id_t +static ctf_dtdef_ref gen_ctf_type (ctf_container_ref ctfc, dw_die_ref die) { - ctf_id_t type_id; + ctf_dtdef_ref dtd = NULL; int unrecog_die = false; - if (ctf_type_exists (ctfc, die, &type_id)) - return type_id; + if (ctf_type_exists (ctfc, die, &dtd)) + return dtd; switch (dw_get_die_tag (die)) { case DW_TAG_base_type: - type_id = gen_ctf_base_type (ctfc, die); + dtd = gen_ctf_base_type (ctfc, die); break; case DW_TAG_pointer_type: - type_id = gen_ctf_pointer_type (ctfc, die); + dtd = gen_ctf_pointer_type (ctfc, die); break; case DW_TAG_typedef: - type_id = gen_ctf_typedef (ctfc, die); + dtd = gen_ctf_typedef (ctfc, die); break; case DW_TAG_array_type: - type_id = gen_ctf_array_type (ctfc, die); + dtd = gen_ctf_array_type (ctfc, die); break; case DW_TAG_structure_type: - type_id = gen_ctf_sou_type (ctfc, die, CTF_K_STRUCT); + dtd = gen_ctf_sou_type (ctfc, die, CTF_K_STRUCT); break; case DW_TAG_union_type: - type_id = gen_ctf_sou_type (ctfc, die, CTF_K_UNION); + dtd = gen_ctf_sou_type (ctfc, die, CTF_K_UNION); break; case DW_TAG_subroutine_type: - type_id = gen_ctf_function_type (ctfc, die, - false /* from_global_func */); + dtd = gen_ctf_function_type (ctfc, die, + false /* from_global_func */); break; case DW_TAG_enumeration_type: - type_id = gen_ctf_enumeration_type (ctfc, die); + dtd = gen_ctf_enumeration_type (ctfc, die); break; case DW_TAG_atomic_type: /* FALLTHROUGH */ @@ -902,35 +893,35 @@ gen_ctf_type (ctf_container_ref ctfc, dw_die_ref die) case DW_TAG_restrict_type: /* FALLTHROUGH */ case DW_TAG_volatile_type: - type_id = gen_ctf_modifier_type (ctfc, die); + dtd = gen_ctf_modifier_type (ctfc, die); break; case DW_TAG_unspecified_type: { const char *name = get_AT_string (die, DW_AT_name); if (name && strcmp (name, "void") == 0) - type_id = gen_ctf_void_type (ctfc); + dtd = gen_ctf_void_type (ctfc); else - type_id = CTF_NULL_TYPEID; + dtd = NULL; break; } case DW_TAG_reference_type: - type_id = CTF_NULL_TYPEID; + dtd = NULL; break; default: /* Unrecognized DIE. */ unrecog_die = true; - type_id = CTF_NULL_TYPEID; + dtd = NULL; break; } /* For all types unrepresented in CTF, use an explicit CTF type of kind CTF_K_UNKNOWN. */ - if ((type_id == CTF_NULL_TYPEID) && (!unrecog_die)) - type_id = gen_ctf_unknown_type (ctfc); + if ((dtd == NULL) && (!unrecog_die)) + dtd = gen_ctf_unknown_type (ctfc); - return type_id; + return dtd; } bool @@ -951,7 +942,7 @@ ctf_do_die (dw_die_ref die) return false; } else - return gen_ctf_type (tu_ctfc, die) == CTF_NULL_TYPEID; + return (gen_ctf_type (tu_ctfc, die) == NULL); } /* Initialize CTF subsystem for CTF debug info generation. */ diff --git a/include/btf.h b/include/btf.h index 24b38bace178..3f45ffb0b6bb 100644 --- a/include/btf.h +++ b/include/btf.h @@ -56,6 +56,11 @@ struct btf_header /* Maximum number of struct, union, enum members or func args. */ #define BTF_MAX_VLEN 0xffff +/* Type ID 0 represents the void type. */ +#define BTF_VOID_TYPEID 0 +/* Initial type ID for regular types. */ +#define BTF_INIT_TYPEID 1 + struct btf_type { uint32_t name_off; /* Offset in string section of type name. */ -- 2.43.0