From patchwork Fri Oct 1 17:07:49 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Julian Brown X-Patchwork-Id: 45698 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 7BBB83857007 for ; Fri, 1 Oct 2021 17:09:28 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from esa3.mentor.iphmx.com (esa3.mentor.iphmx.com [68.232.137.180]) by sourceware.org (Postfix) with ESMTPS id 457AD3857C7E for ; Fri, 1 Oct 2021 17:08:13 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 457AD3857C7E Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=codesourcery.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=mentor.com IronPort-SDR: PS8fzPsrf7m7X1tJVcw+OjNL1NqdCdP/GtpkNiP9Ljx7yeJ9FDD1i0kirVKqW6qGTwvx4/Ax+N YivyuhGrGOo8W53zRNI1S7fA6wkocbxZ+HIxMjUYTNynwL7yReWisfmIWOM9/MpoCxZ/528P79 xOOY7YkcxTAUKW2jJQ818/Dd83nanU7o8MS70dFhl26IenuYMCtLojFWyiuZkDKFQze0zI8opQ uNr7UArsGWPppGcPIkho0V0+lDixPN1+PZ61XTl2t10i+Cdbl1LgZUDsfJCARFCtpymLqe+f6U Pkqr5JEdVRPX12FyK+hBtCFL X-IronPort-AV: E=Sophos;i="5.85,339,1624348800"; d="scan'208";a="66548482" Received: from orw-gwy-01-in.mentorg.com ([192.94.38.165]) by esa3.mentor.iphmx.com with ESMTP; 01 Oct 2021 09:08:13 -0800 IronPort-SDR: hKFIWeJI0a2f6FVD3jtl0fNymQKG7nhMnoNt+/YwRzTbebF8FwniXSJ0zWxpA7UEdUKrEgh+Tg 4CqtvH/jBCVvxNaBSQ6tKWACEnMcomB68oNv72x45wh0+jNmoCOqgGjJ70Edpy7I75NXEFHF9c 6B8nTLioIaDw70zPVuaPfz9vdUOli89XiWk49UDA/3dcR8EIbU52D1OGgHhZb+wPO/Q7ZHeWxq 1cio2c5bc8QyUOpvo4vjvgbv+8UGVvxLhpXeMH76sBTttiRQYbsSdg3Hxps0b0b7Yt753nfX/e lps= From: Julian Brown To: Subject: [PATCH 02/11] Remove base_ind/base_ref handling from extract_base_bit_offset Date: Fri, 1 Oct 2021 10:07:49 -0700 Message-ID: X-Mailer: git-send-email 2.29.2 In-Reply-To: References: MIME-Version: 1.0 X-Originating-IP: [137.202.0.90] X-ClientProxiedBy: SVR-IES-MBX-07.mgc.mentorg.com (139.181.222.7) To SVR-IES-MBX-04.mgc.mentorg.com (139.181.222.4) X-Spam-Status: No, score=-11.8 required=5.0 tests=BAYES_00, GIT_PATCH_0, HEADER_FROM_DIFFERENT_DOMAINS, KAM_DMARC_STATUS, SPF_HELO_PASS, SPF_PASS, 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: , Cc: Jakub Jelinek , Thomas Schwinge Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" In preparation for follow-up patches extending struct dereference handling for OpenMP, this patch removes base_ind/base_ref handling from gimplify.c:extract_base_bit_offset. This arguably simplifies some of the code around the callers of the function also, though subsequent patches modify those parts further. OK for mainline? Thanks, Julian 2021-09-29 Julian Brown gcc/ * gimplify.c (extract_base_bit_offset): Remove BASE_IND, BASE_REF and OPENMP parameters. (strip_indirections): New function. (build_struct_group): Update calls to extract_base_bit_offset. Rearrange indirect/reference handling accordingly. Use extracted base instead of passed-in decl when grouping component accesses together. --- gcc/gimplify.c | 109 ++++++++++++++++++++++++++----------------------- 1 file changed, 57 insertions(+), 52 deletions(-) diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 92f8a7b4073..ece22b7a4ae 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -8641,9 +8641,8 @@ build_struct_comp_nodes (enum tree_code code, tree grp_start, tree grp_end, has array type, else return NULL. */ static tree -extract_base_bit_offset (tree base, tree *base_ind, tree *base_ref, - poly_int64 *bitposp, poly_offset_int *poffsetp, - tree *offsetp, bool openmp) +extract_base_bit_offset (tree base, poly_int64 *bitposp, + poly_offset_int *poffsetp, tree *offsetp) { tree offset; poly_int64 bitsize, bitpos; @@ -8651,38 +8650,12 @@ extract_base_bit_offset (tree base, tree *base_ind, tree *base_ref, int unsignedp, reversep, volatilep = 0; poly_offset_int poffset; - if (base_ind) - *base_ind = NULL_TREE; - - if (base_ref) - *base_ref = NULL_TREE; + STRIP_NOPS (base); base = get_inner_reference (base, &bitsize, &bitpos, &offset, &mode, &unsignedp, &reversep, &volatilep); - if (!openmp - && (TREE_CODE (base) == INDIRECT_REF - || (TREE_CODE (base) == MEM_REF - && integer_zerop (TREE_OPERAND (base, 1)))) - && TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0))) == POINTER_TYPE) - { - if (base_ind) - *base_ind = base; - base = TREE_OPERAND (base, 0); - } - if ((TREE_CODE (base) == INDIRECT_REF - || (TREE_CODE (base) == MEM_REF - && integer_zerop (TREE_OPERAND (base, 1)))) - && DECL_P (TREE_OPERAND (base, 0)) - && TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0))) == REFERENCE_TYPE) - { - if (base_ref) - *base_ref = base; - base = TREE_OPERAND (base, 0); - } - - if (!openmp) - STRIP_NOPS (base); + STRIP_NOPS (base); if (offset && poly_int_tree_p (offset)) { @@ -8739,6 +8712,17 @@ strip_components_and_deref (tree expr) return expr; } +static tree +strip_indirections (tree expr) +{ + while (TREE_CODE (expr) == INDIRECT_REF + || (TREE_CODE (expr) == MEM_REF + && integer_zerop (TREE_OPERAND (expr, 1)))) + expr = TREE_OPERAND (expr, 0); + + return expr; +} + /* Return TRUE if EXPR is something we will use as the base of an aggregate access, either: @@ -9232,7 +9216,7 @@ build_struct_group (struct gimplify_omp_ctx *ctx, { poly_offset_int coffset; poly_int64 cbitpos; - tree base_ind, base_ref, tree_coffset; + tree tree_coffset; tree ocd = OMP_CLAUSE_DECL (c); bool openmp = !(region_type & ORT_ACC); @@ -9242,10 +9226,25 @@ build_struct_group (struct gimplify_omp_ctx *ctx, if (TREE_CODE (ocd) == INDIRECT_REF) ocd = TREE_OPERAND (ocd, 0); - tree base = extract_base_bit_offset (ocd, &base_ind, &base_ref, &cbitpos, - &coffset, &tree_coffset, openmp); + tree base = extract_base_bit_offset (ocd, &cbitpos, &coffset, &tree_coffset); + tree sbase; - bool do_map_struct = (base == decl && !tree_coffset); + if (openmp) + { + if (TREE_CODE (base) == INDIRECT_REF + && TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0))) == REFERENCE_TYPE) + sbase = strip_indirections (base); + else + sbase = base; + } + else + { + sbase = strip_indirections (base); + + STRIP_NOPS (sbase); + } + + bool do_map_struct = (sbase == decl && !tree_coffset); /* Here, DECL is usually a DECL_P, unless we have chained indirect member accesses, e.g. mystruct->a->b. In that case it'll be the "mystruct->a" @@ -9305,19 +9304,12 @@ build_struct_group (struct gimplify_omp_ctx *ctx, OMP_CLAUSE_SET_MAP_KIND (l, k); - if (!openmp && base_ind) - OMP_CLAUSE_DECL (l) = unshare_expr (base_ind); - else if (base_ref) - OMP_CLAUSE_DECL (l) = unshare_expr (base_ref); - else - { - OMP_CLAUSE_DECL (l) = unshare_expr (decl); - if (openmp - && !DECL_P (OMP_CLAUSE_DECL (l)) - && (gimplify_expr (&OMP_CLAUSE_DECL (l), pre_p, NULL, - is_gimple_lvalue, fb_lvalue) == GS_ERROR)) - return error_mark_node; - } + OMP_CLAUSE_DECL (l) = unshare_expr (base); + if (openmp + && !DECL_P (OMP_CLAUSE_DECL (l)) + && (gimplify_expr (&OMP_CLAUSE_DECL (l), pre_p, NULL, + is_gimple_lvalue, fb_lvalue) == GS_ERROR)) + return error_mark_node; OMP_CLAUSE_SIZE (l) = (!attach ? size_int (1) : (DECL_P (OMP_CLAUSE_DECL (l)) @@ -9353,6 +9345,20 @@ build_struct_group (struct gimplify_omp_ctx *ctx, else list_p = insert_node_after (l, list_p); + bool base_ref + = (TREE_CODE (base) == INDIRECT_REF + && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0))) + == REFERENCE_TYPE) + || ((TREE_CODE (TREE_OPERAND (base, 0)) == INDIRECT_REF) + && (TREE_CODE (TREE_TYPE (TREE_OPERAND + (TREE_OPERAND (base, 0), 0))) + == REFERENCE_TYPE)))); + bool base_ind = ((TREE_CODE (base) == INDIRECT_REF + || (TREE_CODE (base) == MEM_REF + && integer_zerop (TREE_OPERAND (base, 1)))) + && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0))) + == POINTER_TYPE)); + /* Handle pointers to structs and references to structs: these cases have an additional GOMP_MAP_FIRSTPRIVATE_{REFERENCE,POINTER} node inserted after the GOMP_MAP_STRUCT node. References to pointers @@ -9485,10 +9491,9 @@ build_struct_group (struct gimplify_omp_ctx *ctx, == REFERENCE_TYPE)) sc_decl = TREE_OPERAND (sc_decl, 0); - tree base = extract_base_bit_offset (sc_decl, NULL, NULL, - &bitpos, &offset, - &tree_offset, openmp); - if (!base || !operand_equal_p (base, decl, 0)) + tree base2 = extract_base_bit_offset (sc_decl, &bitpos, &offset, + &tree_offset); + if (!base2 || !operand_equal_p (base2, base, 0)) break; if (scp) continue;