From patchwork Tue Oct 12 22:51:45 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Qing Zhao X-Patchwork-Id: 46145 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id EBC623858C3A for ; Tue, 12 Oct 2021 22:53:03 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org EBC623858C3A DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1634079184; bh=7Ahr+3oZcG24R+JgQc4+ueRc+MNJN5tKK0rrECOCA6E=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:Cc:From; b=J0y6Wi0H+atn9RN2dbvlOcoAYhnTr48eFpOjJFg+MMBVPGrx+05nLn5w4gkRttiub hcCV+BlVtSLmStnYfvIsLFLhusmGXBy1jA6S+j1wr7VYYDWsgesGPWN8vMvT4RIZl6 0d46ExyvKzYFUELrsEELY722SjHwGlXj2KTth6jU= 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 C85653858426 for ; Tue, 12 Oct 2021 22:51:50 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org C85653858426 Received: from pps.filterd (m0246630.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.16.1.2/8.16.1.2) with SMTP id 19CMd2fr028773; Tue, 12 Oct 2021 22:51:50 GMT Received: from aserp3030.oracle.com (aserp3030.oracle.com [141.146.126.71]) by mx0b-00069f02.pphosted.com with ESMTP id 3bnkbh01f6-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Tue, 12 Oct 2021 22:51:49 +0000 Received: from pps.filterd (aserp3030.oracle.com [127.0.0.1]) by aserp3030.oracle.com (8.16.1.2/8.16.1.2) with SMTP id 19CMoSkc057442; Tue, 12 Oct 2021 22:51:49 GMT Received: from nam04-mw2-obe.outbound.protection.outlook.com (mail-mw2nam08lp2172.outbound.protection.outlook.com [104.47.73.172]) by aserp3030.oracle.com with ESMTP id 3bkyxsgnu1-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Tue, 12 Oct 2021 22:51:49 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=GmcwXbPRVs4TvD6pJujxjbRp7GBhz1qcgD6Xchtji+gmUbsdkw0G+6Bd+AF7LCyzjim77o1PngY95ljDGf6URkJu9sPMU7+Lk1MQqetXRUxTEd9qGwrRsqCxS1zjLxU4iheZv6tAqvWy95dixmY87oB6QL5B2rsHwZH20iGQgu55CglnSvQEouuONv4ThDDm4KXEC9gROOkEsHm0uIOyFMiBRUUVbt7mADA4qT7W0VyC2GOMnCcYTwCx1N4xf7IeEN6/GV3pULqWEHNGoQbEnoejEUz6IeYbcc0IzFPF6v0i111LINqphfi5SKy9eMpUUdjNua3D3duVKWKv2NQEpg== 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=7Ahr+3oZcG24R+JgQc4+ueRc+MNJN5tKK0rrECOCA6E=; b=Es8k9ng+rIi59sRW1Zcov+ttJPGRhf2aPkgGEn9gomOlMzmBHkvxsUb3DD++M6XKXf28Ovjxf7k5nA3StwXre2k/VQfS9N44m7msbBVdwKjzmq7GyuHTFQCaTsMMB1t+a9ELrEyVgl5PibUqbRVgBopLh1eRqYZkweGT92MO/Qp2TchwuOLWiPvjxMfjMqPwnrrgPso6VPTbmF4cXJ0owoQF7bCDvqncFgqQVKkCdnhGnvN8vIdYLlQQlllnCU1syIKMJ0Dbf04ZLvmA4oollS1w0BeTn+hrc4xYOP6KwtomLILh+DYL1Skf/cPGfIUHuSqHoygKfIi5R1kiGInv+Q== 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 CH2PR10MB3878.namprd10.prod.outlook.com (2603:10b6:610:4::15) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4587.18; Tue, 12 Oct 2021 22:51:45 +0000 Received: from CH2PR10MB4344.namprd10.prod.outlook.com ([fe80::8dd2:f5a2:23e8:1a7c]) by CH2PR10MB4344.namprd10.prod.outlook.com ([fe80::8dd2:f5a2:23e8:1a7c%6]) with mapi id 15.20.4587.026; Tue, 12 Oct 2021 22:51:45 +0000 To: richard Biener , jakub Jelinek Subject: [RFC][patch][PR102281]Clear padding for variables that are in registers Thread-Topic: [RFC][patch][PR102281]Clear padding for variables that are in registers Thread-Index: AQHXv7u7y0SgkeebZE+CRpXEVR4aFg== Date: Tue, 12 Oct 2021 22:51:45 +0000 Message-ID: <354CF088-F596-4824-BB2D-62FB2D123D50@oracle.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-mailer: Apple Mail (2.3608.120.23.2.7) x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: 96012c2b-0c68-4350-3871-08d98dd2ddb2 x-ms-traffictypediagnostic: CH2PR10MB3878: x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:9508; x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: 1qfOXdNVahchExiprKzXo2aeV2N3djBSps9GopjZeCQ0WdVyCeqUvKQ+cAWKlJauMVpslI1I3McEBpCF8yPdAGNfnaZtu7PRZ+hUkebQ7C69UbzxXcIFFGU7OFMJyWwUFIMSGew3IK+odyqxnbmU1bLqE7zBUTA4b9fLAo1yofz/ow+5K6q1bCaFgRQWnv6oWM8/4t0EPSGXSVmH7D39IS6XpUMpptsN+jZn8Ul5HvYOyKZnKo6EPeaPtY4RT6EDv7f7PMlqTbLOa7+bHV1KNOCqss97Iy04SX+hkOpGd5zfgz4CGnsIcOq+LOM+723w3Lh6vwNukX4ksiKbdEUVvxu3y53DEulU8MOo++dXpj4iaIthRkJyVC7w/bzX2v3YWp+IunrBz87Y137RvUEOumk1LXCgzzbxtC5GNqE26/YdDIBWKEnvLrQYPnlOPXEBKyxQmXwXO7Y9PFuO5NgAYFtu4fOgC7BxSHlRiOBrcNqDPrwClKV4h0vATaU/r1w66aB5C6iBUR6fWPCCS8Y2cd+rEI888ii46hLRW4ESMR3XFU5ncI7/CSoVxooXoj073y9eBAo5sjcszGtbEqzZDGo+KVqwPzP70M8EGsGDkIuPM5UaQ4YzzfnRfai5SL3sLykSL8A8qySF8Y8PFGjsGCalShOQ95YC0BVJQfCIEFtQz/40K4HkHUjs+Yghw01EkVaOLJUmRStuIUwa+4AjC9foGG+lCfyyqPLcMzxZE2nhIxnFOt8vY4Tgn6OAEJ8A7WC9lzsMbI5CbEDBbQGJeuuqqHu0PSA5O9fi6HVWekE7w9Elxdkmb4V3PupeL3Vq 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:(366004)(8936002)(71200400001)(508600001)(38070700005)(8676002)(316002)(44832011)(110136005)(4326008)(2906002)(26005)(38100700002)(122000001)(33656002)(2616005)(66446008)(6486002)(5660300002)(186003)(36756003)(83380400001)(91956017)(76116006)(86362001)(6506007)(66946007)(53546011)(64756008)(66476007)(66556008)(6512007)(45980500001); DIR:OUT; SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?utf-8?q?0xzDkij9EwuixfCNvRIRIuhjKXA5?= =?utf-8?q?8Iic/NsJ+4rrU3/adjTQptSvPt00lX3sKeSw3H8sKhS1oB3C8rvQEAb3FAKztfnQ1?= =?utf-8?q?lhFi1PjAn+BafSgyRA1fdeokRWCedAIZmjaf/ZjCF6CvcFEIZyH5pkWW4yKuyYhcT?= =?utf-8?q?IBL8tO/d9V1QvrmIBOzXMKH6pm4e3l32e+aNb2iJ+D6o+699F6wX+RhXd1XT/mjS4?= =?utf-8?q?p2QuNSCi4z7qDXoL6V88WIVivp9jEOXE7dpf9whTNUBsdCUPRW7Q3AiSXjin2Kpt4?= =?utf-8?q?A/GipgdXMsnDh0zbGridSm3sdcKtGD38ZebhnywWl3kh2jXUc+UgP862MXddqUVxN?= =?utf-8?q?xsJiaYWncrHICUlRBROWCyErElf7bbSwEOAydIi+ed1QOC52mevAuTfonWFiBClwN?= =?utf-8?q?sipdDk9AenzCDgyV0eKbq8kyeBYEcF6UpwO3LuFo6s9wfmHzy9nO6yjeNV8vpBOyV?= =?utf-8?q?KkkuF7rmFAyLdOgmg5kymWchKWRoDNtUKez7vFPRssXlP6HsNHVANp2fCCuXkK0Fy?= =?utf-8?q?i+RQor0gqdT8kgEzUTPsQdPvt7KVokYNClSOE4Au9fNOtTekSC8HPEuRMBRxFvJpC?= =?utf-8?q?guIcUg/LzBo+uvtg5OC3TGtTAHd7d92yN5WhdwEkfdcoobojAj/jEZpKQGFCI+dki?= =?utf-8?q?j4Kh1lQMq4OapEuQ7unWyBFA6W8yHTUlUHsV4kPqdFhsHlOlHqd9qEuiEKR/llfEk?= =?utf-8?q?kh8f+CQkCB75IA3IesDUQoyfx6Vv4iF4H105aWOPJuZUF1zgWiydeOqbzf+t1lN2W?= =?utf-8?q?WVvqDKUJaVz69g+FrTBe1Q+XW+yque4Cgf2/Jl0Bf4StZXAd13h/kZ7ipEt15eK/s?= =?utf-8?q?Z1QjZFGB7ag2+j3ejAKmzBZSs+SbHTJ5Qj3rTppNqATYxlvst5wnMkauMVZB3V2+7?= =?utf-8?q?PJnZC7PWu8MmvnazaQEp2DMu5Tt8k6Fs2/6Bkq7gFNtz/76Jzpme7MhN94CNlbrb2?= =?utf-8?q?8LuVQeBZOG9XbtTwQUwXtL+PdSGoXNapgtAwx4PAdEp0Jf72V7SGreSRFOHdlyrk0?= =?utf-8?q?IKmSMv+wV/Yqnttf/PwqUXt43PRHx3M1icrFNHAuFDYlmE4E6exM1u39kz5O0d7sR?= =?utf-8?q?4c6L4iBdnCGYpbCcla0AiZmYd+LkkLYAgqDwoyntC0kx9knAQX0kGuRLmpgvAdXWI?= =?utf-8?q?1mcuYranymCgSye3GkrdPO0E4WooCE8zxaXheZK7MGxVUYnfMyWcm0wEt7Ltxr0iu?= =?utf-8?q?Gd/Llwo7QtQMY1soksURZQtV233W/68NIexpxiaMkFum9+tOkrrOEmYzpvrMDH1qA?= =?utf-8?q?o+I0trA3N4iLa0oL?= x-ms-exchange-transport-forked: True Content-ID: <11C6368F9DDFC4488855D3549F3D39CA@namprd10.prod.outlook.com> MIME-Version: 1.0 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: 96012c2b-0c68-4350-3871-08d98dd2ddb2 X-MS-Exchange-CrossTenant-originalarrivaltime: 12 Oct 2021 22:51:45.0215 (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: JU+5D9Q3i+zoLQi92J/s3q+8PvSRErgrwHINj+M9/xXwaxWj7pC0BYQ6vY/eCh3ZlOkLW3cAB6p7PomAZq68jg== X-MS-Exchange-Transport-CrossTenantHeadersStamped: CH2PR10MB3878 X-Proofpoint-Virus-Version: vendor=nai engine=6300 definitions=10135 signatures=668683 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 spamscore=0 phishscore=0 suspectscore=0 mlxlogscore=999 mlxscore=0 bulkscore=0 adultscore=0 malwarescore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2109230001 definitions=main-2110120121 X-Proofpoint-GUID: jReOJuairdnGtpnRQvVlPTEiITFDgi-l X-Proofpoint-ORIG-GUID: jReOJuairdnGtpnRQvVlPTEiITFDgi-l 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, KAM_SHORT, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_BL, RCVD_IN_MSPIKE_L3, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) 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 Cc: gcc-patches Nick Alcock via Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" Hi, PR10228 1https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102281 Exposed an issue in the current implementation of the padding initialization of -ftrivial-auto-var-init. Currently, we add __builtin_clear_padding call _AFTER_ every explicit initialization of an auto variable: var_decl = {init_constructor}; __builtin_clear_padding (&var_decl, 0B, 1); the reason I added the call to EVERY auto variable that has explicit initialization is, the folding of __builtin_clear_padding will automatically turn this call to a NOP when there is no padding in the variable. So, we don't need to check whether the variable has padding explicitly. However, always adding the call to __builtin_clear_padding (&var_decl,…) might introduce invalid IR when VAR_DECL cannot be addressable. In order to resolve this issue, I propose the following solution: Instead of adding the call to __builtin_clear_padding _AFTER_ the explicit initialization, Using zero to initialize the whole variable BEFORE explicit fields initialization when VAR_DECL has padding, i.e: If (had_padding_p (var_decl)) var_decl = ZERO; var_decl = {init_constructor}; This should resolve the invalid IR issue. However, there might be more run time overhead from such padding initialization since the whole variable is set to zero instead of only the paddings. Please let me know you comments on this. Thanks. Qing ==================================== The complete patch is : From cb2ef83e8f53c13694c70ac4bc1df6e09b15f1c7 Mon Sep 17 00:00:00 2001 From: Qing Zhao Date: Tue, 12 Oct 2021 22:33:06 +0000 Subject: [PATCH] Fix pr102281 --- gcc/gimple-fold.c | 25 ++++++++++++++ gcc/gimple-fold.h | 1 + gcc/gimplify.c | 49 +++++++++++++++++---------- gcc/testsuite/c-c++-common/pr102281.c | 15 ++++++++ 4 files changed, 72 insertions(+), 18 deletions(-) create mode 100644 gcc/testsuite/c-c++-common/pr102281.c diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index 7fcfef41f72..de4feb27dbc 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -4651,6 +4651,31 @@ clear_padding_type_may_have_padding_p (tree type) } } +/* Return true if TYPE contains any padding bits. */ + +bool +clear_padding_type_has_padding_p (tree type) +{ + bool has_padding = false; + if (BITS_PER_UNIT == 8 + && CHAR_BIT == 8 + && clear_padding_type_may_have_padding_p (type)) + { + HOST_WIDE_INT sz = int_size_in_bytes (type), i; + gcc_assert (sz > 0); + unsigned char *buf = XALLOCAVEC (unsigned char, sz); + memset (buf, ~0, sz); + clear_type_padding_in_mask (type, buf); + for (i = 0; i < sz; i++) + if (buf[i] != (unsigned char) ~0) + { + has_padding = true; + break; + } + } + return has_padding; +} + /* Emit a runtime loop: for (; buf.base != end; buf.base += sz) __builtin_clear_padding (buf.base); */ diff --git a/gcc/gimple-fold.h b/gcc/gimple-fold.h index 397f4aeb7cf..eb750a68eca 100644 --- a/gcc/gimple-fold.h +++ b/gcc/gimple-fold.h @@ -37,6 +37,7 @@ extern tree maybe_fold_and_comparisons (tree, enum tree_code, tree, tree, extern tree maybe_fold_or_comparisons (tree, enum tree_code, tree, tree, enum tree_code, tree, tree); extern bool clear_padding_type_may_have_padding_p (tree); +extern bool clear_padding_type_has_padding_p (tree); extern void clear_type_padding_in_mask (tree, unsigned char *); extern bool optimize_atomic_compare_exchange_p (gimple *); extern void fold_builtin_atomic_compare_exchange (gimple_stmt_iterator *); diff --git a/gcc/gimplify.c b/gcc/gimplify.c index d8e4b139349..4cc3ca3ae4e 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -1955,7 +1955,8 @@ gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p) In order to make the paddings as zeroes for pattern init, We should add a call to __builtin_clear_padding to clear the paddings to zero in compatiple with CLANG. */ - if (flag_auto_var_init == AUTO_INIT_PATTERN) + if (flag_auto_var_init == AUTO_INIT_PATTERN + && clear_padding_type_has_padding_p (TREE_TYPE (decl))) gimple_add_padding_init_for_auto_var (decl, is_vla, seq_p); } } @@ -4994,9 +4995,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, tree object, ctor, type; enum gimplify_status ret; vec *elts; - bool cleared = false; - bool is_empty_ctor = false; - bool is_init_expr = (TREE_CODE (*expr_p) == INIT_EXPR); + bool need_clear_padding = false; gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR); @@ -5015,6 +5014,13 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, elts = CONSTRUCTOR_ELTS (ctor); ret = GS_ALL_DONE; + /* If the user requests to initialize automatic variables, we + should initialize paddings inside the variable. */ + if ((TREE_CODE (*expr_p) == INIT_EXPR) + && clear_padding_type_has_padding_p (type) + && is_var_need_auto_init (object)) + need_clear_padding = true; + switch (TREE_CODE (type)) { case RECORD_TYPE: @@ -5036,6 +5042,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, = TREE_THIS_VOLATILE (object) && !TREE_ADDRESSABLE (type) && vec_safe_length (elts) > 1; + bool cleared = false; struct gimplify_init_ctor_preeval_data preeval_data; HOST_WIDE_INT num_ctor_elements, num_nonzero_elements; HOST_WIDE_INT num_unique_nonzero_elements; @@ -5048,7 +5055,6 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, { if (notify_temp_creation) return GS_OK; - is_empty_ctor = true; break; } @@ -5131,6 +5137,10 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, /* If a single access to the target must be ensured and all elements are zero, then it's optimal to clear whatever their number. */ cleared = true; + else if (need_clear_padding) + /* if the padding need to be cleared, clear the whole variable + first. */ + cleared = true; else cleared = false; @@ -5266,6 +5276,14 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, if (notify_temp_creation) return GS_OK; + /* If the padding need be cleared, clear the whole variable first. */ + if (need_clear_padding) + { + tree rhs = build_zero_cst (type); + tree lhs = unshare_expr (object); + gimplify_assign (lhs, rhs, pre_p); + } + /* Extract the real and imaginary parts out of the ctor. */ gcc_assert (elts->length () == 2); r = (*elts)[0].value; @@ -5307,6 +5325,14 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, if (notify_temp_creation) return GS_OK; + /* If the padding need be cleared, clear the whole variable first. */ + if (need_clear_padding) + { + tree rhs = build_zero_cst (type); + tree lhs = unshare_expr (object); + gimplify_assign (lhs, rhs, pre_p); + } + /* Go ahead and simplify constant constructors to VECTOR_CST. */ if (TREE_CONSTANT (ctor)) { @@ -5382,19 +5408,6 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, ret = GS_ALL_DONE; } - /* If the user requests to initialize automatic variables, we - should initialize paddings inside the variable. Add a call to - __BUILTIN_CLEAR_PADDING (&object, 0, for_auto_init = true) to - initialize paddings of object always to zero regardless of - INIT_TYPE. Note, we will not insert this call if the aggregate - variable has be completely cleared already or it's initialized - with an empty constructor. */ - if (is_init_expr - && ((AGGREGATE_TYPE_P (type) && !cleared && !is_empty_ctor) - || !AGGREGATE_TYPE_P (type)) - && is_var_need_auto_init (object)) - gimple_add_padding_init_for_auto_var (object, false, pre_p); - return ret; } diff --git a/gcc/testsuite/c-c++-common/pr102281.c b/gcc/testsuite/c-c++-common/pr102281.c new file mode 100644 index 00000000000..bfe9b08524b --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr102281.c @@ -0,0 +1,15 @@ +/* PR102281 */ +/* { dg-do compile } */ +/* { dg-options "-ftrivial-auto-var-init=zero" } */ +long _mm_set_epi64x___q0; +__attribute__((__vector_size__(2 * sizeof(long)))) long long _mm_set_epi64x() { + return (__attribute__((__vector_size__(2 * sizeof(long)))) long long){ + _mm_set_epi64x___q0}; +} + +float _mm_set1_ps___F; +__attribute__((__vector_size__(4 * sizeof(float)))) float +__attribute___mm_set1_ps() { + return (__attribute__((__vector_size__(4 * sizeof(float)))) float){ + _mm_set1_ps___F}; +}