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 DC1BD3858D32 for ; Tue, 18 Oct 2022 21:41:05 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org DC1BD3858D32 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 (m0246632.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 29IKwxfd003427 for ; Tue, 18 Oct 2022 21:41:05 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=rKJNIHhyg55HYO4WuvpeZf7r/YShqs+l6OmDuJNoeQQ=; b=qKoBgy6U+lamqYViOIZI/qZ6Hl3zhA41+4CPMchY7ecNiqPawZB6NluXt8AdhtcpCk28 AWyF9b2Dc4teBBbbrBAUKOSslS/G876vbjKpQl197jTCKdSxZWr4nUZVJgoGTQJXjndT Fh5TOzD3JfE2bKHudCx+VF7ayJHeSwUrLFPhYI5ElGo1WtY8LOGvoLI6XMRYYxpIIoMX OO13YoaT5jDqD6jZg/RyiiIH83HbmrOKOFIld/sH8qKSv0LDKXrsQbJCdO3FrcMh2Mdg qb2RWt85r29ivgyKvn/IuVQ+VznPUkwgZAhC5rPac5EkUrM9D2eGdXIXZbw6HYrRg92i Zg== Received: from phxpaimrmta02.imrmtpd1.prodappphxaev1.oraclevcn.com (phxpaimrmta02.appoci.oracle.com [147.154.114.232]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3k7mu00ays-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Tue, 18 Oct 2022 21:41:04 +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 29IJtbrl031343 for ; Tue, 18 Oct 2022 21:41:04 GMT Received: from nam12-dm6-obe.outbound.protection.outlook.com (mail-dm6nam12lp2175.outbound.protection.outlook.com [104.47.59.175]) by phxpaimrmta02.imrmtpd1.prodappphxaev1.oraclevcn.com (PPS) with ESMTPS id 3k8j0r35tn-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Tue, 18 Oct 2022 21:41:03 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=gGHt9d8kOHTjb+8DOigiUHiCM65g9cHPCwtN0YRP36KIrYZO6qCK2Z4z6HQR4+L4DfHUlyBU2bzy4upMI32i2xiCbBxK+80cXkUkU+aFaq0caWVLNy6cep1S8NH6dfOpkrfjJgj6ttQwnM7WseA4mqEQ7jstQsqiPe1BPk6pp/faPsdLM+X4H2yKR78Igbe2TlOGl0gxZFMEl6VNuLvfSWiOvbVJxcIEr9fBpGpCsXrB49zzJNsy7g7ib7eURYxC7yo1+AIgK9BSEkDycNyTnO8pmk8NkHbRSuDFUaJe3C6Fwo69i1HoSD6en+PvF9od5q3X398XxahztsyXvJYyXw== 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=rKJNIHhyg55HYO4WuvpeZf7r/YShqs+l6OmDuJNoeQQ=; b=FWyRHhxYP8dSk06lYbSsot0DNKpiCOf5ih3PDZ1tR1h2jWz2k+FrFXce2nNO6ePjgrQe4/54XOIVlzweGUAWmxALCtfi9DQ9rynB5rcxekfzJK4FFvOYmCm2IlF7/Ul6q0+rE+qlyIhMKZVx8EMPkxwDIPhn96zWvSWyk67e0apHTRhzLf9RE9LmiQ/TdeFv8E4Vy2w1iGlpw3NEmMOsivRwoiTy7CteUlUeP4fnGZzpp9KAzZqIgc2hDFiT2l0E2p4zMVbJ07N2N/706lWXxL5wVLn9kXFdKNOAvewejUS3VELgUO4aumrvm3AXRWAahQKaZoMP5r8pQVRCl5lbzQ== 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=rKJNIHhyg55HYO4WuvpeZf7r/YShqs+l6OmDuJNoeQQ=; b=ZMAuuywVitF59944uMcblfVmr2cT0zvt+ioEKLMJaNhmTVwPEm9XuHMRz2sriNQ8on3IjPKkD8PVE+uQIiWmJFrf7FGou/wf1WZpOlyOVMKlqvESYdE6ZllAOeSCme0vqYOr87KG5k6AuWEOTL93eNBlfWaFIDyMR8syOVKIVt0= Received: from MWHPR1001MB2158.namprd10.prod.outlook.com (2603:10b6:301:2d::17) by SA1PR10MB6469.namprd10.prod.outlook.com (2603:10b6:806:29d::8) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5723.33; Tue, 18 Oct 2022 21:41:01 +0000 Received: from MWHPR1001MB2158.namprd10.prod.outlook.com ([fe80::a505:15c2:a248:efa2]) by MWHPR1001MB2158.namprd10.prod.outlook.com ([fe80::a505:15c2:a248:efa2%7]) with mapi id 15.20.5723.033; Tue, 18 Oct 2022 21:41:01 +0000 Subject: Re: [PATCH v3] btf: Add support to BTF_KIND_ENUM64 type To: "Guillermo E. Martinez" , gcc-patches@gcc.gnu.org Cc: david.faust@oracle.com References: <20220928211501.2647123-1-guillermo.e.martinez@oracle.com> <20221015035548.274704-1-guillermo.e.martinez@oracle.com> From: Indu Bhagat Message-ID: <89f6eab1-aaf7-2f54-f3e5-c3618603cfc2@oracle.com> Date: Tue, 18 Oct 2022 14:40:59 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.6.1 In-Reply-To: <20221015035548.274704-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: MW2PR16CA0003.namprd16.prod.outlook.com (2603:10b6:907::16) To MWHPR1001MB2158.namprd10.prod.outlook.com (2603:10b6:301:2d::17) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: MWHPR1001MB2158:EE_|SA1PR10MB6469:EE_ X-MS-Office365-Filtering-Correlation-Id: 6418fefb-08d3-431c-ab72-08dab151735c X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: +L6oy+nk5t3Ljydwrqa+NQxBQEa3ZmeSJ5OlTOWd24nPZT4rYmDJewRqikkYl7hrzEJ727eoyKpQSRLzj/H/Affza5ik4VoXnqlWhvjOf12Pu9sQUUBXUJZtFtQJXLdQB4mA0ocA2LWffPSD9+am7Jz1r/yhKtGw9OYKbng9r4vvPIqdVzmlp1tutWw7oxf549BLBcSooYBQumH5igJ+rK4+Xi7dM5q+0CBvsR74Y8EwFg9sRLi8JzosQKaVAn6piDPXjj2Mqb9nPHMXtsKodPLUkLI1tXWDrJCge0cCnz0IBt9qPn7kepCzAZuyI8QnXGlGFFFufG8NWmKrr9DIqVz9Ivf8eYcYujB4QgYz/H2mr3o9LfiV0FZ8QKpXxrSziI20khEd2hA/y9AKmH/gi9KfFKWNqB0J8eJxrxaCJwLorhWdPKxS+cpUcsB85UoOT9D8SYOma4fzb4+62P/f8H2L1X8tQfMgktcQF5S+UJftlgXA4QxzZYNZ8OEAC7QtRh6t4m32MEpDN2rXuwCgkDeNkiiNIhvwb76rEJIVmOsPA7cfqQcBmc36Ao96505BNWMurZW3q8OSNWkyh+Ifyd8CUv6cwqOqYwmd/AoM4mWtaFMFSkikLJd1SVMzXTzwsDnTffgf0151qUS10z9c0yu+Uq1dR7GU40RYCzebX/RDHeSyqvTpxXgl5+MXaE7IIIUtFiIBl8cJE4zQQ58ZC2ft6ToMGujy8H+HhK8+nlg0kml5T0Q16xJy5hLKpl0j2vuZvv3JGL3TR4oBwNMv7vuboZTNObLmp9Ik0togGE5FQS0pUoMCJA+9r5u1lHgFXWsxfdTN9gDKOY1MPHPotcVBC2X2sjWPZfb15pmnQjw= 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)(376002)(39860400002)(396003)(346002)(451199015)(41300700001)(186003)(107886003)(2616005)(30864003)(478600001)(44832011)(86362001)(2906002)(36756003)(6506007)(6512007)(4326008)(5660300002)(8936002)(53546011)(31696002)(38100700002)(316002)(6486002)(8676002)(66556008)(66946007)(66476007)(84970400001)(83380400001)(66899015)(31686004)(43740500002)(45980500001);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?Y1FSN1B2aG5iMEVVak9ldVZKOUVNWlZVejBFcnZjbE1wdDdMMkRMQzNPOGF1?= =?utf-8?B?ZitNQ25ML0ZPWEZVMmRVVHJtNytsbENzVldib0NjMS9yQW9CemZ1OUszMzlz?= =?utf-8?B?WmpYdlp3aVE4a1lxcURMOE5kMFA3N2k3RjI2Uk5TQndhd0pmNm5vaXJNV1o3?= =?utf-8?B?QVpuSDdPa3JHYWJSZTlXSS91cnFpZ3JkenhLRmpkeE4vQ2gvSWw3TUx3STNm?= =?utf-8?B?QllYZkRIUm5URzdacjZJOUtXdWJuQ3VEWHNyT1JBZHVyRFdqZUYveGw3cHpF?= =?utf-8?B?QnJSYzZnZHE2UFNwYmIwbTJzdEhGRXBWNnBJOXVyY0FOMGFPTzhKeDJNejY0?= =?utf-8?B?OWhGYUVMdGNidG8vYUZlcEVHb0NsaVRwMHl0MjJJVlZEZnpyTkoxRFlDb2kr?= =?utf-8?B?MlRPRnQyUk9nOHB2MDhPaTYyUGUwb0Q2TGlIeHI3Wm01dGJnanB6YWJZNHg5?= =?utf-8?B?YUJHZkFrOUxTZ3J1MURKQnhCUjNlaEhkaUgrWTBqWHVRcU51NTBJNlc1UCtT?= =?utf-8?B?N0lxdXp6dDhlLzBSQkYweXNqNkI5b3owN0RFekJSSkwxWXRleVpxR1lXM2NJ?= =?utf-8?B?T1ZUa0JRVkdRbExiYjZGVlpqbFBzS2UraHFidy9WZ0ZHdmxHQkVta3hhVmVl?= =?utf-8?B?bkl6MFc0MW5XL2xUOWs3emdjV3htcFEvSVFqbUFSNm1sZ25UMHIxOUF0a0xP?= =?utf-8?B?MEhmZm9JVmpqR1hLRG1DT1BoUk9TczdSZ0hBTlVKVUdWSFpzVTlKRjNUOXhx?= =?utf-8?B?bnJ2M0NSamoxVnloNktTNytrYk1OTXpZRFBpWk42cEYxWS9EMlRHbjQvNjRX?= =?utf-8?B?OWYxeGMvUmVZSFFLdE5icGJROFZzeW1Hb1lWUjJCR0JLOXVKTzM3UmVTdHc3?= =?utf-8?B?RjA0bEZSaHhJOGQzRWc4K3p3aHYzSTFxaDdPeXVwRmtkRDFKNkh5NnVaaktz?= =?utf-8?B?d3V3RFZRcE9DbmlNLytVT053T21UU1g5VjdBNXpPZWNNWHJzOXJWUDFpamx3?= =?utf-8?B?NXAxek1lN1MrNklUK3lTckVTR1ZGRVJXaTBjeU1qa09lclU3VHBQU1h0TE5h?= =?utf-8?B?akdXYXZVMnhCZnlhMWVNZU5vVDRQVkM4VlhOeEF0MVBHa3o3bGtOM0JvdmxM?= =?utf-8?B?YUo3T0paRjcrMVNpYmhFcmExa1Y0dmtPT0toYnA5WGxFUlpkN0kwSjF1YzdQ?= =?utf-8?B?MG1MRm1wMnp4b0lkMENUb1BNZTQvNFcvbndFWDdOTFVrdG9QZFNoN3hWWS9Z?= =?utf-8?B?YWRRbEYwaEtJNUllbURaYXM5RWhESEhHUXFGVjhqb2pBYWo2bnFNY2hZa0U5?= =?utf-8?B?S1JWV0xXTEtOR0JaWHhvanJNYm9HMTB2VjRNeThwdHVBWW1ZYzBPZyszbzdr?= =?utf-8?B?dCt1WHhmN05ienA1VEtvVDJma1hvS3FYeVh3QUNBZHFBMkFDdlF5dFllVlBG?= =?utf-8?B?UGM5VWszNW5XY3lHTEwwU1lLOER3VE9udGN2NUN5K3hSa1p5MHNZckJ6UXJ5?= =?utf-8?B?bVFSS1lnSUpoc29DcmZhWlN3YWcrY0ZST29kNTNZeEc3SVd4UU1XZk5TYXgx?= =?utf-8?B?UUhXY2ZOSUNtcXNickpITUNwWUUyUG55NUlnalo5N2RxYnIxdUNMZFBreTdX?= =?utf-8?B?WlMwYnlYWXJmdDJXUUpuQUpBVDRGSUpaWmNyYTVDb2pVN0syYmRxVy9oeUk0?= =?utf-8?B?dGRGVE1OVTgzQmExMUZ3S1VuaGdWZDY0OXRzek8vV1dqUE1qZDBYRmZxdVBi?= =?utf-8?B?QVVXM1ZaNm11ZTVxNlNDazNVbzRxQnVQY3JlSEQ5VDlLRFU1TWFPQ1I2ZXFE?= =?utf-8?B?OHZjTkl1Vzl3bUM4T21xTGg4N3c2REtTN0htclVQQUtETUJoUU1abFQrZDdy?= =?utf-8?B?Qk9BTm9YMXNwRm0vb3hQRGdOUCtRL2VTUHh3ZkpUV2RRb1NWMEMrdkJxd3hF?= =?utf-8?B?UWk0SXVKZDhOYjJpcTBaVFp6cFBRanJxVVFmL29GMTlQaUNtY2ZoZTlHNmZk?= =?utf-8?B?eGJuYm0rNEtKdTZldFJsT3lxZ2tkNmdhOEdmK29xdEVqT21FNHYrWmVTaDMz?= =?utf-8?B?NER3M3I5ZldyNG1nL29qVS9tRktvVDhFZ2hGOU1rM25jV2FEL1BxdGJDUDlu?= =?utf-8?B?WG53QklZL0M5VTNtVnJHcGxYbzYwb0htOHBleXBWanArclZCQ1hDVTF1SUFU?= =?utf-8?Q?IN2tcftnSRxB4nGS9lWu1HM=3D?= X-OriginatorOrg: oracle.com X-MS-Exchange-CrossTenant-Network-Message-Id: 6418fefb-08d3-431c-ab72-08dab151735c X-MS-Exchange-CrossTenant-AuthSource: MWHPR1001MB2158.namprd10.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 18 Oct 2022 21:41:01.5704 (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: Ycx47MTbvVrt6uHzxVAVdcYzDPTNY4Z3WAeyyjhMMoOZxG1zLnL29V7GF2ysNGhDffC42fBgej+TW+FRmPp7JA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: SA1PR10MB6469 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-10-18_07,2022-10-18_01,2022-06-22_01 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 spamscore=0 bulkscore=0 mlxscore=0 suspectscore=0 mlxlogscore=999 phishscore=0 malwarescore=0 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2209130000 definitions=main-2210180121 X-Proofpoint-ORIG-GUID: kxgJ6PtTtQu3Z6heyJVglhEVrRMfruSL X-Proofpoint-GUID: kxgJ6PtTtQu3Z6heyJVglhEVrRMfruSL X-Spam-Status: No, score=-13.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: Hi Guillermo, On 10/14/22 8:55 PM, Guillermo E. Martinez wrote: > Hello, > > The following is patch v3 to update BTF/CTF backend supporting > BTF_KIND_ENUM64 type. Changes from v2: > > + Add a new `dtd_enum_unsigned' field in `ctf_dtdef' to indicate > signedness of the enum type. > + Fix endianness for representing BTF enum 64-bits enumerators. > + Add {little,big}-endian testcases. > > Comments will be welcomed and appreciated!, > > Kind regards, > guillermo > > -- > > 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 dtd_enum_unsigned in ctf_dtdef structure to distinguish > when CTF enum is a signed or unsigned type, 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 enumeration type sign > using dtd_enum_unsigned field for both: BTF_KIND_ENUM{,64}. > (btf_asm_enum_const): New argument to represent the size of > the BTF enum type, writing the enumerator constant value for > 32 bits, if it's 64 bits then explicitly writes lower 32-bits > value and higher 32-bits value. > (output_asm_btf_enum_list): Add enumeration size argument. > * ctfc.cc (ctf_add_enum): New argument to represent CTF enum > basic information. > (ctf_add_generic): Use of ei_{name. size, unsigned} to build the > dtd structure containing enumeration information. > (ctf_add_enumerator): Update comment mention support for BTF > enumeration in 64-bits. > * ctfc.h (ctf_dmdef): Update dmd_value to HOST_WIDE_INT to allow > use 32/64 bits enumerators. > (ctf_enum_binfo): New type to represent CTF basic enum type > information. > (ctf_dtdef): New field to describe enum signedness. > * dwarf2ctf.cc (gen_ctf_enumeration_type): Use of ctf_enum_binfo > type to pass information to ctf_add_enum to build the enum type. > > 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-be-1.c: New testcase. > * gcc.dg/debug/btf/btf-enum64-le-1.c: New testcase. > --- > gcc/btfout.cc | 30 ++++++++++--- > gcc/ctfc.cc | 22 +++++----- > gcc/ctfc.h | 15 +++++-- > gcc/dwarf2ctf.cc | 8 +++- > gcc/testsuite/gcc.dg/debug/btf/btf-enum-1.c | 2 +- > .../gcc.dg/debug/btf/btf-enum64-be-1.c | 44 +++++++++++++++++++ > .../gcc.dg/debug/btf/btf-enum64-le-1.c | 44 +++++++++++++++++++ > include/btf.h | 19 ++++++-- > 8 files changed, 160 insertions(+), 24 deletions(-) > create mode 100644 gcc/testsuite/gcc.dg/debug/btf/btf-enum64-be-1.c > create mode 100644 gcc/testsuite/gcc.dg/debug/btf/btf-enum64-le-1.c > > diff --git a/gcc/btfout.cc b/gcc/btfout.cc > index 997a33fa089..aef9fd70a28 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->dtd_enum_unsigned > + ? BTF_KF_ENUM_UNSIGNED > + : BTF_KF_ENUM_SIGNED; > + if (dtd->dtd_data.ctti_size == 0x8) > + btf_kind = BTF_KIND_ENUM64; > + } > + > 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,19 @@ 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"); > + if (size == 4) > + dw2_asm_output_data (size, dmd->dmd_value, "bte_value"); > + else > + { > + dw2_asm_output_data (4, dmd->dmd_value & 0xffffffff, "bte_value_lo32"); > + dw2_asm_output_data (4, (dmd->dmd_value >> 32) & 0xffffffff, "bte_value_hi32"); > + } > } > > /* Asm'out a function parameter description following a BTF_KIND_FUNC_PROTO. */ > @@ -871,7 +889,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 +899,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..80322eea91a 100644 > --- a/gcc/ctfc.cc > +++ b/gcc/ctfc.cc > @@ -576,8 +576,8 @@ ctf_add_array (ctf_container_ref ctfc, uint32_t flag, const ctf_arinfo_t * arp, > } > > ctf_id_t > -ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, const char * name, > - HOST_WIDE_INT size, dw_die_ref die) > +ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, > + const ctf_enum_binfo_t *ei, dw_die_ref die) The name and size information is typically being passed via explicit arguments in the other similar APIs in this functionality. I have a slight preference towards keeping it that way when possible. So in this API ctf_add_enum, how about just adding another function argument for signedness and getting rid of the data structure ctf_enum_binfo_t altogether. What do you think ? Patch looks good to me otherwise. Thanks Indu > { > ctf_dtdef_ref dtd; > ctf_id_t type; > @@ -595,16 +595,16 @@ 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); > + type = ctf_add_generic (ctfc, flag, ei->ei_name, &dtd, die); > > dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_ENUM, flag, 0); > > /* Size in bytes should always fit, of course. > TBD WARN - warn instead? */ > - gcc_assert (size <= CTF_MAX_SIZE); > - > - dtd->dtd_data.ctti_size = size; > + gcc_assert (ei->ei_size <= CTF_MAX_SIZE); > > + dtd->dtd_data.ctti_size = ei->ei_size; > + dtd->dtd_enum_unsigned = ei->ei_unsigned; > ctfc->ctfc_num_stypes++; > > return type; > @@ -630,10 +630,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); > diff --git a/gcc/ctfc.h b/gcc/ctfc.h > index bcf3a43ae1b..d3f50454385 100644 > --- a/gcc/ctfc.h > +++ b/gcc/ctfc.h > @@ -125,6 +125,14 @@ typedef struct GTY (()) ctf_itype > > #define CTF_FUNC_VARARG 0x1 > > +/* Basic enum information to build ctf_dmdef_t type. */ > +typedef struct ctf_enum_binfo > +{ > + const char * ei_name; > + unsigned int ei_size; /* Size in bytes. */ > + bool ei_unsigned; > +} ctf_enum_binfo_t; > + > /* Struct/union/enum member definition for CTF generation. */ > > typedef struct GTY ((chain_next ("%h.dmd_next"))) ctf_dmdef > @@ -133,7 +141,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; > > @@ -162,6 +170,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. */ > + bool dtd_enum_unsigned; /* Enum signedness. */ > union GTY ((desc ("ctf_dtu_d_union_selector (&%1)"))) > { > /* struct, union, or enum. */ > @@ -405,8 +414,8 @@ extern const char * ctf_add_string (ctf_container_ref, const char *, > > 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, dw_die_ref); > +extern ctf_id_t ctf_add_enum (ctf_container_ref, uint32_t, > + const ctf_enum_binfo_t *, 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 *, > diff --git a/gcc/dwarf2ctf.cc b/gcc/dwarf2ctf.cc > index 397100004c2..56dfcadd3fb 100644 > --- a/gcc/dwarf2ctf.cc > +++ b/gcc/dwarf2ctf.cc > @@ -736,6 +736,7 @@ gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration) > { > const char *enum_name = get_AT_string (enumeration, DW_AT_name); > unsigned int bit_size = ctf_die_bitsize (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; > @@ -757,9 +758,14 @@ gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration) > bit_size = ctf_die_bitsize (type); > } > > + ctf_enum_binfo_t ei; > + ei.ei_name = enum_name; > + ei.ei_size = bit_size / 8; > + ei.ei_unsigned = (signedness == DW_ATE_unsigned); > + > /* Generate a CTF type for the enumeration. */ > enumeration_type_id = ctf_add_enum (ctfc, CTF_ADD_ROOT, > - enum_name, bit_size / 8, enumeration); > + &ei, enumeration); > > /* Process the enumerators. */ > { > 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-be-1.c b/gcc/testsuite/gcc.dg/debug/btf/btf-enum64-be-1.c > new file mode 100644 > index 00000000000..40d44556e16 > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/debug/btf/btf-enum64-be-1.c > @@ -0,0 +1,44 @@ > +/* Test BTF generation for 64 bits enums. */ > + > +/* { dg-do compile } */ > +/* { dg-options "-O0 -gbtf -dA -mbig-endian" } */ > + > +/* { 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 "\[\t \]0xffffffaa\[\t \]+\[^\n\]*bte_value_lo32" 2 } } */ > +/* { dg-final { scan-assembler-times "\[\t \]0xff\[\t \]+\[^\n\]*bte_value_hi32" 3 } } */ > +/* { 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_lo32" 9 } } */ > +/* { dg-final { scan-assembler-times "bte_value_hi32" 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; > diff --git a/gcc/testsuite/gcc.dg/debug/btf/btf-enum64-le-1.c b/gcc/testsuite/gcc.dg/debug/btf/btf-enum64-le-1.c > new file mode 100644 > index 00000000000..873a50ea174 > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/debug/btf/btf-enum64-le-1.c > @@ -0,0 +1,44 @@ > +/* Test BTF generation for 64 bits enums. */ > + > +/* { dg-do compile } */ > +/* { dg-options "-O0 -gbtf -dA -mlittle-endian" } */ > + > +/* { 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 "\[\t \]0xffffffaa\[\t \]+\[^\n\]*bte_value_lo32" 2 } } */ > +/* { dg-final { scan-assembler-times "\[\t \]0xff\[\t \]+\[^\n\]*bte_value_hi32" 3 } } */ > +/* { 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_lo32" 9 } } */ > +/* { dg-final { scan-assembler-times "bte_value_hi32" 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; > 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 >