From patchwork Fri May 19 20:49:47 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Qing Zhao X-Patchwork-Id: 96623 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b0ea:0:b0:3b6:4342:cba0 with SMTP id b10csp1512955vqo; Fri, 19 May 2023 13:51:18 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ7H/E6ODJE5S9kewetYynoAzLS0+V/aORyjUMC0Bt3HzIEoY0u+VKMG6rL6/HfdGh5r/0qW X-Received: by 2002:a17:907:3184:b0:96a:8412:a444 with SMTP id xe4-20020a170907318400b0096a8412a444mr2724582ejb.73.1684529478174; Fri, 19 May 2023 13:51:18 -0700 (PDT) Received: from sourceware.org (server2.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id i7-20020a1709067a4700b00969c8607ef5si31270ejo.1038.2023.05.19.13.51.17 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 May 2023 13:51:18 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=PhjltssA; arc=fail (signature failed); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 97DF638432D8 for ; Fri, 19 May 2023 20:50:55 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 97DF638432D8 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1684529455; bh=1csujGjNrHjgS2vJO06EgUcPmaPZD2LvOjLK+tXO+IY=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=PhjltssAUecGtdNRJNWzirPxSvOV1GEQJ0Vkme/RpRn9gR6fm/XoUZ1oXWduRF++L MrI8skqehZu0dER4OAl+kaE1SFTn3+EWvWtyJ5bwzQxrw9uLLZ2W90QopFqXZJplvO aO99UQXuu/DjLvAL9vWfro4yqkjI6XID6EWZiteQ= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mx0b-00069f02.pphosted.com (mx0b-00069f02.pphosted.com [205.220.177.32]) by sourceware.org (Postfix) with ESMTPS id 2541D3858C41 for ; Fri, 19 May 2023 20:50:09 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 2541D3858C41 Received: from pps.filterd (m0246630.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 34JJEH22018994; Fri, 19 May 2023 20:50:06 GMT Received: from phxpaimrmta03.imrmtpd1.prodappphxaev1.oraclevcn.com (phxpaimrmta03.appoci.oracle.com [138.1.37.129]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3qj0yeb0hd-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 19 May 2023 20:50:06 +0000 Received: from pps.filterd (phxpaimrmta03.imrmtpd1.prodappphxaev1.oraclevcn.com [127.0.0.1]) by phxpaimrmta03.imrmtpd1.prodappphxaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 34JKn8Ku033918; Fri, 19 May 2023 20:50:05 GMT Received: from nam11-co1-obe.outbound.protection.outlook.com (mail-co1nam11lp2171.outbound.protection.outlook.com [104.47.56.171]) by phxpaimrmta03.imrmtpd1.prodappphxaev1.oraclevcn.com (PPS) with ESMTPS id 3qj1091ntu-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 19 May 2023 20:50:05 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=MMck4mARexioiU/sFWDoNOfNRw8Y2L08D6Aov1kkeqXyUQMUZc4B10Dos17u+feH3wPy16wVdfeFPrNwElU38Lq4W5byGEmVyY/nVTrXq/s6nAd3RxHQ06EZwQCVyIdZaqb2fQZlQtkTlAPcMo489Azg2SlZHOEREJ3rOQPyiNBTzEIttmUZ1Kgaz0jP9rGdP6L/NXAty8LrFJJCy7EMPdAtI711+7VRNsc3Q0hkdlMCcRMM0jfVlXTdBDKv4cywb7Q1MDCyMKdgebWGEI8Djydn8jkQUVu1JrXWJgL2aQFiM2OLRsGFhhRdRvP3bwDTZZuPm2VFKwKD2wagzIwSyA== 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=1csujGjNrHjgS2vJO06EgUcPmaPZD2LvOjLK+tXO+IY=; b=NhvMdm31bvlx7yErLxfBEOHFDgmM8MKKK1sm1f193hS891kW5gLac9XGOiipzmC57zRLw0APKCGc7jsYSWQRj4cHhxuuXAJdX1yC2RVfcLGiBqBYerY3djuGnUV4ujhSa8iUS5mfiMRk+SwtALcH9ovADElbAFlS9YkwTdTJYhmoPxKY/EjhcKxXWgGcGs8OB59uQKWNwn2jMiltMK+J2EnU/XUSNtQocIIXVpClldgwG4DIsQbivSS9qocqsyJnH5V9M4SMOnP0Tx90QbvNmrr72pTzQVHTTJAWGSSUkfoyhWSB0W/QJ3K9l1Nd7mBvLJkfjBLSgqtOUOzkUP8tKQ== 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 Received: from CH2PR10MB4344.namprd10.prod.outlook.com (2603:10b6:610:af::19) by PH0PR10MB7062.namprd10.prod.outlook.com (2603:10b6:510:283::20) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6411.19; Fri, 19 May 2023 20:50:02 +0000 Received: from CH2PR10MB4344.namprd10.prod.outlook.com ([fe80::7aa1:df38:105a:21fa]) by CH2PR10MB4344.namprd10.prod.outlook.com ([fe80::7aa1:df38:105a:21fa%7]) with mapi id 15.20.6411.021; Fri, 19 May 2023 20:50:02 +0000 To: joseph@codesourcery.com, richard.guenther@gmail.com, jakub@redhat.com, gcc-patches@gcc.gnu.org Cc: keescook@chromium.org, siddhesh@gotplt.org, uecker@tugraz.at, Qing Zhao Subject: [V7][PATCH 1/2] Handle component_ref to a structre/union field including flexible array member [PR101832] Date: Fri, 19 May 2023 20:49:47 +0000 Message-Id: <20230519204948.237791-2-qing.zhao@oracle.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20230519204948.237791-1-qing.zhao@oracle.com> References: <20230519204948.237791-1-qing.zhao@oracle.com> X-ClientProxiedBy: LO4P123CA0560.GBRP123.PROD.OUTLOOK.COM (2603:10a6:600:33b::18) To CH2PR10MB4344.namprd10.prod.outlook.com (2603:10b6:610:af::19) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: CH2PR10MB4344:EE_|PH0PR10MB7062:EE_ X-MS-Office365-Filtering-Correlation-Id: f56a9513-4670-4bba-bfc1-08db58aa9e1b X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 6rH9hLeIEGuGeJHNw1H6V+JxZ4w16AQ0szwNiwiCLzSNgT5OeqF8yGZEaZeNiT5LbeQs3259OaDyg64WwA9/Pqz2yf983Zx0tX6o+3HYeZcLB/odZPwH5Hx/sor/dFLmuc15bT++dj4ZE68PMl9qlo01EadrvTkoGbilvFpoZUQ4PyZFdVTAd4EaFTvXJuppu8DtnpslqdCy13kZIfe104bWr/wRyU5MFJuj08sf309W72GrIn0BPv1V9ZahMAjq2QTJhuyT54jB3PNOQIHgtpB0VV9+jXAm7y6OKO+uy66Dp0jLUSxB7xerGTCmUeJ0R5xWQ6JHhaA22IUi9ju0tSEZraHBG2b1dzokhpVg7mvlGYrrRyO/zEaUJTDewC2vsIooENE7+JMfqtPTGFVw74UVCH3uhKD15rOsK3qwbQpU3PP2/LNtdJEdBMpYAfGQpHlMLwQA/XxtuXt+2IUU/NfISPEn/SvBMusUnYOBbqT6g2U/IIAvAvEZJqiPHiAXkaY1jjAQqD4GAP+vsbadRGa3gCwT4/0qvTrXJkYPAJI= 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:(13230028)(39860400002)(396003)(346002)(136003)(376002)(366004)(451199021)(2906002)(316002)(30864003)(478600001)(41300700001)(8936002)(8676002)(4326008)(6486002)(5660300002)(44832011)(84970400001)(6666004)(66946007)(66556008)(66476007)(6512007)(1076003)(26005)(107886003)(6506007)(38100700002)(186003)(83380400001)(36756003)(2616005)(86362001); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: 7/jzpxP51b1Kr5iIUCpFlNiScGFQq63xQbZDtZjjfsjECkYSDDarUpI4+OwJgw7h0uFi2/A7pXkSiTpaOHuelitvc1OQV5f6knKl0fgVoXv423XG2c+k+dFK6LyNOzsrSbE9Ntxg00TOx7o6o5uGecJJ4zMwwpUdyV2BbsMypWG/s8S4vDWdiiBA61WOw4qeS+nC1BPmYNimyzFnVzvLV1yCV7efVQeE/FfsVcFuIpuHmw65wWJIRI4K6BI8YApQ4xpSYJUHpSNLW+LmGwTKqDryXuTHmIoy1AaEYeubfbw3s+pxZwu9AXt4mTsdWBjWf7sbT4B+1brDyyznbtLMsqzX5Cj7WQGW8fl3eFTYPJ0zZeW3Wp95l3uN5AloSnjF9gKcCb5InXPL3JJanm7otZcqsPW8a4AkzWGIuZ4/2xmg+YteG8TNkB5CGPqgQqxCCdbuV7v4cRX2wAkFhQ3oiE+R7Da8XKF7gvAeWQZXhPBjyaaZ678REcTafAkimgRbpvlW4XTcxZ7xkpnig8NtPmghCD0Mv9gNSd2kCtaEsuOAJuZekbT80fsIxy79yUceFDwZBC59Bxnn9A31FNmOuEai/gbgtueS4ajT4oBM+I+FLi8tnfHwtyVhw+1VHRtcECAkGAIRuVFlrJ6uZD/vNFsso4Hw/IOvDSNcGvLgIxwi9D3hRCObC7bKad15bXpJ2g0loqBmVEKGIZY+kXO+7LXm+NsHAVtIWOWzoH4yJGTjlnbKC4SR+hpRssK37jH4AAbr0KlfcmGOwGjWf1lNASXWDgxNTtCfx14Q8NbG4iwGGX+pNMZVg8AE/7PLn7nB5K4uGXzBZ2WUzBjnRGVXAZ0nlAp/HGxqZbMvlCwPXEGmcO4VXdnAddFYRrB33PEMuGXBotw41ErBpAs167PYO1m0V+lXf8rLdE9bQQBgOO+7JEDQiIRAs+8kmei8Z+bmyxHZd3p+V37kmCw7q2BnbTVb1paPZ6WiLe04mvsPlI1ab+7FvBSRHqXuN4/Py4eUzQzMMuDGgbZCMapiA55gS4cZDfbU1/RbhJJ7S3/3Z6RnxCQ1lGJWc+nd9xjV8rwc9tap+DGWnnzW71hmtKEDmnbRPUNh1rVbS2nOhDLhRsfI0ryQ2OqzRK4WssgAUrWY8OAgh7NFQHnfkjbdFH7oYHVswFN6RCHkdJNUWF8kREUOQ9V6CsJ1G7wuksmdBtjd8QtTP1mTVTfoYxvY0X8U5Qr6s1ESn4AzMfvwKQqhfEuezWVuV4YtAoBn/PnsG8CEPokLmISMdXjUajNfS65tfCzGJJab0B+Pp4NMatAfyne50784uKTnkDeJOl7cpOym9ftJCf8eTSL7bvxlAAKHhBo6onKrwsQGCgiz2jrVkYAQwgDYl7L6a4cxhBfBxdGlFotkWv8SV2U+DtSUp4z0xfLZPdddFR7bzk6weGnHc+jWMC4ZfJkB3eh5fHwv9i0L0t+8p6+LCZBp4ta2YIpW9yGruLD1SzLTV3urmeHvgn+/P2Np82TVWlQpvjJBO3YWumy1uk4n33yH1/XC+Nx4n6EP5AYGQud6m6o1R+tRtvD4dni4K9E2UtF8AuKYOtyj X-MS-Exchange-AntiSpam-ExternalHop-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-ExternalHop-MessageData-0: /UZWHMTyMk7AHnYF0w1iRkFapUAOm7BxICjWHH7Err2kv/4XD6Ecn4LxDjQOVOQWgWr41WRwzxosYbPHuJL/OGLJRL83jgY05EaeZrYKAJAhCW6+GieAsTA9T8soQaXgS+GruEgNE7uYkhfoKcliQN2O37AGaR3PCvotKXePnJqiSU/j9sAEYG2dgWABPDvgBxrdFhsG5mAQK8MJj9hBinC/cfGrkf0n/WtYZG8ioGIBNFkK8AHIiEVzFChzp6/oSPcodQlJ8rdCjHaTase7hCZWub5vVIuGPpLv6NGXd1hCMxKCeQZ0BvIkcQkKs1ug3h29JDiA3Eb4veuK7YPuCbUkBf+qNDZYHUqjdPudNRDVBFO+yf8Z75kE63Fi1cxR4Ov03v/C6anOzoiVsEEkKvytJPImlttxo6UbeGpBXvB9cDQs1VCM17mINQmVTpNnMk4MQ9xu1KKGDGDVYSWAVBmhOtQzwYCjHwap/mh0mVX/96k7gahf2ffCnaGBn94EWt2veG36LX+4DukjdfcCemKD378XnStkVHLmJHWI3J7F6Ih4j+pCFmajPdp5IT+8tBlJfZyqoD9Y/jnjc1PFa6zRKgiuKwNqRlYao03iLxBrglloDoX9o/hham7hV0IHf4eLOJgnJ3mj6Sqi+Qy+zUTssuxAVScJbJYlYRwsFZUMTl/9UebSgtkYOWW1mxVjSDZFIBTg4Kc4MdpuuT/JQuE173mpCK8wU5sQFeug3WVdpEQJZBgra4zZAo7/GaS/kxgIAMCPOhBKTBIWJqtB9KAOi1m5HEUO5SS+vQUvMZlcgI9vmRh4trfT46ey/+JkzNudWXfwZMU1FitlJ/L4fXF3TySBH10y7BT7PxJOEpmNhlvbmZlkR3AYRdiuT70yrgGoGP/DRJXlFhjVnFbC9QNYDJ6QGm2hfsKe7ILGvrzQtR42BggV0vrBAljHRDE8 X-OriginatorOrg: oracle.com X-MS-Exchange-CrossTenant-Network-Message-Id: f56a9513-4670-4bba-bfc1-08db58aa9e1b X-MS-Exchange-CrossTenant-AuthSource: CH2PR10MB4344.namprd10.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 19 May 2023 20:50:02.5130 (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: cp2PQlWUoCqMPrJ2wosxVMUf6NfIT6VqhX6G/1xmgM5PH+NHc9lxX9kSiNJdkZTjqtuevqSXR5FTJMUo5sw3Pg== X-MS-Exchange-Transport-CrossTenantHeadersStamped: PH0PR10MB7062 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.573,FMLib:17.11.170.22 definitions=2023-05-19_15,2023-05-17_02,2023-02-09_01 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxscore=0 phishscore=0 spamscore=0 bulkscore=0 suspectscore=0 mlxlogscore=999 adultscore=0 malwarescore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2304280000 definitions=main-2305190180 X-Proofpoint-ORIG-GUID: 0VUxcHbUqmHPTQadDKPoEMz46LmV8sZv X-Proofpoint-GUID: 0VUxcHbUqmHPTQadDKPoEMz46LmV8sZv X-Spam-Status: No, score=-11.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Qing Zhao via Gcc-patches From: Qing Zhao Reply-To: Qing Zhao Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1766357182360866328?= X-GMAIL-MSGID: =?utf-8?q?1766357182360866328?= GCC extension accepts the case when a struct with a 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/lto/ChangeLog: PR tree-optimization/101832 * lto-common.cc (compare_tree_sccs_1): Compare bit TYPE_NO_NAMED_ARGS_STDARG_P or TYPE_INCLUDE_FLEXARRAY properly for its corresponding type. gcc/ChangeLog: PR tree-optimization/101832 * print-tree.cc (print_node): Print new bit type_include_flexarray. * tree-core.h (struct tree_type_common): Use bit no_named_args_stdarg_p as type_include_flexarray for RECORD_TYPE or UNION_TYPE. * 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 bit no_named_args_stdarg_p properly for its corresponding type. * tree-streamer-out.cc (pack_ts_type_common_value_fields): Stream out bit no_named_args_stdarg_p properly for its corresponding type. * 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 | 11 ++ gcc/lto/lto-common.cc | 5 +- gcc/print-tree.cc | 5 + .../gcc.dg/builtin-object-size-pr101832.c | 134 ++++++++++++++++++ gcc/tree-core.h | 2 + gcc/tree-object-size.cc | 23 ++- gcc/tree-streamer-in.cc | 5 +- gcc/tree-streamer-out.cc | 5 +- gcc/tree.h | 7 +- 9 files changed, 192 insertions(+), 5 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 b5b491cf2da..2c620b681d9 100644 --- a/gcc/c/c-decl.cc +++ b/gcc/c/c-decl.cc @@ -9282,6 +9282,17 @@ 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 and is the last field. */ + if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE) + TYPE_INCLUDE_FLEXARRAY (t) + = is_last_field && flexible_array_member_type_p (TREE_TYPE (x)); + /* Recursively set TYPE_INCLUDE_FLEXARRAY for the context of x, t + when x is an union or record and is the last field. */ + else if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (x))) + TYPE_INCLUDE_FLEXARRAY (t) + = is_last_field && TYPE_INCLUDE_FLEXARRAY (TREE_TYPE (x)); + if (DECL_NAME (x) || RECORD_OR_UNION_TYPE_P (TREE_TYPE (x))) saw_named_field = true; diff --git a/gcc/lto/lto-common.cc b/gcc/lto/lto-common.cc index 537570204b3..35827aab075 100644 --- a/gcc/lto/lto-common.cc +++ b/gcc/lto/lto-common.cc @@ -1275,7 +1275,10 @@ compare_tree_sccs_1 (tree t1, tree t2, tree **map) if (AGGREGATE_TYPE_P (t1)) compare_values (TYPE_TYPELESS_STORAGE); compare_values (TYPE_EMPTY_P); - compare_values (TYPE_NO_NAMED_ARGS_STDARG_P); + if (FUNC_OR_METHOD_TYPE_P (t1)) + compare_values (TYPE_NO_NAMED_ARGS_STDARG_P); + if (RECORD_OR_UNION_TYPE_P (t1)) + compare_values (TYPE_INCLUDE_FLEXARRAY); compare_values (TYPE_PACKED); compare_values (TYPE_RESTRICT); compare_values (TYPE_USER_ALIGN); diff --git a/gcc/print-tree.cc b/gcc/print-tree.cc index ccecd3dc6a7..aaded53b1b1 100644 --- a/gcc/print-tree.cc +++ b/gcc/print-tree.cc @@ -632,6 +632,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 9d44c04bf03..6f33ea0db97 100644 --- a/gcc/tree-core.h +++ b/gcc/tree-core.h @@ -1712,6 +1712,8 @@ struct GTY(()) tree_type_common { unsigned typeless_storage : 1; unsigned empty_flag : 1; unsigned indivisible_p : 1; + /* TYPE_NO_NAMED_ARGS_STDARG_P for a stdarg function. + Or TYPE_INCLUDE_FLEXARRAY for RECORD_TYPE and UNION_TYPE. */ unsigned no_named_args_stdarg_p : 1; unsigned spare : 1; diff --git a/gcc/tree-object-size.cc b/gcc/tree-object-size.cc index 9a936a91983..1619d144ecd 100644 --- a/gcc/tree-object-size.cc +++ b/gcc/tree-object-size.cc @@ -633,11 +633,32 @@ 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 aggregate type, i.e, an array, + a record or a union, it will not have flexible size, + compute the object size directly. */ + if (!AGGREGATE_TYPE_P (TREE_TYPE (v))) { v = NULL_TREE; break; } + /* if the ref is to a record or union type, but the type + does not include a flexible array recursively, compute + the object size directly. */ + if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (v))) + { + if (!TYPE_INCLUDE_FLEXARRAY (TREE_TYPE (v))) + { + v = NULL_TREE; + break; + } + else + { + v = TREE_OPERAND (v, 0); + break; + } + } + /* Now the ref is to an array type. */ + gcc_assert (TREE_CODE (TREE_TYPE (v)) == 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))) diff --git a/gcc/tree-streamer-in.cc b/gcc/tree-streamer-in.cc index c803800862c..1b11e5a1bae 100644 --- a/gcc/tree-streamer-in.cc +++ b/gcc/tree-streamer-in.cc @@ -386,7 +386,10 @@ unpack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr) if (AGGREGATE_TYPE_P (expr)) TYPE_TYPELESS_STORAGE (expr) = (unsigned) bp_unpack_value (bp, 1); TYPE_EMPTY_P (expr) = (unsigned) bp_unpack_value (bp, 1); - TYPE_NO_NAMED_ARGS_STDARG_P (expr) = (unsigned) bp_unpack_value (bp, 1); + if (FUNC_OR_METHOD_TYPE_P (expr)) + TYPE_NO_NAMED_ARGS_STDARG_P (expr) = (unsigned) bp_unpack_value (bp, 1); + if (RECORD_OR_UNION_TYPE_P (expr)) + TYPE_INCLUDE_FLEXARRAY (expr) = (unsigned) bp_unpack_value (bp, 1); TYPE_PRECISION (expr) = bp_unpack_var_len_unsigned (bp); SET_TYPE_ALIGN (expr, bp_unpack_var_len_unsigned (bp)); #ifdef ACCEL_COMPILER diff --git a/gcc/tree-streamer-out.cc b/gcc/tree-streamer-out.cc index 5751f77273b..ce1b143e1ea 100644 --- a/gcc/tree-streamer-out.cc +++ b/gcc/tree-streamer-out.cc @@ -355,7 +355,10 @@ pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr) if (AGGREGATE_TYPE_P (expr)) bp_pack_value (bp, TYPE_TYPELESS_STORAGE (expr), 1); bp_pack_value (bp, TYPE_EMPTY_P (expr), 1); - bp_pack_value (bp, TYPE_NO_NAMED_ARGS_STDARG_P (expr), 1); + if (FUNC_OR_METHOD_TYPE_P (expr)) + bp_pack_value (bp, TYPE_NO_NAMED_ARGS_STDARG_P (expr), 1); + if (RECORD_OR_UNION_TYPE_P (expr)) + bp_pack_value (bp, TYPE_INCLUDE_FLEXARRAY (expr), 1); bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr)); bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr)); } diff --git a/gcc/tree.h b/gcc/tree.h index 0b72663e6a1..237644e788e 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -786,7 +786,12 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, (...) prototype, where arguments can be accessed with va_start and va_arg), as opposed to an unprototyped function. */ #define TYPE_NO_NAMED_ARGS_STDARG_P(NODE) \ - (TYPE_CHECK (NODE)->type_common.no_named_args_stdarg_p) + (FUNC_OR_METHOD_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) \ + (RECORD_OR_UNION_CHECK (NODE)->type_common.no_named_args_stdarg_p) /* In an IDENTIFIER_NODE, this means that assemble_name was called with this string as an argument. */