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 5DEA7385840C for ; Sat, 11 Feb 2023 00:50:42 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 5DEA7385840C 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 (m0246627.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 31B0OhM6012147; Sat, 11 Feb 2023 00:50:26 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-2022-7-12; bh=1oKS9t8b2ailpllC9KQi9JdASzX+GrxpUjWZYvl1YDU=; b=FPTVyo/GH3hg0bYW5VBvs6xZ6c8waHgLogbTAw4hmOQT36oLCVPu4zTNXuoVtQbWcMVq fLegQGRHYn43JPb1nCl/XRH2z0flaaJ2Tznurr3cPTOkv6HKywugZsJa5ulSJGUdIiJk nzjaivsvJIkFZYYvt4Ikm3bAf1PJ6qK38fHRFQm5bVfo/p/qsJFGsb26/2kcZIDmkkfg BmaXyCmdw1Z7kcvoA6YQUGM1l10vI2tTGlYwdD3TRBsazA83WzKNjt7eGpLmz66eazvi 35sYNa4ldRvcnTSW6zPB3f1eSt2UkGJlFuPHwcyhINB3cKUzZPqIV5j22csQEWOPXhQi eQ== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3nhdy1ep5t-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Sat, 11 Feb 2023 00:50:25 +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 31AM5hQO036007; Sat, 11 Feb 2023 00:50:24 GMT Received: from nam10-dm6-obe.outbound.protection.outlook.com (mail-dm6nam10lp2107.outbound.protection.outlook.com [104.47.58.107]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3nhdtha14e-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Sat, 11 Feb 2023 00:50:24 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=E3nr0FKzwT9hQprepKOz0atuPnK/v1zUFk4Vgeg62yDi8mm4n2btaBB5zWuAGEiyjZifpWQXoWJGt7eLodZlnPzxz7UN0MgSbPmxCtnhI1YbG1/jscUR+A9hf+1elVaOqa8anBg+Wo+XvxnwlJZNZw5432o6Azb/bZAlgH+Nz5W5ISFF849cuR+jEb1n+2MFqOq6HzxLmykKfj6bB6yHPcG8RE2j/fVJXXp33hJ+uoM3KCo2cyFbRpU3GlJM9U0dpfgTJR2jELWqzVOG9QQjdXh9mICAkyED/IT1Pm03cIpGNST+WLp439wCrN8kVqtiBvbt8VKykKfgKtr4OVcs0A== 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=1oKS9t8b2ailpllC9KQi9JdASzX+GrxpUjWZYvl1YDU=; b=ad5D8KcMjAkR9pxk89VeAhkWWk9xkKeXTZotmKxQ6EPGdK1d/VQ5QLm+FAvJfGUHADSKv2we1s061WDOiDGKrbDYukGnQGtZctKklWbueK53yYchjUdE3o4LSuxrYLFjzQoWcBy2335xgzLIiYap1Iw37Wf881qWqYEhP9V1EqaSNDotLXzD+pv3LY4/RcHdOdFcrFu4YZX4fP8r4Q++A4/B9VjU0LXyoqDSq4uP0y1t8fM9dTx7v9iZlnwtlwTxfzgKP98DEm4IEMuSpFMS3LRhYrI8TLsmnVPrxwna4uIs6/el5bV7JJ37E9fNVN1yuHsMtvHK9dv79le8z7xocw== 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=1oKS9t8b2ailpllC9KQi9JdASzX+GrxpUjWZYvl1YDU=; b=o74MoCvlbGqn/JqRkGSk5cemFbNzVm5YHgv4wetuqsAzuTAOa8f5JbooI2n8cERoNr2e3BXI3PETLEiPivNcL2K2Tf9LVEpQ7aIkN/otl4QnKaymeDr/TSzYrlio/0f+RwRdYJ5CZIC1cQVtdfuiN5ubfP57HSXLePIIWNSiLqM= Received: from CH2PR10MB4344.namprd10.prod.outlook.com (2603:10b6:610:af::19) by DS0PR10MB6176.namprd10.prod.outlook.com (2603:10b6:8:c0::8) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6111.7; Sat, 11 Feb 2023 00:50:22 +0000 Received: from CH2PR10MB4344.namprd10.prod.outlook.com ([fe80::7030:ed2e:20d0:cd5b]) by CH2PR10MB4344.namprd10.prod.outlook.com ([fe80::7030:ed2e:20d0:cd5b%5]) with mapi id 15.20.6111.007; Sat, 11 Feb 2023 00:50:22 +0000 From: Qing Zhao To: joseph@codesourcery.com, rguenther@suse.de Cc: siddhesh@gotplt.org, keescook@chromium.org, gcc-patches@gcc.gnu.org, Qing Zhao Subject: [v3][PATCH 1/2] Handle component_ref to a structre/union field including C99 FAM [PR101832] Date: Sat, 11 Feb 2023 00:50:12 +0000 Message-Id: <20230211005013.789161-2-qing.zhao@oracle.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20230211005013.789161-1-qing.zhao@oracle.com> References: <20230211005013.789161-1-qing.zhao@oracle.com> Content-Transfer-Encoding: 8bit Content-Type: text/plain X-ClientProxiedBy: SA0PR11CA0071.namprd11.prod.outlook.com (2603:10b6:806:d2::16) To CH2PR10MB4344.namprd10.prod.outlook.com (2603:10b6:610:af::19) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: CH2PR10MB4344:EE_|DS0PR10MB6176:EE_ X-MS-Office365-Filtering-Correlation-Id: e67523b4-3ba8-40f7-9b6f-08db0bc9f485 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: i9tC8q4sFiKPMi48UFe4OsymiuCt9kjcAjhyNNMvOKxA19fIt7yYBhCUvLdJqn97MFKi2JYDMwuPrPEUYtv8miDPXkR4m2il40NVOSDuEW1ssfZl6uD6oqc8V3WlPUVCwX9fKUGfFn7Yn2Ldpsy8KmjCTKrqbUUMve64X229h2M+92QmwP3TuXXsLFVjgvq2uKx2H5r2HrFhTtmQaPIrBhZ1VeZSkNR+K9T8TM1sqpyDWd7Y5vi4f8oHbPe7CrNTr3+lPVJXRNOjQagYqoVc1n0NlBxjlkFBjbDmNFdERNqHpJ4GoDtxH1odnpUTP85V6vNy6PWp/N/pfEmu0N3mNOTPOZ6Edv3LbwfSZPCvRTj8D65c38l9wIUz2NeKJQL90i/ZLJgehLH/BxI09N6MWNR0dnOPY4jw3cQ3a3vpPcG0UebdPJRUeHeozOptBj5QqNYpIcbirXty89wwelEENfwvBzUpK2C4OuUFhZCElQsx2z4sefx9GBR6hNDXyMQxxrT5WQFydkfFwgWqj326Eb5Dbo2aOCTzeKOOAViXpGpUREpuhlRhxrLvwP/8A90CowI7SiJ5GORjo291utX6Kn/95RexkeN4WnH3Bdtd2WwOSX2tDH1/SCjT6/red1h7O7CEL7VDYi1g0cg9iWb4tmGxj1F7lpI2e9jfFY/GDQg= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:CH2PR10MB4344.namprd10.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230025)(366004)(39860400002)(136003)(346002)(396003)(376002)(451199018)(86362001)(8676002)(36756003)(30864003)(44832011)(8936002)(41300700001)(5660300002)(84970400001)(4326008)(66476007)(66556008)(66946007)(38100700002)(316002)(83380400001)(6486002)(478600001)(2616005)(2906002)(26005)(1076003)(186003)(107886003)(6666004)(6512007)(6506007);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?Bl1wbqPNyp9M2z5HgsRrGpKvLtOWL/Xlypgcje4/skKUmgqcy+GtG1fyhlvv?= =?us-ascii?Q?LO9AaWvkhI5bd1tLrCRy6d1uc/M0Wf6pTZqZpY6pd9ShP5+rwzYkMfJnogKV?= =?us-ascii?Q?3sHtoGY4zw84wYivzmRMuMrV/qsUGsuPcHArY+OrM+xxP8VAhxxpndR6u4VN?= =?us-ascii?Q?HHxBUbVOK68rFdrpjrmmB3osyIOPl3TyudkRkj+YC+rZtoONuYF4e+0+W8en?= =?us-ascii?Q?ZlXMObNQFBz/vMeBkDuJ3wvVkpmNK2wiOgkpD+blUC79WXZvwzJV8/LjWYw9?= =?us-ascii?Q?uFYN9gRyJBE2PVKHK3I7pE2CiXPFKS1SubN0/FNodP8bT5GG11bvclynxoLF?= =?us-ascii?Q?cM4nbHHt1b3wlb1Pmfds3BT15aq2rd74BT0NJhJvvgTsMT7awjtfnz64o5rF?= =?us-ascii?Q?Jq0jcYiQuBrkmyyTwxAtJdzV/+yk5n2ITIT78xG9o4o0rieMtmC3UGFBbiO0?= =?us-ascii?Q?V07zSsq7i2Bkt9N+/5ve8yzQwFIhklt3eCf16+bhWahEEcTqbQkJTOxca0fk?= =?us-ascii?Q?S6eISkWG8PjuSI4LQ/zQQTykl8E2iYNOpjpDPmrRGtZGJpgGZLVQOU19kbw4?= =?us-ascii?Q?NFJYDi4ogqI+9Oacok50E3aWreJZNF2kldKY+upLCy8L71IF5mv5g3ztp779?= =?us-ascii?Q?Ur6HXwoXmGyzxE5ImZJ+BWeor3MadteUQtmg7XCwk9Cg85rsuwUeR2Hp1tcJ?= =?us-ascii?Q?4sKSo6P/yLSK26nI+XDArrDCvYqtA1pXaqCoDwsIgF5TDtKxukGUXiV/2QKa?= =?us-ascii?Q?psQHx0FOROPwpn7tN3PBu2TokGbVUKvZECcvRxH8CT1SzMUF0ljshP97ZPPf?= =?us-ascii?Q?ETcOWR0bJFb97mJf842xI9iXV2qj1+1wjZY+vad/ygzDx5iCuRZy/tIW3w5r?= =?us-ascii?Q?FHa01Wy+ZfkQHxpJnu8MHLUsswYLo7lge4Zx3m/H9m0F5R89BjFp1q3Tf9Dq?= =?us-ascii?Q?o+nJq1uPAAQ63lJC5ReSRB3u5YV6CRe+qsaAQUN59SUJrb3gzJwvomuS+xe6?= =?us-ascii?Q?SKSB1k2j5x6eJjCgXLI5TTAnP0JrE3B0MDWnRxx2udIq2+4R47/DS7CJ0abW?= =?us-ascii?Q?X6Tnff0m0dRJegEGOwE7GcSYaXVJ4lbRCD4gVBzJA+VSCllULEf5ZqRmysiy?= =?us-ascii?Q?uvl3zhWDEjDFqMqIiUXQFc5YX6yfDckUJ2R/QsJme14j7MNhfdFOGhUC8OkH?= =?us-ascii?Q?pWQXiaqe2YyMq+U+xyN4e73tCTWxcNj5xuxQ33ZlX9Q4a/ueEVI3Zfkd9rIl?= =?us-ascii?Q?2lOSRCMbNneiTs6s85jjEG5akslmHNNJomAACmxBJeu3D7Q5ioQShNX+rWMy?= =?us-ascii?Q?BqFz/EUywpaolA4oVpL2ZhKpPBX8Krrqu4YKjNV43nnQ27Q9IztyoDdqj67z?= =?us-ascii?Q?NJwio7AJO9UtS0j+j4dtv8Y6FCPU3OKzQ4wEhrx/9RBd1U+CqOYgQPgzwQ7K?= =?us-ascii?Q?jfPhvPj3lRN4ZPXwRQ445svcRUXYlBtxpgjcE0trWVuhulboxiHYSoU8rc7s?= =?us-ascii?Q?VbLxBoXxPY95r/tfzxUrWu7oWAwzYp6Orwt22dNY0D/i1b2yohc0vTrIHii4?= =?us-ascii?Q?UcB7WmmqXgnbvC1nopE2GSsFBencZu5DSwqkrKBd?= X-MS-Exchange-AntiSpam-ExternalHop-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-ExternalHop-MessageData-0: eztDiqvijKMsBCvpBWWLcZextQNNHLNuV0E9GBOSx96xG9D9DeB4mdFt/H6HxUygEOmC0eU7Ggv0Bj1g2Vs2pDYZo3re/tszYUhoYwJJs4Dr0Zfi0hIlUHH3keQRh2dzLo0KtT/O7HDzZjZ6k00R+tfBK2KQxWL2vncx6Mny9zxpqJDt/kBqHfjoLlUaKrNurYwVf6bo+TGA0g7EucrfalIGrO4KiKtoRsHLJXAmIP4nbLw1DNl3KP+sATd6+RjIDx8HLe+YTK1evr93zv5cdaUJ4im2ARm1AxDyACcvkc5vYkXb52DsFbkkxvKk3tzn2IB2Pxpcnxj6A1pQVC2cHyUCCN7O6uJG3bK0pg96IDCV8Aep46ptKcNeWE1kJpUv/Hr/Dh5yysBWFCB0FJ55/KloXBXzdl9aamt4n4ruC8yvA+GUk0Uv5Ym5X+Xt3eC5Q0Ihd9Xg+3WIIpd2ZsPAW76DghGfgilUEiXRQMlQteACfA9mrRrb2xm/LuJt3w3rpgPK8sACbs9T1Cxpjntenzm9+vcUufU709g77QBsBK/SXrRRagyFnPeDeDEdWdAwVzcytYt7I+8v/+u4gllmxto6w4w1Cf+unmxxV+bsHlL/Ans2/Dzo8pL1NubRFxRmHJLUenfxK3t7a5El3ZUH/ZpV+4Il8HdLFlnGCTiN5bQMkDQJJ/aRxnjJFxd/iJnD5FnhhYZwkxJryL0JQygwXkp4nO4z/tdwjotwyC7e6hG6ISEZusrGzhyNW6x3eCbeE1Z4kTk6NdYGQWjMs8yNHXeSKkb8FIA+h8WywH83YczsYAs+XDJRN3uKL+fHG2voK+vSAdVuTicUzvqxS1FRCoPL3i6r/v7/73foh7QqevO8w4bT4licUCXGJNv0PKdY X-OriginatorOrg: oracle.com X-MS-Exchange-CrossTenant-Network-Message-Id: e67523b4-3ba8-40f7-9b6f-08db0bc9f485 X-MS-Exchange-CrossTenant-AuthSource: CH2PR10MB4344.namprd10.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 11 Feb 2023 00:50:22.3660 (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: CIn1zjne3vrGk2dugl4UXyC8loxULndHWecMJad1+FLiwfOAyLoahzf44oapuxsQV4PJGS0nizLj6KOzT20wpQ== X-MS-Exchange-Transport-CrossTenantHeadersStamped: DS0PR10MB6176 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.170.22 definitions=2023-02-10_17,2023-02-09_03,2023-02-09_01 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 bulkscore=0 suspectscore=0 adultscore=0 malwarescore=0 mlxscore=0 phishscore=0 spamscore=0 mlxlogscore=999 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2212070000 definitions=main-2302110004 X-Proofpoint-GUID: Eu_3yNVhxR2DahJiOrNcvZtTV9EZwT3d X-Proofpoint-ORIG-GUID: Eu_3yNVhxR2DahJiOrNcvZtTV9EZwT3d X-Spam-Status: No, score=-10.7 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,KAM_STOCKGEN,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: GCC extension accepts the case when a struct with a C99 flexible array member is embedded into another struct or union (possibly recursively). __builtin_object_size should treat such struct as flexible size. gcc/c/ChangeLog: PR tree-optimization/101832 * c-decl.cc (finish_struct): Set TYPE_INCLUDE_FLEXARRAY for struct/union type. gcc/cp/ChangeLog: PR tree-optimization/101832 * module.cc (trees_out::core_bools): Stream out new bit type_include_flexarray. (trees_in::core_bools): Stream in new bit type_include_flexarray. gcc/ChangeLog: PR tree-optimization/101832 * print-tree.cc (print_node): Print new bit type_include_flexarray. * tree-core.h (struct tree_type_common): New bit type_include_flexarray. * tree-object-size.cc (addr_object_size): Handle structure/union type when it has flexible size. * tree-streamer-in.cc (unpack_ts_type_common_value_fields): Stream in new bit type_include_flexarray. * tree-streamer-out.cc (pack_ts_type_common_value_fields): Stream out new bit type_include_flexarray. * tree.h (TYPE_INCLUDE_FLEXARRAY): New macro TYPE_INCLUDE_FLEXARRAY. gcc/testsuite/ChangeLog: PR tree-optimization/101832 * gcc.dg/builtin-object-size-pr101832.c: New test. --- gcc/c/c-decl.cc | 12 ++ gcc/cp/module.cc | 2 + gcc/print-tree.cc | 5 + .../gcc.dg/builtin-object-size-pr101832.c | 134 ++++++++++++++++++ gcc/tree-core.h | 4 +- gcc/tree-object-size.cc | 79 +++++++---- gcc/tree-streamer-in.cc | 1 + gcc/tree-streamer-out.cc | 1 + gcc/tree.h | 6 + 9 files changed, 215 insertions(+), 29 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/builtin-object-size-pr101832.c diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc index 20e7d1855bf..741a37560b0 100644 --- a/gcc/c/c-decl.cc +++ b/gcc/c/c-decl.cc @@ -9277,6 +9277,18 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes, /* Set DECL_NOT_FLEXARRAY flag for FIELD_DECL x. */ DECL_NOT_FLEXARRAY (x) = !is_flexible_array_member_p (is_last_field, x); + /* Set TYPE_INCLUDE_FLEXARRAY for the context of x, t + * when x is an array. */ + if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE) + TYPE_INCLUDE_FLEXARRAY (t) = flexible_array_member_type_p (TREE_TYPE (x)) ; + /* Recursively set TYPE_INCLUDE_FLEXARRAY for the context of x, t + when x is the last field. */ + else if ((TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE + || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE) + && TYPE_INCLUDE_FLEXARRAY (TREE_TYPE (x)) + && is_last_field) + TYPE_INCLUDE_FLEXARRAY (t) = true; + if (DECL_NAME (x) || RECORD_OR_UNION_TYPE_P (TREE_TYPE (x))) saw_named_field = true; diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc index ac2fe66b080..c750361b704 100644 --- a/gcc/cp/module.cc +++ b/gcc/cp/module.cc @@ -5371,6 +5371,7 @@ trees_out::core_bools (tree t) WB (t->type_common.lang_flag_5); WB (t->type_common.lang_flag_6); WB (t->type_common.typeless_storage); + WB (t->type_common.type_include_flexarray); } if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) @@ -5551,6 +5552,7 @@ trees_in::core_bools (tree t) RB (t->type_common.lang_flag_5); RB (t->type_common.lang_flag_6); RB (t->type_common.typeless_storage); + RB (t->type_common.type_include_flexarray); } if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) diff --git a/gcc/print-tree.cc b/gcc/print-tree.cc index 1f3afcbbc86..efacdb7686f 100644 --- a/gcc/print-tree.cc +++ b/gcc/print-tree.cc @@ -631,6 +631,11 @@ print_node (FILE *file, const char *prefix, tree node, int indent, && TYPE_CXX_ODR_P (node)) fputs (" cxx-odr-p", file); + if ((code == RECORD_TYPE + || code == UNION_TYPE) + && TYPE_INCLUDE_FLEXARRAY (node)) + fputs (" include-flexarray", file); + /* The transparent-union flag is used for different things in different nodes. */ if ((code == UNION_TYPE || code == RECORD_TYPE) diff --git a/gcc/testsuite/gcc.dg/builtin-object-size-pr101832.c b/gcc/testsuite/gcc.dg/builtin-object-size-pr101832.c new file mode 100644 index 00000000000..60078e11634 --- /dev/null +++ b/gcc/testsuite/gcc.dg/builtin-object-size-pr101832.c @@ -0,0 +1,134 @@ +/* PR 101832: + GCC extension accepts the case when a struct with a C99 flexible array + member is embedded into another struct (possibly recursively). + __builtin_object_size will treat such struct as flexible size. + However, when a structure with non-C99 flexible array member, i.e, trailing + [0], [1], or [4], is embedded into anther struct, the stucture will not + be treated as flexible size. */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +#include "builtin-object-size-common.h" + +#define expect(p, _v) do { \ + size_t v = _v; \ + if (p == v) \ + __builtin_printf ("ok: %s == %zd\n", #p, p); \ + else {\ + __builtin_printf ("WAT: %s == %zd (expected %zd)\n", #p, p, v); \ + FAIL (); \ + } \ +} while (0); + + +struct A { + int n; + char data[]; +}; + +struct B { + int m; + struct A a; +}; + +struct C { + int q; + struct B b; +}; + +struct A0 { + int n; + char data[0]; +}; + +struct B0 { + int m; + struct A0 a; +}; + +struct C0 { + int q; + struct B0 b; +}; + +struct A1 { + int n; + char data[1]; +}; + +struct B1 { + int m; + struct A1 a; +}; + +struct C1 { + int q; + struct B1 b; +}; + +struct An { + int n; + char data[8]; +}; + +struct Bn { + int m; + struct An a; +}; + +struct Cn { + int q; + struct Bn b; +}; + +volatile void *magic1, *magic2; + +int main (int argc, char *argv[]) +{ + struct B *outer; + struct C *outest; + + /* Make sure optimization can't find some other object size. */ + outer = (void *)magic1; + outest = (void *)magic2; + + expect (__builtin_object_size (&outer->a, 1), -1); + expect (__builtin_object_size (&outest->b, 1), -1); + expect (__builtin_object_size (&outest->b.a, 1), -1); + + struct B0 *outer0; + struct C0 *outest0; + + /* Make sure optimization can't find some other object size. */ + outer0 = (void *)magic1; + outest0 = (void *)magic2; + + expect (__builtin_object_size (&outer0->a, 1), sizeof (outer0->a)); + expect (__builtin_object_size (&outest0->b, 1), sizeof (outest0->b)); + expect (__builtin_object_size (&outest0->b.a, 1), sizeof (outest0->b.a)); + + struct B1 *outer1; + struct C1 *outest1; + + /* Make sure optimization can't find some other object size. */ + outer1 = (void *)magic1; + outest1 = (void *)magic2; + + expect (__builtin_object_size (&outer1->a, 1), sizeof (outer1->a)); + expect (__builtin_object_size (&outest1->b, 1), sizeof (outest1->b)); + expect (__builtin_object_size (&outest1->b.a, 1), sizeof (outest1->b.a)); + + struct Bn *outern; + struct Cn *outestn; + + /* Make sure optimization can't find some other object size. */ + outern = (void *)magic1; + outestn = (void *)magic2; + + expect (__builtin_object_size (&outern->a, 1), sizeof (outern->a)); + expect (__builtin_object_size (&outestn->b, 1), sizeof (outestn->b)); + expect (__builtin_object_size (&outestn->b.a, 1), sizeof (outestn->b.a)); + + DONE (); + return 0; +} diff --git a/gcc/tree-core.h b/gcc/tree-core.h index acd8deea34e..705d5702b9c 100644 --- a/gcc/tree-core.h +++ b/gcc/tree-core.h @@ -1718,7 +1718,9 @@ struct GTY(()) tree_type_common { unsigned empty_flag : 1; unsigned indivisible_p : 1; unsigned no_named_args_stdarg_p : 1; - unsigned spare : 15; + /* TYPE_INCLUDE_FLEXARRAY flag for RECORD_TYPE and UNION_TYPE. */ + unsigned int type_include_flexarray : 1; + unsigned spare : 14; alias_set_type alias_set; tree pointer_to; diff --git a/gcc/tree-object-size.cc b/gcc/tree-object-size.cc index 9a936a91983..22b3c72ea6e 100644 --- a/gcc/tree-object-size.cc +++ b/gcc/tree-object-size.cc @@ -633,45 +633,68 @@ addr_object_size (struct object_size_info *osi, const_tree ptr, v = NULL_TREE; break; case COMPONENT_REF: - if (TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE) + /* When the ref is not to an array, a record or a union, it + will not have flexible size, compute the object size + directly. */ + if ((TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE) + && (TREE_CODE (TREE_TYPE (v)) != RECORD_TYPE) + && (TREE_CODE (TREE_TYPE (v)) != UNION_TYPE)) { v = NULL_TREE; break; } - is_flexible_array_mem_ref = array_ref_flexible_size_p (v); - while (v != pt_var && TREE_CODE (v) == COMPONENT_REF) - if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) - != UNION_TYPE - && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) - != QUAL_UNION_TYPE) - break; - else - v = TREE_OPERAND (v, 0); - if (TREE_CODE (v) == COMPONENT_REF - && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) - == RECORD_TYPE) + if (TREE_CODE (TREE_TYPE (v)) == RECORD_TYPE + || TREE_CODE (TREE_TYPE (v)) == UNION_TYPE) + /* if the record or union does not include a flexible array + recursively, compute the object size directly. */ { - /* compute object size only if v is not a - flexible array member. */ - if (!is_flexible_array_mem_ref) + if (!TYPE_INCLUDE_FLEXARRAY (TREE_TYPE (v))) { v = NULL_TREE; break; } - v = TREE_OPERAND (v, 0); + else + v = TREE_OPERAND (v, 0); } - while (v != pt_var && TREE_CODE (v) == COMPONENT_REF) - if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) - != UNION_TYPE - && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) - != QUAL_UNION_TYPE) - break; - else - v = TREE_OPERAND (v, 0); - if (v != pt_var) - v = NULL_TREE; else - v = pt_var; + { + /* Now the ref is to an array type. */ + is_flexible_array_mem_ref + = array_ref_flexible_size_p (v); + while (v != pt_var && TREE_CODE (v) == COMPONENT_REF) + if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) + != UNION_TYPE + && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) + != QUAL_UNION_TYPE) + break; + else + v = TREE_OPERAND (v, 0); + if (TREE_CODE (v) == COMPONENT_REF + && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) + == RECORD_TYPE) + { + /* compute object size only if v is not a + flexible array member. */ + if (!is_flexible_array_mem_ref) + { + v = NULL_TREE; + break; + } + v = TREE_OPERAND (v, 0); + } + while (v != pt_var && TREE_CODE (v) == COMPONENT_REF) + if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) + != UNION_TYPE + && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) + != QUAL_UNION_TYPE) + break; + else + v = TREE_OPERAND (v, 0); + if (v != pt_var) + v = NULL_TREE; + else + v = pt_var; + } break; default: v = pt_var; diff --git a/gcc/tree-streamer-in.cc b/gcc/tree-streamer-in.cc index d4dc30f048f..c19ede0631d 100644 --- a/gcc/tree-streamer-in.cc +++ b/gcc/tree-streamer-in.cc @@ -390,6 +390,7 @@ unpack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr) TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1); TYPE_FINAL_P (expr) = (unsigned) bp_unpack_value (bp, 1); TYPE_CXX_ODR_P (expr) = (unsigned) bp_unpack_value (bp, 1); + TYPE_INCLUDE_FLEXARRAY (expr) = (unsigned) bp_unpack_value (bp, 1); } else if (TREE_CODE (expr) == ARRAY_TYPE) TYPE_NONALIASED_COMPONENT (expr) = (unsigned) bp_unpack_value (bp, 1); diff --git a/gcc/tree-streamer-out.cc b/gcc/tree-streamer-out.cc index d107229da5c..73e4b4e547c 100644 --- a/gcc/tree-streamer-out.cc +++ b/gcc/tree-streamer-out.cc @@ -357,6 +357,7 @@ pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr) bp_pack_value (bp, flag_wpa && TYPE_CANONICAL (expr) ? TYPE_CXX_ODR_P (TYPE_CANONICAL (expr)) : TYPE_CXX_ODR_P (expr), 1); + bp_pack_value (bp, TYPE_INCLUDE_FLEXARRAY (expr), 1); } else if (TREE_CODE (expr) == ARRAY_TYPE) bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1); diff --git a/gcc/tree.h b/gcc/tree.h index c656cd5b7bf..a27b9bb43bc 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -778,6 +778,12 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, #define TYPE_NO_NAMED_ARGS_STDARG_P(NODE) \ (TYPE_CHECK (NODE)->type_common.no_named_args_stdarg_p) +/* True if this RECORD_TYPE or UNION_TYPE includes a flexible array member + at the last field recursively. */ +#define TYPE_INCLUDE_FLEXARRAY(NODE) \ + (TYPE_CHECK (NODE)->type_common.type_include_flexarray) + + /* In an IDENTIFIER_NODE, this means that assemble_name was called with this string as an argument. */ #define TREE_SYMBOL_REFERENCED(NODE) \ -- 2.31.1