From patchwork Thu Apr 20 14:10:24 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Qing Zhao X-Patchwork-Id: 1771465 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=aW9ncO4E; dkim-atps=neutral Received: from sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-384) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4Q2KM851fDz1ybF for ; Fri, 21 Apr 2023 00:10:59 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 01EDE3858434 for ; Thu, 20 Apr 2023 14:10:58 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 01EDE3858434 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1681999858; bh=exqPpBCsxS/UtEty8T3sOAzh6BzbfYiL49jszCeBlsI=; h=To:CC:Subject:Date:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=aW9ncO4EhqCCGLZRA2gW67BQZ++lyy7OLOgsWZxu592VfSYFPb21HEjvkFSdzA7H9 U87zxC+tw1EFjStaNhYeH9wJD0NFoBricMzKWobcY+g2NJo+FxP6Aeuat0mtpm7yvm 1nmpVuhKTblfv4XJIAUMM+h/qitpedWALYWYnwrA= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mx0a-00069f02.pphosted.com (mx0a-00069f02.pphosted.com [205.220.165.32]) by sourceware.org (Postfix) with ESMTPS id 6F97A3858C83 for ; Thu, 20 Apr 2023 14:10:32 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 6F97A3858C83 Received: from pps.filterd (m0246617.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 33KDtbpw019587; Thu, 20 Apr 2023 14:10:30 GMT Received: from iadpaimrmta02.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta02.appoci.oracle.com [147.154.18.20]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3pymfujx9e-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 20 Apr 2023 14:10:29 +0000 Received: from pps.filterd (iadpaimrmta02.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta02.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 33KCpCQm015656; Thu, 20 Apr 2023 14:10:28 GMT Received: from nam10-dm6-obe.outbound.protection.outlook.com (mail-dm6nam10lp2104.outbound.protection.outlook.com [104.47.58.104]) by iadpaimrmta02.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3pyjcebwph-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 20 Apr 2023 14:10:27 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=eZLRwijznTFTAuOasCzG+upBrLzkvLvQHx6b/LsLw6TRyfEcIrQR5WyfF4UPY4cYeqC7GEBU4RaOkcxv2fgM+GLlcPumKd36k4yixI00ot356ODZimSs/897P8FJw9HdjUviJLedalB8AO2VFiIFPvN1NxoWROrU91OJzW8uNNT5d0vO99qEuaNgZMJNCfCSFNyTqu7KXq7Vn7zh40kiXSdt820teXIAclyWD2ps6/VxDuuvAQsp6mdj9GKMuxJIwmLjAUR3zBcrpgb+tvkRxNFV9lmKmS01XyE77fIOePdmUrNhdGxOcs89DngoRRg8eXh3t2TD9bvw9lx7pZnMkw== 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=WNSekdGj+bvRdlm5QCFrBFhZu5WQz1Uq6tFYFi/Goyc=; b=ZOiPCuQxmMUZy5BBjcL/AenSKTJR0b74i5XNHqJnCMp7WTWTVDFyD9G6kV0CGmqtgY9HRIoG2zMeZu4ZCdEBi4aoXoZjNQuiUVN3pi10Uj/btM9Tkn8qkBTVQTmctz6jhqbZprbYnI5MWj7m3lFlqBgeEqN5uCXTCq7BmgeDY3TKMpi6periBh4/PLeLXqQ7LRok6ecY/wdlZ/PRn5DL8QIEOOeHLMTOIj8FSOBZ3qcAE9VP876DhsXiR+AX0OwkRmQde8DLYrn3GjEGc5lKD0ROTPOJppjNmjfiLVkszIqm/r13+FgJs9xPxvSyIdQpMypmb4mj27IEAXy0Ihn1dQ== 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 SA2PR10MB4508.namprd10.prod.outlook.com (2603:10b6:806:11d::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6319.22; Thu, 20 Apr 2023 14:10:24 +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.6319.022; Thu, 20 Apr 2023 14:10:24 +0000 To: Jakub Jelinek , gcc Patches CC: Joseph Myers , Richard Biener , Kees Cook , Siddhesh Poyarekar Subject: Ping * 3: [V6][PATCH 1/2] Handle component_ref to a structre/union field including flexible array member [PR101832] Thread-Topic: Ping * 3: [V6][PATCH 1/2] Handle component_ref to a structre/union field including flexible array member [PR101832] Thread-Index: AQHZYYzv3gONN8NQMky6yn7F/gExww== Date: Thu, 20 Apr 2023 14:10:24 +0000 Message-ID: References: <9FB1E5C7-4229-49A8-851E-8AC3B38ABC82@oracle.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-mailer: Apple Mail (2.3696.120.41.1.2) x-ms-publictraffictype: Email x-ms-traffictypediagnostic: CH2PR10MB4344:EE_|SA2PR10MB4508:EE_ x-ms-office365-filtering-correlation-id: ce21353f-57ff-46c4-38fe-08db41a8fc44 x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: rWmRQNfl0bL501qgBKZF8H4XBEQQzxPCOFuzJEIQGSNMIHD+0l5u1yCZ2Tke9RYD7mw0eq17zEN4JZBb4VmffdYIFQDlv6dh8rm6kcrlmkrXWgrgQkOCMwP4dN8mIrfqa+I1sQrUjhCVNTBxHw/cm9QqqQCMsqzYWFnfG6YkooCbJhdqd/gYsu7tJNoqfvTp5f/Fn/QXFTZfWaldOUDckwFygKoyarQbtZHp9XP2rFCVbfKgVjjNwelKevy3UOHHM5A9fzoL59wIbYqCaRkqE1tUblp+1EAk3s/7bWRAjzzkWy5zTrZv/igUI8q574ql8zoFg+0gSSPRSGfh4OqTaUgGvVGKk/6XJ4q4EBrFol50F+URdTgHu1E7i6rrKcSPEFMPuuc5O3kuqQu964/1nbw3QhLfrm1/wKgXFaV/r/VqiRJcC0ywatow7TIvv7JJaAleP/v6dtH2gSS5obBpY6tcGG/nrn5BzN0NhIjJA8G0qBu1xeSr1dtDJRgm6AKjeI2MMMoriG4Q3z7GGBpC04jiZFs5SdbF/Gmsf1+QSJAkOLNX4F1Vms8pi4S6TfRZBwuNVlzo9bYIW4KkR+r83fmuM+9s8IXJ5jTYYXH678HLbPCdGtFYD6BWMctNT+Ov2XepkmtzbBBVOd8K2rwPMng+0ttxQ1GWSkTcZMJ98dI= 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)(136003)(396003)(376002)(346002)(366004)(39860400002)(451199021)(8676002)(8936002)(122000001)(166002)(36756003)(2616005)(84970400001)(5660300002)(41300700001)(33656002)(186003)(26005)(6512007)(6506007)(38070700005)(38100700002)(30864003)(83380400001)(2906002)(44832011)(76116006)(4326008)(91956017)(316002)(64756008)(66946007)(66556008)(66476007)(66446008)(71200400001)(86362001)(54906003)(478600001)(110136005)(6486002)(45980500001); DIR:OUT; SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?utf-8?q?X0OPOIMTogP7THojZ9/4azKdPIhw?= =?utf-8?q?/cM/Ol/19uXyy2cl7cVTgPQxjVS/MZort8We8DmMIIEWEVyQ0J9OBhzYmoL/2vZjG?= =?utf-8?q?73HiYU6WHeqAJ/J1J7cUtLs864P8IPjAWF6Gi9XynmTpw+96c4A/ToM11uobMovN1?= =?utf-8?q?wJ1bANdIS7WmAA2lsT/AIdGuTOO77isNt4UTKSaAUPAup01MvmwaBIhMA+7Dz6mvm?= =?utf-8?q?6mmXRGNbrGZW3x5ebFa6tjm/oUpy6a3VouGTMQG6y6IEtGgRAF833h3dCObDvrwXl?= =?utf-8?q?HnPhP5jtH9vdVSJsGiOYeNu39JgKTP1d/Vcm/e27YzG6S+IZvfgKJdRe/wCFDrfL/?= =?utf-8?q?8WKsuc9liizwjDSC+D129Wt+taxCoESNULIz3bPBuARB+Bg50IcDdbYnUvvg+4UBb?= =?utf-8?q?hylPdLNGFrpXNKDuo9TVCIv7kDKNbWfIohdK1cZBKaowRdtCwa0ph1a+ZSP/CAaNh?= =?utf-8?q?viamffkI1OIwzR338wFjsT8A5DWNi4w1uju5Q9Bg4fPigDoWMk7JqhEaGJEqVA9Jg?= =?utf-8?q?sDGMAeBraGiS5Dy6KuaBqIzonMIrKdxqhNQ0D1+WHDUjEoIbDA0u8JKvLID99fKlW?= =?utf-8?q?xsWTieQEKmf8BCfb6/NJx834+GDQHFxZsfd6GzIAY/3L5VsIRLVF/hIbJcBt4la7M?= =?utf-8?q?ZDyQpY60KUESso/nN2L7WLUGi1ws9ErIUkrMCXqlk+pQqQqMumC1sSn0khGp1tW1b?= =?utf-8?q?zchgbygx0nJZzMPaikOYPz/CeKSDpEdpUWPUzyaB5iXg9hDDSEY9PoUjDbOIFkqBq?= =?utf-8?q?YHTAH3dEyL0pkKPJgN06vWsEHsUESavbb/AqDjcXQ+WYuUIqhMuMHqz4PDx0AfRo4?= =?utf-8?q?LdjNW1AGqcpTqECtUKJVNkp5G82Z4DQVtPQkk8HNzrdq9MZw3I8eYnjCplryudLW3?= =?utf-8?q?pEmdrHqHzDvwgyrvBhXg8Ld8JnctRpbt78z/avHo2tJMmgn8PlhL3lBnzZOHFtKyF?= =?utf-8?q?C4pSPT7Kv+x/UFzDs3g1Q0jUuNvrS6thHlxUtRupJi3Bkhjsb+7vp/3Xd4bvb5hBP?= =?utf-8?q?5NfOFx1Up7r7zH3TQ5qVpYgazi/ZTfiI04CMAzsFNE9uAs1cGb/yJ1qjKpuuNbkg9?= =?utf-8?q?i1q0RsxuNADiVfsMxkqvTb8BZ75ubRCSpcFA/VmL7AAzcRAELB7fXsOXYce/GKiyk?= =?utf-8?q?ZDhmKsBjlpUaIxN3KEHGHTLQUCbCglyQoCtHc5cCVcWCKXb0Rn4ag5gk5lysA17Rm?= =?utf-8?q?RUdG2bSi5x5fVaZDIItdbxXotvZ59j4AHSe5QsSI1zZI15L0alSxgHSejurLzrA8j?= =?utf-8?q?twYaSXVDHooHzmoa6U/lq9lXzp5xOzZsJUWnUCn7UByEru/HSgY8z3G7/j0oir85M?= =?utf-8?q?Fm58BTFt40KY44H4tEqYCp7CdYP3y+EnrauowPlQpE+lcwGyUZuIOcpDo0wIQOEDt?= =?utf-8?q?OpBbhKuktC/IZUgQkYcffxJCEg5dvbsM+BNl0vRNdL9kK2LIb0QIDNh/ulgPUHz/d?= =?utf-8?q?C9RHKnXn+IPxvJ9fq747v/fiUmdyqZZ+Z+SPAA60d5eIVjB+7+OEfIaD0A+r0EXVc?= =?utf-8?q?VPYwxzUDl5aT?= MIME-Version: 1.0 X-MS-Exchange-AntiSpam-ExternalHop-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-ExternalHop-MessageData-0: sO1JdvwOuH+t7Bu//EDktJUfawKOpjhIWgp9zEZ6QRvZxIB6mCLh2zWNAUyxmhUSLMIlilPzgv9NqLTeDAmIgk6t7pDmD534OWsXs2AbtaXgF4SU6Ppnxqqv7ORJne1YRNl7aQ0vHJ46JsWF1gez0NLrSJ/5IiaMws+QSCk1QGkHsi2Zuo+iFOaNaG84JEOXjd841FmuAWh8YRIctoQ0iV4DST2RHXIq9edHd24RWXAGFxYN2Aj43qCCY4wD/TCpP7RgAXt1KL6yRQEQw5tj1imwZuWaTBzvHGNEiIVmPFQXyyYFrZzuzcuF0aELIZxGtscDodbTQFNnuEe5gO5stSUqKVa5EEswBlKJL5QsZgyxKjHiY/X9bLqxY/VMYa6lJUc1rDa+0WT8lOwwIrXs3kgB5T7rmXXm2NvUKWloS3zqdrH9m2EW5Ld/f6L8Xn7wSIQWwlvlUDBrAX4v0drw4bBdHRjfEBdH2QevsoNTgQIGujTl6fx9MNTHuOvd9465NwtsMZ5lG77MIObnCB4pdFQqg5bsSfx9WY9xamZpSM3U5OUCUZkWC8GwwmcA3/pduBmsBQ4lqrwsSRbvLP3FPtbjewXsyPpI4uwFAFB56J5AWAQuUkD70JlDkN3lwQ0MjjtelBDVMSyF14VSvNa7u/XrWT0NVEy+KOMUZV/5AJNBu1oeUBRV6uVz4KfPDFlpr7v2/gyjTX5j9RZnczppuJwt0tWDZFeZWDdxCJRq4GtJnhKKSVAJtIeLaar1YEFLjH76nufwrN98xdGNx6kQ6+FYtMGNeShsLd0zFhpgL/gJhJW7/C6/0WgUwWBp2fz6QVcfA0dJo9xri3ddrbJgvx6zMUQehSgpl/HPnVjFJ89fGtszwQ8JIYU9dC7P6wwmKUENAAADklKOXG2j7RJbIbluu57iPBRHulU/ymhh7ls= X-OriginatorOrg: oracle.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: CH2PR10MB4344.namprd10.prod.outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: ce21353f-57ff-46c4-38fe-08db41a8fc44 X-MS-Exchange-CrossTenant-originalarrivaltime: 20 Apr 2023 14:10:24.5279 (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: RNCb7gWwHGGsCui8/UpNg5pmnsGf65GQYVvuyfmbhWnhNVQ6BClEu92BdUglNU9l7xmK2V/RYukhp5TcMXeQdA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: SA2PR10MB4508 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.942,Hydra:6.0.573,FMLib:17.11.170.22 definitions=2023-04-20_10,2023-04-20_01,2023-02-09_01 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=999 adultscore=0 phishscore=0 malwarescore=0 spamscore=0 bulkscore=0 suspectscore=0 mlxscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2303200000 definitions=main-2304200116 X-Proofpoint-GUID: UBMR-NIhxsuk_SJkCQKi1Mhbu9ODJ-nL X-Proofpoint-ORIG-GUID: UBMR-NIhxsuk_SJkCQKi1Mhbu9ODJ-nL X-Spam-Status: No, score=-10.9 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, HTML_MESSAGE, KAM_SHORT, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SCC_5_SHORT_WORD_LINES, 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-Content-Filtered-By: Mailman/MimeDel 2.1.29 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+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Hi, Is this patch ready for GCC14? Thanks. Qing Begin forwarded message: From: Qing Zhao via Gcc-patches > Subject: Fwd: [V6][PATCH 1/2] Handle component_ref to a structre/union field including flexible array member [PR101832] Date: April 11, 2023 at 9:37:18 AM EDT To: Jakub Jelinek > Cc: Joseph Myers >, Richard Biener >, kees Cook >, Siddhesh Poyarekar >, gcc Patches > Reply-To: Qing Zhao > Hi, Jakub, This is the 2nd ping to the 6th version of the patches -:) Please let me know if you have any further comments on this patch, and whether it’s Okay to commit it to trunk? Thanks a lot for the help. Qing Begin forwarded message: From: Qing Zhao via Gcc-patches > Subject: Fwd: [V6][PATCH 1/2] Handle component_ref to a structre/union field including flexible array member [PR101832] Date: April 4, 2023 at 9:06:37 AM EDT To: Jakub Jelinek > Cc: Joseph Myers >, Richard Biener >, kees Cook >, Siddhesh Poyarekar >, gcc Patches > Reply-To: Qing Zhao > Ping… Qing Begin forwarded message: From: Qing Zhao > Subject: [V6][PATCH 1/2] Handle component_ref to a structre/union field including flexible array member [PR101832] Date: March 28, 2023 at 11:49:43 AM EDT To: jakub@redhat.com, joseph@codesourcery.com Cc: richard.guenther@gmail.com, keescook@chromium.org, siddhesh@gotplt.org, gcc-patches@gcc.gnu.org, Qing Zhao > the C front-end has been approved by Joseph. Jacub, could you please eview the middle end part of the changes of this patch? The major change is in tree-object-size.cc (addr_object_size). (To use the new TYPE_INCLUDE_FLEXARRAY info). This patch is to fix PR101832(https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101832), and is needed for Linux Kernel security. It’s better to be put into GCC13. Thanks a lot! Qing ========== 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 per -fstrict-flex-arrays. 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 -- 2.31.1 diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc index e537d33f398..14c54809b9d 100644 --- a/gcc/c/c-decl.cc +++ b/gcc/c/c-decl.cc @@ -9258,6 +9258,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 882dd8971a4..9dde7118266 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 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 fd2be57b78c..83482537a6d 100644 --- a/gcc/tree-core.h +++ b/gcc/tree-core.h @@ -1717,6 +1717,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 : 15; 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 d4dc30f048f..56add06a70a 100644 --- a/gcc/tree-streamer-in.cc +++ b/gcc/tree-streamer-in.cc @@ -398,7 +398,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 d107229da5c..4a1d481015b 100644 --- a/gcc/tree-streamer-out.cc +++ b/gcc/tree-streamer-out.cc @@ -365,7 +365,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 abcdb5638d4..3ab3a3a0cc7 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. */