From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx0a-00069f02.pphosted.com (mx0a-00069f02.pphosted.com [205.220.165.32]) by sourceware.org (Postfix) with ESMTPS id AC586384D1AC for ; Thu, 29 Sep 2022 22:35:26 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org AC586384D1AC Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=oracle.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=oracle.com Received: from pps.filterd (m0246629.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 28TLxSSw008301 for ; Thu, 29 Sep 2022 22:35:25 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=subject : to : cc : references : from : message-id : date : in-reply-to : content-type : content-transfer-encoding : mime-version; s=corp-2022-7-12; bh=RksvzowCXwFTxXVsSZ74riuoX6/USy7vYdQBhdzcVAo=; b=jU/DictLYVO8emcU41RE3jOuPWQg8l9RwxyrvDUyrfhwuKOa6UCahm1QToS5CgPB14j7 eQyKXUnckIhw2GwfV+3iegN9LU66EfahITqRBZY7vBH/4pGyFpx7ziJKOMe29rtxDOds boaXS7PPHJXs617zIu2EURkWrCUkDuJZNz/6hxdnkudCg0Wpn6R6i5EnB005xhNHNtuZ iPCgPUeN3uyaPoa4wBSrdLZY6iY4XQFgai/SbakIAUp9W15iembA8c7qP+Z8TkYTUzdC lvwGBAgryflQGBNkFUbT4h1/iLcJYlYsxragHOI3ogc1W62pESm7Wd/9LZ57dFYPUT2b zQ== Received: from phxpaimrmta02.imrmtpd1.prodappphxaev1.oraclevcn.com (phxpaimrmta02.appoci.oracle.com [147.154.114.232]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3jst0kx05y-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Thu, 29 Sep 2022 22:35:25 +0000 Received: from pps.filterd (phxpaimrmta02.imrmtpd1.prodappphxaev1.oraclevcn.com [127.0.0.1]) by phxpaimrmta02.imrmtpd1.prodappphxaev1.oraclevcn.com (8.17.1.5/8.17.1.5) with ESMTP id 28TMU37U039413 for ; Thu, 29 Sep 2022 22:35:24 GMT Received: from nam04-dm6-obe.outbound.protection.outlook.com (mail-dm6nam04lp2041.outbound.protection.outlook.com [104.47.73.41]) by phxpaimrmta02.imrmtpd1.prodappphxaev1.oraclevcn.com (PPS) with ESMTPS id 3jtpqasxss-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Thu, 29 Sep 2022 22:35:24 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=C8YvPD2Jfi2tfU1kkZO5cppz5Q4sfEyx7c3QnkquFqjOsk5XSBpvRJ+MI+cTGZZ4jdT2tKBJ/Vm5vcX20482XPCEjiZ/mYs1fyq3sgw5l1nmbmirImV7qw13zLqAMSDvtwIK6P8KrvvtZHES9hzlGKgfYYtX9bO4gzlfSHNLx4mRg6x7zITIFZbM4SZ44fZFJn3MDoO+br102fKIkeMw+zVqyZkqbFLmHIEYb+euuVVHPsxb7gNsjrix1/ukti7FYKs+mZX91+gB1dodchhNFsG9BN07WznPn279C67skn3UbiYza1YzxbJtkTO+cmVbZnnB/8QdBM8qH1jFBwiQ2A== 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=RksvzowCXwFTxXVsSZ74riuoX6/USy7vYdQBhdzcVAo=; b=bhNXiUZF0jyPh7FmK/wH5j0ySP9nSZ7GjJt0tNJCg2q5odF+u5KzWpgBxw//8nZXYtYZxSA2peX6w+2vH6BIO0iYe++FW07avhEBa0P8SBPpOtCSzWh9Rko9+irZN0VjCLgT1ipNeAG25Nfluhm7JYnfbTyRSpX73ecTn+VPcxrQM3RmE03m4DviZOpKfQWPusOK9R5aZqjV/H33i9EXY+Tf0aYnIuzGO2Xa4UHd0W3CbFW819XWvr3nWw9VrfxAvnZMyNde61blodKYqDoG0BxHLWa56DBoSDT89Iw0wxwkfWeCvtc/8Uw3izHbRdzhp1C/YuZytiMto+yFZkQ7qw== 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=RksvzowCXwFTxXVsSZ74riuoX6/USy7vYdQBhdzcVAo=; b=VdxChVMn2kgcR+ETdI7+co1qZ2MVmVxWgw4tL9795SXJm0ay2gGbVz3mq0ai4w8oT3ky/kx+o4e2oD6p5XpCf2iAQeFl+85ljFGQSnpvgZCsOPksTuE9Z1uOTrXgZOeG3Gfi+aE5/nhCOEIJ1LGU+62aC121lhGKcSEsk53f8O8= Received: from MWHPR1001MB2158.namprd10.prod.outlook.com (2603:10b6:301:2d::17) by PH7PR10MB5697.namprd10.prod.outlook.com (2603:10b6:510:130::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5632.19; Thu, 29 Sep 2022 22:35:22 +0000 Received: from MWHPR1001MB2158.namprd10.prod.outlook.com ([fe80::80a7:f7f3:4303:54e4]) by MWHPR1001MB2158.namprd10.prod.outlook.com ([fe80::80a7:f7f3:4303:54e4%5]) with mapi id 15.20.5676.017; Thu, 29 Sep 2022 22:35:22 +0000 Subject: Re: [PATCH v2] btf: Add support to BTF_KIND_ENUM64 type To: "Guillermo E. Martinez" , gcc-patches@gcc.gnu.org Cc: David Faust References: <20220829211106.427267-1-guillermo.e.martinez@oracle.com> <20220928211501.2647123-1-guillermo.e.martinez@oracle.com> From: Indu Bhagat Message-ID: <3995d832-83b9-848f-6d58-0525a0f588e3@oracle.com> Date: Thu, 29 Sep 2022 15:35:18 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.6.1 In-Reply-To: <20220928211501.2647123-1-guillermo.e.martinez@oracle.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-ClientProxiedBy: DS7PR03CA0337.namprd03.prod.outlook.com (2603:10b6:8:55::25) To MWHPR1001MB2158.namprd10.prod.outlook.com (2603:10b6:301:2d::17) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: MWHPR1001MB2158:EE_|PH7PR10MB5697:EE_ X-MS-Office365-Filtering-Correlation-Id: f4af62a8-383f-47b9-d952-08daa26ae4ef X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: qlytCuX53Qvb5FQeqrY1csA2g2FBk/a2h1xneOH38dDmpfT/iWklbmKjROg7kVyh3fQCEm692OpIsXtkd3eIe1tUPkRGVfgJMfmltQErcfy/Dtj3wD0x3OLPr9kwEXkQWcVb+61SWz2KJ0UdfIaT770v2DbBulfPWn0fZ6/zkdlPKl+NQeNm+H8UfPdYYnxzypr+3yKKfAmNhGp06gHtRmaVBScE/LIHc1q0r43beLkU2mBSQgcR9sNEaIgyjhj5/TJqQHpRA/MSqXPi+ayKArgPmLeboNaP/tvDNbYhabnQfV71dsM2/14oTP8/G2df56eiUW1H+fyB02lLDH5Dd7D5+3OU7n4XlDMosxkxGdxAA8Je84PPtUHIGHHaC1wLSrkuocBpE/DP+CvalyxsLXAIiMVtp7ntzYMlvzfuDqlysMmLl1EDcdJfDdBkilGGqB73iUu6PW1hIeS9T7nf2R3ll6H5/4mP+8n0FWJ2+U6dzhpC35DXgTlLsj51YPi4BfvsxCEMHN2si0RnQf92+kEb/EBKrn/hGAnwIKSSt1dkRzyXeAF30XwVU19N2O8vKsZJd10dA1oxzEb/qliJz/rfA6Bt8e+z1mW/6fGkF2dDaDvHXAqjiJCM2NjIJzw4hmK1ftnEWK6FUJfIN26cqMYxoA9gNRLcuV7m3qsC1VqbXRss8OYRzzRTX/sRLWgqT67BODhkejDmuM7loOyA/pagdtvSkmPY8ig81LRKJP4gn6+8I65tG5hUILuZpRlTPcN+O6koCBsrsUvJ+jUJAHi4aM6BE8Cz09Y9tZRxE13AWd+uxeV+YdV5mYb6Za61/pxDXDyO6oF9Oi7zvpRKtQ3wEvtjMxSvsFBgfjyEj/Y= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:MWHPR1001MB2158.namprd10.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230022)(136003)(366004)(396003)(39860400002)(376002)(346002)(451199015)(84970400001)(86362001)(66556008)(38100700002)(316002)(31696002)(8676002)(66476007)(30864003)(8936002)(2906002)(66899015)(44832011)(478600001)(2616005)(66946007)(6486002)(5660300002)(186003)(36756003)(6666004)(83380400001)(4326008)(107886003)(6512007)(53546011)(6506007)(31686004)(41300700001)(43740500002)(45980500001);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?S3JqSk15cE9ybWxsZkxQM0pPY3J5cEVsT3RXN3c1TjVTU1VPNUlsMVFQWSta?= =?utf-8?B?eEJBMG9sL3Y4UGtmT1NMdGVKTDBBd0NxRFBXTUIwRy83THNVY0h0OUxLaDRi?= =?utf-8?B?ZGRHMzRLcUhYU1llZnRjR3BtQmpsbEk5Ym9KRlJPVkdnMXU2Q3kyUTQ3Wjhl?= =?utf-8?B?N0QzR3pPS0ZnSG9vV2VBajRFTzNXR3o1MEdBcHk2VEhvd3RBaFdCRzMzVU05?= =?utf-8?B?Y2M2L1lOUGsvU0lqOVk5TWZwNXQ2Ykw4MklmcVJWNW8wbVBGbGZDUFMwVk9y?= =?utf-8?B?U05nN05nNlJoMjBjUGVJQjIyWkg5dEtCV1hueGo2YnF4MHp2cGhkRE9jSUhj?= =?utf-8?B?QS9jY2R3dmhvejA0VEZHUEVlc3Z2WlpKazRJK3cyVzByTVlNMnZJNDMrRm9K?= =?utf-8?B?dVFiVDZpZ2wxWUlzUTVsMDRnMDdpVWVVU0xZN0F1eForbG9jbE56NWRvRGx1?= =?utf-8?B?aHJabEJRS3RUOVE2TXNOZ2taaXhIb2FDYUwxN3RTN1ZlVGZKbjhkbGllTTE2?= =?utf-8?B?UGZGRk5yVksxVkhCTTYrNEp0RmNUQUZmMGFXVzhjTXV0dHMvVEVNYTJzMEcw?= =?utf-8?B?d01ZRXRqNEdVUXdQT0ZWNzRIbnU1V1NlZ0QrZXY3cloxMUVNbXE2VDdxWGNF?= =?utf-8?B?KzF4dEdHTk1FWmI0YXN3V2o2ZHErMVBqSnZEN2tMOW1sZmxTNlQxbERkUGY5?= =?utf-8?B?eFd5Sk9wMXYvV29uOUw0SGxYVjBHaUJzemxobFAvV2hMWkwzSEZNdTBsbG1L?= =?utf-8?B?K1E3VFdtRkVuZXZoNjQ0ekpKSUN0RkIwRm9YUVlsVkRSTTNVZEszU3BmN1Br?= =?utf-8?B?S3VCQ2tjUXloQ2lJMm4yM1J2N1lnblAreVN2b1hYbFNGdlJrT09Td0w4QVlO?= =?utf-8?B?VVBUZVZSOG56OCtJb29SdkNXeFYvM1dGYytNZHVSMm5NYUV3K1NpWDk1dFBn?= =?utf-8?B?VTRPWlk5OWhKSUlNSExDRDZ3OFhUdEFWRjd1Tk82WlNlMHFDSzVmT2w2VCtB?= =?utf-8?B?VStLUXNNT0sydm94S1lFZFlqaVJVWGFDUWdXcWwzUDhEejJjdllXMmpDMWc0?= =?utf-8?B?Z3c1cklEa0ZMU3krS2cvTXRFNGl5R2Jla2Z1NUdPU3dTZUJiM3RVUDZ0KzVs?= =?utf-8?B?TmtUZ05vT2kyV09HOTRXbmZpZndSdE1zQnJrQ0UzM2FaempKcUVZTThIVU9r?= =?utf-8?B?dWlpQVhHZFQ2bU40eVoyM2p5NGdHK0dPVDRmY0pRTzhLdVl3WXc5S3ZUUldX?= =?utf-8?B?R1d6ZmNvQndmSjdzR1oyaHA4N0RkZDBlNnp5czJqVGQveXJpUVluVHJ0bGNo?= =?utf-8?B?dlpSeEpMWFJMbExOUGMrYkR0R0F2QjQydWRqWjV0V0RRL0RId1orVkE0RTk3?= =?utf-8?B?aTd3MEZqYUo4VTJYV25QdzVMQXQxRzJqSVlqZ2N5OGVvQnhtaFVGMk5vdjA3?= =?utf-8?B?WWwyK2lvYWpwbUFNMkVhZlZ0ZllYVkx6bkxzK203dGxhRCtaUk1oME9sWElw?= =?utf-8?B?S1NwRHNrQlNQaHlkV0NFaFhJVnozNEE5NWJ6bWs5NDFIWU5ZL3BMTnFNcnZP?= =?utf-8?B?UGlzWHFhQVZ1V0pLOXR3NUZiNGRBNXRkRk4vdlQzWFM4N0dQUStZWEQ2T1oz?= =?utf-8?B?OWV0bWRhdm9kMXA5U3FrcGpjVDRuclRReDVyMVZnekRlVC9HSllwamt4NVVD?= =?utf-8?B?cGxxUTF5dXo1U2tuQktYL013YVBNa0t3R2g5U0ExbDEvQ2lWdzJ4T2VjRGZL?= =?utf-8?B?dzZzYlpxKzE4SGVwMFlsUm0wYVVEbDZxd2ZrNThhMUZwYTNDenBMT0tWQWZq?= =?utf-8?B?UlpjYWNzQm4zTWUySlNoK3NhMVVFWkR5akU3SDdDVDZkZTlDNVdQRDFVQVlq?= =?utf-8?B?cTZiVlU3ekJoM0NlYXdnL2ZYN1FYNVpaK3BueTJJMDAzWjN6UnFPSm1wbnNw?= =?utf-8?B?UmtqUnN6eXUrQU9KRHNaSng5bGpHS2Y5NXRqY1pxbXNWTmhUOGRBbldnWUxT?= =?utf-8?B?d1FTS1hrc3lVVVlmRU9tcWRsWXJDOVIvR0RabmJXSjIxSWg4ckNzRCtpRmlv?= =?utf-8?B?K2FyblN0Qmk0YTRUVXVxZlVHRkZCVEdhcFNoUUdSWlBMOXozelZVN0R5TFRl?= =?utf-8?B?ajg0QlRzM1hwK0ZJK0RWVGdKUWpzUmdJT1RqTnM0bHN1MEJ2N2UvRm5aTURk?= =?utf-8?B?TEE9PQ==?= X-OriginatorOrg: oracle.com X-MS-Exchange-CrossTenant-Network-Message-Id: f4af62a8-383f-47b9-d952-08daa26ae4ef X-MS-Exchange-CrossTenant-AuthSource: MWHPR1001MB2158.namprd10.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 29 Sep 2022 22:35:22.0159 (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: iSP2t3pEX73dlxQGBa1eoLi3dpgKrIpOA71pZiupp1FWBijnk10mONOyNTt/If5IrDOSxw9GKDkxZgJrsuvAzA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: PH7PR10MB5697 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.895,Hydra:6.0.528,FMLib:17.11.122.1 definitions=2022-09-29_13,2022-09-29_03,2022-06-22_01 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=999 bulkscore=0 mlxscore=0 suspectscore=0 malwarescore=0 adultscore=0 spamscore=0 phishscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2209130000 definitions=main-2209290141 X-Proofpoint-GUID: dNDx1AfGW7w7Bf9p34AEld7CBdJ1J3Yo X-Proofpoint-ORIG-GUID: dNDx1AfGW7w7Bf9p34AEld7CBdJ1J3Yo X-Spam-Status: No, score=-15.3 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,NICE_REPLY_A,RCVD_IN_DNSWL_LOW,RCVD_IN_MSPIKE_H2,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 List-Id: On 9/28/22 2:15 PM, Guillermo E. Martinez via Gcc-patches wrote: > Hello GCC team, > > The following is patch v2 to update BTF/CTF backend supporting > BTF_KIND_ENUM64 type. Changes from v1: > > + Fix typo in commit message. > + Fix changelog entries. > > Comments will be welcomed and appreciated!, > > Kind regards, > guillermo > -- > Hi Guillermo, Thanks for your patch. Sorry for the delay in reviewing this patch. Please see my comments inlined. Indu > BTF supports 64-bits enumerators with following encoding: > > struct btf_type: > name_off: 0 or offset to a valid C identifier > info.kind_flag: 0 for unsigned, 1 for signed > info.kind: BTF_KIND_ENUM64 > info.vlen: number of enum values > size: 1/2/4/8 > > The btf_type is followed by info.vlen number of: > > struct btf_enum64 > { > uint32_t name_off; /* Offset in string section of enumerator name. */ > uint32_t val_lo32; /* lower 32-bit value for a 64-bit value Enumerator */ > uint32_t val_hi32; /* high 32-bit value for a 64-bit value Enumerator */ > }; > > So, a new btf_enum64 structure was added to represent BTF_KIND_ENUM64 > and a new field in ctf_dtdef to represent specific type's properties, in > the particular case for CTF enums it helps to distinguish when its > enumerators values are signed or unsigned, later that information is > used to encode the BTF enum type. > > gcc/ChangeLog: > > * btfout.cc (btf_calc_num_vbytes): Compute enumeration size depending of > enumerator type btf_enum{,64}. > (btf_asm_type): Update btf_kflag according to enumerators sign, > using correct BPF type in BTF_KIND_ENUMi{,64}. Typo : i after ENUM > (btf_asm_enum_const): New argument to represent the size of > the BTF enum type. > * ctfc.cc (ctf_add_enum): Use and initialization of flag field to > CTF_ENUM_F_NONE. > (ctf_add_enumerator): New argument to represent CTF flags, > updating the comment and flag vaue according to enumerators > sing. > * ctfc.h (ctf_dmdef): Update dmd_value to HOST_WIDE_INT to allow > use 32/64 bits enumerators. > (ctf_dtdef): Add flags to to describe specific type's properties. > * dwarf2ctf.cc (gen_ctf_enumeration_type): Update flags field > depending when a signed enumerator value is found. > > include/ > * btf.h (btf_enum64): Add new definition and new symbolic > constant to BTF_KIND_ENUM64 and BTF_KF_ENUM_{UN,}SIGNED. > > gcc/testsuite/ChangeLog: > > * gcc.dg/debug/btf/btf-enum-1.c: Update testcase, with correct > info.kflags encoding. > * gcc.dg/debug/btf/btf-enum64-1.c: New testcase. > --- > gcc/btfout.cc | 24 ++++++++--- > gcc/ctfc.cc | 14 ++++--- > gcc/ctfc.h | 9 +++- > gcc/dwarf2ctf.cc | 9 +++- > gcc/testsuite/gcc.dg/debug/btf/btf-enum-1.c | 2 +- > gcc/testsuite/gcc.dg/debug/btf/btf-enum64-1.c | 41 +++++++++++++++++++ > include/btf.h | 19 +++++++-- > 7 files changed, 99 insertions(+), 19 deletions(-) > create mode 100644 gcc/testsuite/gcc.dg/debug/btf/btf-enum64-1.c > > diff --git a/gcc/btfout.cc b/gcc/btfout.cc > index 997a33fa089..4b11c867c23 100644 > --- a/gcc/btfout.cc > +++ b/gcc/btfout.cc > @@ -223,7 +223,9 @@ btf_calc_num_vbytes (ctf_dtdef_ref dtd) > break; > > case BTF_KIND_ENUM: > - vlen_bytes += vlen * sizeof (struct btf_enum); > + vlen_bytes += (dtd->dtd_data.ctti_size == 0x8) > + ? vlen * sizeof (struct btf_enum64) > + : vlen * sizeof (struct btf_enum); > break; > > case BTF_KIND_FUNC_PROTO: > @@ -622,6 +624,15 @@ btf_asm_type (ctf_container_ref ctfc, ctf_dtdef_ref dtd) > btf_size_type = 0; > } > > + if (btf_kind == BTF_KIND_ENUM) > + { > + btf_kflag = (dtd->flags & CTF_ENUM_F_ENUMERATORS_SIGNED) > + ? BTF_KF_ENUM_SIGNED > + : BTF_KF_ENUM_UNSIGNED; > + if (dtd->dtd_data.ctti_size == 0x8) > + btf_kind = BTF_KIND_ENUM64; > + } > + See below. If you do add a new member in ctf_dmdef instead (as I propose), you should ideally iterate over the enumerators (dtd->dtd_u.dtu_members) to make sure they are all the same signedness. > dw2_asm_output_data (4, dtd->dtd_data.ctti_name, "btt_name"); > dw2_asm_output_data (4, BTF_TYPE_INFO (btf_kind, btf_kflag, btf_vlen), > "btt_info: kind=%u, kflag=%u, vlen=%u", > @@ -634,6 +645,7 @@ btf_asm_type (ctf_container_ref ctfc, ctf_dtdef_ref dtd) > case BTF_KIND_UNION: > case BTF_KIND_ENUM: > case BTF_KIND_DATASEC: > + case BTF_KIND_ENUM64: > dw2_asm_output_data (4, dtd->dtd_data.ctti_size, "btt_size: %uB", > dtd->dtd_data.ctti_size); > return; > @@ -707,13 +719,13 @@ btf_asm_sou_member (ctf_container_ref ctfc, ctf_dmdef_t * dmd) > } > } > > -/* Asm'out an enum constant following a BTF_KIND_ENUM. */ > +/* Asm'out an enum constant following a BTF_KIND_ENUM{,64}. */ > > static void > -btf_asm_enum_const (ctf_dmdef_t * dmd) > +btf_asm_enum_const (unsigned int size, ctf_dmdef_t * dmd) > { > dw2_asm_output_data (4, dmd->dmd_name_offset, "bte_name"); > - dw2_asm_output_data (4, dmd->dmd_value, "bte_value"); > + dw2_asm_output_data (size, dmd->dmd_value, "bte_value"); I am not sure if this is ok to do like the above. The format specification says: The ``btf_enum64`` encoding: * ``name_off``: offset to a valid C identifier * ``val_lo32``: lower 32-bit value for a 64-bit value * ``val_hi32``: high 32-bit value for a 64-bit value What if the chosen BPF arch type is big-endian and the const value is 8 bytes ? Wouldnt such constant values to be written out incorrectly then ? I think you need to write the lower 32-bits and higher 32-bits explicitly to avoid that issue. > } > > /* Asm'out a function parameter description following a BTF_KIND_FUNC_PROTO. */ > @@ -871,7 +883,7 @@ output_asm_btf_sou_fields (ctf_container_ref ctfc, ctf_dtdef_ref dtd) > btf_asm_sou_member (ctfc, dmd); > } > > -/* Output all enumerator constants following a BTF_KIND_ENUM. */ > +/* Output all enumerator constants following a BTF_KIND_ENUM{,64}. */ > > static void > output_asm_btf_enum_list (ctf_container_ref ARG_UNUSED (ctfc), > @@ -881,7 +893,7 @@ output_asm_btf_enum_list (ctf_container_ref ARG_UNUSED (ctfc), > > for (dmd = dtd->dtd_u.dtu_members; > dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd)) > - btf_asm_enum_const (dmd); > + btf_asm_enum_const (dtd->dtd_data.ctti_size, dmd); > } > > /* Output all function arguments following a BTF_KIND_FUNC_PROTO. */ > diff --git a/gcc/ctfc.cc b/gcc/ctfc.cc > index 9773358a475..253c36b6a0a 100644 > --- a/gcc/ctfc.cc > +++ b/gcc/ctfc.cc > @@ -604,6 +604,7 @@ ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, const char * name, > gcc_assert (size <= CTF_MAX_SIZE); > > dtd->dtd_data.ctti_size = size; > + dtd->flags = CTF_ENUM_F_NONE; > > ctfc->ctfc_num_stypes++; > > @@ -612,7 +613,7 @@ ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, const char * name, > > int > ctf_add_enumerator (ctf_container_ref ctfc, ctf_id_t enid, const char * name, > - HOST_WIDE_INT value, dw_die_ref die) > + HOST_WIDE_INT value, uint32_t flags, dw_die_ref die) > { > ctf_dmdef_t * dmd; > uint32_t kind, vlen, root; > @@ -630,10 +631,12 @@ ctf_add_enumerator (ctf_container_ref ctfc, ctf_id_t enid, const char * name, > > gcc_assert (kind == CTF_K_ENUM && vlen < CTF_MAX_VLEN); > > - /* Enum value is of type HOST_WIDE_INT in the compiler, dmd_value is int32_t > - on the other hand. Check bounds and skip adding this enum value if out of > - bounds. */ > - if ((value > INT_MAX) || (value < INT_MIN)) > + /* Enum value is of type HOST_WIDE_INT in the compiler, CTF enumerators > + values in ctf_enum_t is limited to int32_t, BTF supports signed and > + unsigned enumerators values of 32 and 64 bits, for both debug formats > + we use ctf_dmdef_t.dmd_value entry of HOST_WIDE_INT type. So check > + CTF bounds and skip adding this enum value if out of bounds. */ > + if (!btf_debuginfo_p() && ((value > INT_MAX) || (value < INT_MIN))) > { > /* FIXME - Note this TBD_CTF_REPRESENTATION_LIMIT. */ > return (1); > @@ -649,6 +652,7 @@ ctf_add_enumerator (ctf_container_ref ctfc, ctf_id_t enid, const char * name, > dmd->dmd_value = value; > > dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, root, vlen + 1); > + dtd->flags |= flags; > ctf_dmd_list_append (&dtd->dtd_u.dtu_members, dmd); > > if ((name != NULL) && strcmp (name, "")) > diff --git a/gcc/ctfc.h b/gcc/ctfc.h > index bcf3a43ae1b..a22342b2610 100644 > --- a/gcc/ctfc.h > +++ b/gcc/ctfc.h > @@ -125,6 +125,10 @@ typedef struct GTY (()) ctf_itype > > #define CTF_FUNC_VARARG 0x1 > > +/* Enum specific flags. */ > +#define CTF_ENUM_F_NONE (0) > +#define CTF_ENUM_F_ENUMERATORS_SIGNED (1 << 0) > + > /* Struct/union/enum member definition for CTF generation. */ > > typedef struct GTY ((chain_next ("%h.dmd_next"))) ctf_dmdef > @@ -133,7 +137,7 @@ typedef struct GTY ((chain_next ("%h.dmd_next"))) ctf_dmdef > ctf_id_t 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). */ > - int dmd_value; /* Value of this member (for enum). */ > + HOST_WIDE_INT dmd_value; /* Value of this member (for enum). */ > struct ctf_dmdef * dmd_next; /* A list node. */ > } ctf_dmdef_t; > I am wondering if you considered adding a member here instead - something like- bool dmd_value_signed; /* Signedness for the enumerator. */. See comment below. > @@ -162,6 +166,7 @@ struct GTY ((for_user)) ctf_dtdef > bool from_global_func; /* Whether this type was added from a global > function. */ > uint32_t linkage; /* Used in function types. 0=local, 1=global. */ > + uint32_t flags; /* Flags to describe specific type's properties. */ > union GTY ((desc ("ctf_dtu_d_union_selector (&%1)"))) > { > /* struct, union, or enum. */ Instead of carrying this information in ctf_dtdef which is the data structure for each type in CTF, how about adding a new member in struct ctf_dmdef? The "flags" member is meant for only enum types, and hence it will be more appropriate to add to ctf_dmdef as say, dmd_value_signed. > @@ -429,7 +434,7 @@ 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 *, > - HOST_WIDE_INT, dw_die_ref); > + HOST_WIDE_INT, uint32_t, dw_die_ref); > extern int ctf_add_member_offset (ctf_container_ref, dw_die_ref, const char *, > ctf_id_t, uint64_t); > extern int ctf_add_function_arg (ctf_container_ref, dw_die_ref, > diff --git a/gcc/dwarf2ctf.cc b/gcc/dwarf2ctf.cc > index 397100004c2..0ef96dd48fd 100644 > --- a/gcc/dwarf2ctf.cc > +++ b/gcc/dwarf2ctf.cc > @@ -772,6 +772,7 @@ gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration) > const char *enumerator_name; > dw_attr_node *enumerator_value; > HOST_WIDE_INT value_wide_int; > + uint32_t flags = 0; > > c = dw_get_die_sib (c); > > @@ -785,10 +786,14 @@ gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration) > == dw_val_class_unsigned_const_implicit)) > value_wide_int = AT_unsigned (enumerator_value); > else > - value_wide_int = AT_int (enumerator_value); > + { > + value_wide_int = AT_int (enumerator_value); > + flags |= CTF_ENUM_F_ENUMERATORS_SIGNED; > + } > > ctf_add_enumerator (ctfc, enumeration_type_id, > - enumerator_name, value_wide_int, enumeration); > + enumerator_name, value_wide_int, > + flags, enumeration); > } > while (c != dw_get_die_child (enumeration)); > } > diff --git a/gcc/testsuite/gcc.dg/debug/btf/btf-enum-1.c b/gcc/testsuite/gcc.dg/debug/btf/btf-enum-1.c > index 728493b0804..7e940529f1b 100644 > --- a/gcc/testsuite/gcc.dg/debug/btf/btf-enum-1.c > +++ b/gcc/testsuite/gcc.dg/debug/btf/btf-enum-1.c > @@ -4,7 +4,7 @@ > /* { dg-options "-O0 -gbtf -dA" } */ > > /* { dg-final { scan-assembler-times "\[\t \]0x6000004\[\t \]+\[^\n\]*btt_info" 1 } } */ > -/* { dg-final { scan-assembler-times "\[\t \]0x6000003\[\t \]+\[^\n\]*btt_info" 1 } } */ > +/* { dg-final { scan-assembler-times "\[\t \]0x86000003\[\t \]+\[^\n\]*btt_info" 1 } } */ > /* { dg-final { scan-assembler-times "ascii \"QAD.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > /* { dg-final { scan-assembler-times "ascii \"QED.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > /* { dg-final { scan-assembler-times "ascii \"QOD.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > diff --git a/gcc/testsuite/gcc.dg/debug/btf/btf-enum64-1.c b/gcc/testsuite/gcc.dg/debug/btf/btf-enum64-1.c > new file mode 100644 > index 00000000000..da103842807 > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/debug/btf/btf-enum64-1.c > @@ -0,0 +1,41 @@ > +/* Test BTF generation for 64 bits enums. */ > + > +/* { dg-do compile } */ > +/* { dg-options "-O0 -gbtf -dA" } */ > + > +/* { dg-final { scan-assembler-times "\[\t \].size\[\t \]myenum1,\[\t \]8" 1 } } */ > +/* { dg-final { scan-assembler-times "\[\t \].size\[\t \]myenum2,\[\t \]8" 1 } } */ > +/* { dg-final { scan-assembler-times "\[\t \].size\[\t \]myenum3,\[\t \]8" 1 } } */ > +/* { dg-final { scan-assembler-times "\[\t \]0x13000003\[\t \]+\[^\n\]*btt_info" 2 } } */ > +/* { dg-final { scan-assembler-times "\[\t \]0x93000003\[\t \]+\[^\n\]*btt_info" 1 } } */ > +/* { dg-final { scan-assembler-times "ascii \"B1.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > +/* { dg-final { scan-assembler-times "ascii \"B2.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > +/* { dg-final { scan-assembler-times "ascii \"B3.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > +/* { dg-final { scan-assembler-times "ascii \"C1.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > +/* { dg-final { scan-assembler-times "ascii \"C2.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > +/* { dg-final { scan-assembler-times "ascii \"C3.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > +/* { dg-final { scan-assembler-times "ascii \"D1.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > +/* { dg-final { scan-assembler-times "ascii \"D2.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > +/* { dg-final { scan-assembler-times "ascii \"D3.0\"\[\t \]+\[^\n\]*btf_string" 1 } } */ > +/* { dg-final { scan-assembler-times "bte_value" 9 } } */ > + > +enum default_enum > +{ > + B1 = 0xffffffffaa, > + B2 = 0xbbbbbbbb, > + B3 = 0xaabbccdd, > +} myenum1 = B1; > + > +enum explicit_unsigned > +{ > + C1 = 0xffffffffbbUL, > + C2 = 0xbbbbbbbb, > + C3 = 0xaabbccdd, > +} myenum2 = C1; > + > +enum signed64 > +{ > + D1 = 0xffffffffaa, > + D2 = 0xbbbbbbbb, > + D3 = -0x1, > +} myenum3 = D1; I wonder if its meaningul to add such an enum64 test with -mlittle-endian and -mbig-endian to keep the order of val_lo32 and val_hi32 tested. > diff --git a/include/btf.h b/include/btf.h > index 78b551ced23..eba67f9d599 100644 > --- a/include/btf.h > +++ b/include/btf.h > @@ -109,7 +109,8 @@ struct btf_type > #define BTF_KIND_VAR 14 /* Variable. */ > #define BTF_KIND_DATASEC 15 /* Section such as .bss or .data. */ > #define BTF_KIND_FLOAT 16 /* Floating point. */ > -#define BTF_KIND_MAX BTF_KIND_FLOAT > +#define BTF_KIND_ENUM64 19 /* Enumeration up to 64 bits. */ > +#define BTF_KIND_MAX BTF_KIND_ENUM64 > #define NR_BTF_KINDS (BTF_KIND_MAX + 1) > > /* For some BTF_KINDs, struct btf_type is immediately followed by > @@ -130,14 +131,17 @@ struct btf_type > #define BTF_INT_BOOL (1 << 2) > > /* BTF_KIND_ENUM is followed by VLEN struct btf_enum entries, > - which describe the enumerators. Note that BTF currently only > - supports signed 32-bit enumerator values. */ > + which describe the enumerators. */ > struct btf_enum > { > uint32_t name_off; /* Offset in string section of enumerator name. */ > int32_t val; /* Enumerator value. */ > }; > > +/* BTF_KF_ENUM_ holds the flags for kflags in BTF_KIND_ENUM{,64}. */ > +#define BTF_KF_ENUM_UNSIGNED (0) > +#define BTF_KF_ENUM_SIGNED (1 << 0) > + > /* BTF_KIND_ARRAY is followed by a single struct btf_array. */ > struct btf_array > { > @@ -190,6 +194,15 @@ struct btf_var_secinfo > uint32_t size; /* Size (in bytes) of variable. */ > }; > > +/* BTF_KIND_ENUM64 is followed by VLEN struct btf_enum64 entries, > + which describe the 64 bits enumerators. */ > +struct btf_enum64 > +{ > + uint32_t name_off; /* Offset in string section of enumerator name. */ > + uint32_t val_lo32; /* lower 32-bit value for a 64-bit value Enumerator */ > + uint32_t val_hi32; /* high 32-bit value for a 64-bit value Enumerator */ > +}; > + > #ifdef __cplusplus > } > #endif >