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 E15773857C7D for ; Mon, 3 Oct 2022 14:39:52 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org E15773857C7D 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 (m0246617.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 293EYqMb024509 for ; Mon, 3 Oct 2022 14:39:50 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=message-id : date : subject : to : cc : references : from : in-reply-to : content-type : content-transfer-encoding : mime-version; s=corp-2022-7-12; bh=2fHx11XLn/de+FUtjbfxeVYvlEom54sc27YZdlt6cJY=; b=UDRkVQZO+xpmBUoOJP4sEUlolgkbvyPN6ZJtCw6YZUPn85h7SDbIUyeg/MQ7xyLW09gu KWCHMWlpZKu+E5U74qEvKHMNDua76UnwDmzWhqMaxWwqgfqtUFjisMm7Nw+QLhxkPeLV kOqYZ2MLCGiTpGC02gBDK5na5DPkHUwNaZv66arBWbaOh6ShrG5AxHBmCYuYEiyTwb/V qPqz1RM9MnlrTMVEbvHFKHUXu+tVbwTqVcgs8tiKzAt/w0iBHvqsmk4qQ8iNVy0NMQCL mbLzePoClrpUhAxi8Q+tc9JZNcilRmb50P8ZPXdnkYO7zZ4nGyuzG3B7rfYblJSXyGqr rw== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3jxe3tks21-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Mon, 03 Oct 2022 14:39:50 +0000 Received: from pps.filterd (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.5/8.17.1.5) with ESMTP id 293DUVAk028098 for ; Mon, 3 Oct 2022 14:39:49 GMT Received: from nam04-bn8-obe.outbound.protection.outlook.com (mail-bn8nam04lp2049.outbound.protection.outlook.com [104.47.74.49]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3jxc09audr-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Mon, 03 Oct 2022 14:39:48 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=mPzpSKsVwfXucO1n+HeDTCaAeAQ/DwydfYNdj9O/mbTwd7I+Ez5QCTR/HVtc8bCkwhFtWHm6gge7msZ6kZAp/KyXzYKa0ZGAQ4JEbeesbd/uHE89ObPGRv210sQmruqrz9yGY87AcMAMCSBcK2QS9/5CZ3XR+jlLMSXzgUyhQpO4PZScuYSA0fswry7DQ2XmL7gqj4GxEtcuvymbqZoIz3hh4sRPYK25PjBTFww7psBsCwdPfFw+Ujwe1JavFWc8NZLPWMOpc8HQAjar9JQMuqgegYfMmyouF3IULavX8Z1qZWkY58gMA2r+7lqAphIRXOtGFuQaeFwcZ9Dchy8n3w== 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=2fHx11XLn/de+FUtjbfxeVYvlEom54sc27YZdlt6cJY=; b=EW2W6UsV+FqzjpXtC0PeUj14viRxi1wkhPTvFtAPKoy+V4ewlCxMYsI1mibtaF/8etha88pNv0L61u3Oeio063suGYN1DaV1Mc7AQVUdKRS+Gxx9k8MqPQB9KLdnprB7IZo3jJGe7WO4znwz0mXH7/z4FY3rJnxJihj2CD9KxDFCszkSvRTRBwW8SThtZxcKKYEshN87ZIreFb3rIcjL6gnpAWcJGv5OjIZWL+6AwnE3gdhOa2sy+mgIHHnhiiBhVIlBixPlngB4nBlRA5OreKu+zAPYZQzwUOWPpQMCagH4QXwvpZiNeKQSMs8/2yvmYvvaWYXVfsb8XdAGc0hG4g== 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=2fHx11XLn/de+FUtjbfxeVYvlEom54sc27YZdlt6cJY=; b=VTafG67AExEJlzZbPJAAueLRfzxT9dvQJAq/Ig1Y9NamJzKLQ2/jpQJ5jX81Z164BeIhyvpIlRf8Ij+sKKa1JzFQ2Nvl2OOT8khHOBCmqRwqqrFc/lXbOGghYLINIcPKNOmhgLqWvrWkFZSKMmP3mVU+oPagwm9hVByuwepv2B8= Received: from MWHPR10MB1407.namprd10.prod.outlook.com (2603:10b6:300:23::20) by DS7PR10MB5087.namprd10.prod.outlook.com (2603:10b6:5:3b0::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5676.20; Mon, 3 Oct 2022 14:39:46 +0000 Received: from MWHPR10MB1407.namprd10.prod.outlook.com ([fe80::d05e:773d:2a05:eaed]) by MWHPR10MB1407.namprd10.prod.outlook.com ([fe80::d05e:773d:2a05:eaed%2]) with mapi id 15.20.5676.030; Mon, 3 Oct 2022 14:39:46 +0000 Message-ID: <6c9e3ce7-2365-81b3-d3e7-464ec06622cb@oracle.com> Date: Mon, 3 Oct 2022 09:39:42 -0500 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.3.0 Subject: Re: [PATCH v2] btf: Add support to BTF_KIND_ENUM64 type To: Indu Bhagat , 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> <3995d832-83b9-848f-6d58-0525a0f588e3@oracle.com> Content-Language: en-US From: "Guillermo E. Martinez" Organization: Oracle Corporation In-Reply-To: <3995d832-83b9-848f-6d58-0525a0f588e3@oracle.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit X-ClientProxiedBy: BY5PR17CA0045.namprd17.prod.outlook.com (2603:10b6:a03:167::22) To MWHPR10MB1407.namprd10.prod.outlook.com (2603:10b6:300:23::20) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: MWHPR10MB1407:EE_|DS7PR10MB5087:EE_ X-MS-Office365-Filtering-Correlation-Id: 1a6211fa-ac1b-40d5-4b13-08daa54d1e15 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Fx9rRxH2tiQiJakxp13GFYxKFQeGS4sZ/LAdFHyL1CIXXOXLLhbO4LnoIlYXSPOSvUEgriha4WOa3aLzIOs2D5ogcTffuyxzVtJi0pGi5GItBWZpiiW1Wwi6aDi1xCR0umyDdgqnfvQkZrJLzB/CJFtvFyC/U/qbZIZBtltQ4HEHT6vmY4StxmtUJlaQ3mjMWQUHrKM5ETDuTp06dWrLmL1hf7Tjnw21eHKwXyaVAuttciYRF2uBPAomr+4t38+nv9P29eQsTa2DjPEVSAawxGhrifUD6kHEtZd/fXaSR9GvCPDmYVnUoNgTuPPZmatKh/9qtPNiitJ3kJwWv1tqMfs/MMUHYB68J3z3t+sesTDTQqpH1YB5OuIxt67xKG6mIwCwJ1psn/zkbQz2/IEA+QPB60HSL+xu9DJbNGcGvZbcBRqtB1vfCRrYUAK+zwtp3CJ5kZ4Px7QUOwFH2LydQ3kX9bJtqs3S2rG+cssAqguOLO5W0qdQVJl3QGLsYxMM1g0saAg6sZB+96gN2W3DadtWSst3DXYrJtQCsHZQXlkv9f5SP2g/10QaRK7/ov76s22jA9oG8GpTRfBTK1hY+x4T3xWzAsJrqUWJTYmPp+yEX0kQEW808HmDEcv0Kt3Li5VCdRnTf7Ryc9epV0vAONRDYUx//y1u9yApbQfJfPzGcbH7GGYOzE41TB5io7ShSvD1XANr+oB+xkapHBPiw8Fwwq3ts8O58D6nTGfuaL5j6H38Mj5CSmEn/xkabc6K7KPYAxwlKiWJRdv4Nay4vNTMMdygNkB/odqsCiQ8RZ+zRV48lZeKgy+ZqYeQpqEw X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:MWHPR10MB1407.namprd10.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230022)(366004)(396003)(376002)(346002)(136003)(39860400002)(451199015)(86362001)(2906002)(31696002)(6506007)(84970400001)(38100700002)(6512007)(36916002)(53546011)(6666004)(107886003)(2616005)(316002)(6486002)(478600001)(41300700001)(8936002)(66946007)(5660300002)(66556008)(66476007)(30864003)(186003)(8676002)(4326008)(31686004)(83380400001)(66899015)(36756003)(43740500002)(45980500001);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?d3N2UHBobFBIZkN4eUJFUnBkMCtrYXEzaEhPajEzeXZIU3VudjhTSkE5bjhS?= =?utf-8?B?dlVpbUdTZW9lMkwzbUlPcDdFMnlNeGN3MXlpaGd1cXg5dlcvWmZOL0ZDMUkz?= =?utf-8?B?ZkRIQi81bll2U05UcGRiZGFUdjcvOUcvOElzakRNOE1EMTNVUTJWNStEYUdm?= =?utf-8?B?ckFjMk1CWldFbkdqdnZqVk95eWNNVUt1VG9hU0JiSU9reEVualJObzFTeVBN?= =?utf-8?B?WjdtUFk0RllFU0dkQ0VoZEI2dHFIWUpKZUtKQmtTNElYcFEyeHBKRDVxczAx?= =?utf-8?B?ZGVncWc0WGhQSGdYLzhxYmh5U09KVXBVVDVsNTdaUE1UK0hXaUlzQUFZYW15?= =?utf-8?B?cWl2UzR6RG9CWmVVWFIxQ3FXWkdGdDBMVkd3R2VIYWtkaTJaQ3E3VHNiZDhI?= =?utf-8?B?YW9nWG5xdTZ3U3ArczlPanZsRGd0cW13eDNHVjBwbXkyWGhVekNNT25vUUww?= =?utf-8?B?UHZSYnB3QmtOUExwcmxvRmx6b1B3S0h5UHNGZjUzQ2pXWDVyTmVvbEpxdHdS?= =?utf-8?B?Wmx1WW8xZHkvS1RlMXlBWGpZekc1bFRCVExkUjJuTStXUU1zbDFDcUo3NG00?= =?utf-8?B?UjR6T0FVSHF6SmFzMlNySVZNUWY0RG1PT1lvaTBTbmVIVWpRRzVpb0dTbEZw?= =?utf-8?B?VjN4YkR1SGMrckROVUVuVUFWN29zdms0eU13NjFpUWp3MlQwRVAzWE5admJw?= =?utf-8?B?MUFDV2wwczJ2NWZhdkozV2hLZWQweDhXVENLVWN2S2NWR0lkM1dTNktMaUNs?= =?utf-8?B?MEhJSGd5NXFCRE5kUTJreEFPN0pYbzFoYUtXZTFRYnRMTmV2QVFuSkRsd0pJ?= =?utf-8?B?UVVqd1ZnMDhuMjhvbTlNeWhqakY2OUJReEt1ZVV1c2dKcElRcHpoSUhQMGEr?= =?utf-8?B?Z21CMlBEaGdmY2k0ak1QeUdxeTd4eXFlN3duTDF0NEdaNFRFOHNyNFk4NnBT?= =?utf-8?B?YjJpcjd1NThrTGxBWUFWRUQ3M3lrNDR0VUtUZTdHaFdDRXZUcW5IYVZ3SHRC?= =?utf-8?B?SDJLYko0STVXZk13Q1RqY0xmNHo3Ly9mcEhKV0ptRCtWS29uVVV2T2IxQkRx?= =?utf-8?B?cnRwbVBJeGRZM1Zxczd4S1lmeDF5aXVpaFhyZm1hZlJTb2wvUU84d0hzZEh1?= =?utf-8?B?TnVEYlJBbzhNNzFCZ2QyL3JmcDgrWmZEMGM2dWJaSTBqaXJWMHFjUWYyTUNk?= =?utf-8?B?TTZ6NWoxcklYZzQzYnVta3U3ZWVubEFRS29lcVNtTlhJa2pTMW8waTg1Q2hQ?= =?utf-8?B?QUIrc1JzR1FRNmdBTlZRQUZDeGxjMHRLWUtUZC9zME50a3daNHJ4TWRaSklS?= =?utf-8?B?WVlHNTc0bEZGL2FYYU9TUjFFZzJ0VjV5d2dzOFRwempYdWwrTnRCZHF2WXQ3?= =?utf-8?B?eEpCLzZSTTFpWURXU2hPWnRnUi82NmRpQnFuZkkzM1hkcTNCUThuNzJ4bWFu?= =?utf-8?B?TDFzdW9TREh0TzZ2MExMMkEzWXZ1U3pzNW4xdGdDUjdOVFUwMWhZTGpjTDA2?= =?utf-8?B?MVNTbS9kdXc3ank0V2M3cHoxQTB5aWtnNmcrUjlmaWZ1SG1MVmp0ZFdQcGRx?= =?utf-8?B?eXBGd2l4cFYxQ1FPZEtvMWhaM2J2Yk51dm1OT3JmTk1nVmQ5ZE51WDd0THN0?= =?utf-8?B?T0haUTIzR245TEdKNXZiZEJJTVNIZTcyejJMSHdhcGNCQ2dhdTc5YzZqN2Jj?= =?utf-8?B?WVBHaTBXMmUrRXlVczdEbDRsRWdzRVNLQ21GSDBUTnFKSzA1eWszQ0xYQmh3?= =?utf-8?B?S01hUlNDSUFuN3Q1OTZvOWxyNmdESndyOFFvWTNSTmZNT1ltRHNUd0dORnFS?= =?utf-8?B?QVNDaDI3VXZpMjdmN092TmsvZ1daZG9iR3dRZnFmblFSOTQrUFN2Ym9sMGNr?= =?utf-8?B?bDllOXA1RFFRNnhsZVhENW1TMlc5ekFFc1ZSQ3h6eU1aam9KN2hxSGEwUmRM?= =?utf-8?B?UlpaOHNxdDAxMkJHMnU2WlZCS05obGhoakpmUUVmRDdRakM0dVVRc0oyWmRC?= =?utf-8?B?RkNtMG8rRDJRV09DTzFMTmc5Wk9GWE9YaGlXYzdaWkVTMUZXaXVwdVp4Q1hl?= =?utf-8?B?YndEWkYrVHJUUzlWZ05TcERxQlBuUWpuSVRXQy9ERm1JclNzK1RORXI5NmNT?= =?utf-8?B?d05OZW5zdDJ0TlBQczhyMGo2MXhMV3FLdjduZjBvRkE1VlU4ejRuOS8zRzY3?= =?utf-8?Q?XV4LelnBsBMR4If2neCEan7tjoFawn3yTBYYTLZ/80Dx?= X-OriginatorOrg: oracle.com X-MS-Exchange-CrossTenant-Network-Message-Id: 1a6211fa-ac1b-40d5-4b13-08daa54d1e15 X-MS-Exchange-CrossTenant-AuthSource: MWHPR10MB1407.namprd10.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 03 Oct 2022 14:39:46.3998 (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: LQY17B7PtwPCaZzv59iqnS0bFJU2ssE4L8Y3wVXK7iKA6O8/xPfN4OfCro/dL3fk8+pZGGBXjob+Yd7WFilLTeksLhUqRqwyq/QYvfKlsRs= X-MS-Exchange-Transport-CrossTenantHeadersStamped: DS7PR10MB5087 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-10-03_02,2022-09-29_03,2022-06-22_01 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 phishscore=0 bulkscore=0 mlxscore=0 malwarescore=0 adultscore=0 spamscore=0 mlxlogscore=999 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2209130000 definitions=main-2210030087 X-Proofpoint-ORIG-GUID: ccUuYu1yA1gSoCYQZ9X1kYFSSsjw6cMs X-Proofpoint-GUID: ccUuYu1yA1gSoCYQZ9X1kYFSSsjw6cMs X-Spam-Status: No, score=-11.7 required=5.0 tests=BAYES_00,BODY_8BITS,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/29/22 17:35, Indu Bhagat wrote: > 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, > Hi Indu, > Thanks for your patch. > > Sorry for the delay in reviewing this patch. Please see my comments inlined. > No worries, thanks so much for your comments!. They were really useful. > 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 > Fixed in v3. >>     (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. > Correct, struct `ctf_dmdef' stores enumerator's information. However in BTF spec ``info.kind_flag`` is not a property per enumerator, but enumeration type property instead, so I decided to add in `ctf_dtdef' a `flag' field to store the signeedness information for an enumeration type, then in `gen_ctf_enumeration_type' when it builds the enumerators entries,`ctf_dtdef.flag' is updated to `CTF_ENUM_F_ENUMERATORS_SIGNED' when it found a signed enumerator value meaning that enumeration type should be consider a signed type. i.e, I detect signeedness when enumeration type is being building. Of course, I can add `dmd_value_signed' field in `ctf_dmdef' but I need to iterate over all `ctf_dmdef.dmd_value_signed' (in `btf_asm_type' I guess) to properly set ``info.kind_flag`` if it's a signed enumeration type. >>     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: > No, It is not right. > 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. > Totally agree. Fixed in v3. >>   } >>   /* 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. > Yes, `ctf_dtdef' is structure for each type in CTF (including enumeration), and `ctf_dmdef' keeps information for enumerator, not for the enumeration type. >> @@ -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. > Very meaningful!. I'll add use cases in v3 for both endianess. >> 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 >> >