From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 20615 invoked by alias); 12 Jul 2019 10:08:16 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 20602 invoked by uid 89); 12 Jul 2019 10:08:16 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-10.4 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_2,GIT_PATCH_3,KAM_ASCII_DIVIDERS,SPF_PASS autolearn=ham version=3.3.1 spammy=273322, sk:compone X-HELO: mx1.suse.de Received: from mx2.suse.de (HELO mx1.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 12 Jul 2019 10:08:06 +0000 Received: from relay2.suse.de (unknown [195.135.220.254]) by mx1.suse.de (Postfix) with ESMTP id 3EE2FAE36; Fri, 12 Jul 2019 10:08:04 +0000 (UTC) Date: Fri, 12 Jul 2019 10:19:00 -0000 From: Richard Biener To: Jan Hubicka cc: gcc-patches@gcc.gnu.org, d@dcepelik.cz Subject: Re: Make nonoverlapping_component_refs_since_match_p work with non-trivial MEM_REFs and TMRs In-Reply-To: <20190711152544.pa3ynve62wzjsjzj@kam.mff.cuni.cz> Message-ID: References: <20190711135445.n75ttzdw7mxzba42@kam.mff.cuni.cz> <20190711140722.moezlw2k2fw7vfwz@kam.mff.cuni.cz> <20190711152544.pa3ynve62wzjsjzj@kam.mff.cuni.cz> User-Agent: Alpine 2.20 (LSU 67 2015-01-07) MIME-Version: 1.0 Content-Type: multipart/mixed; BOUNDARY="-1609908220-482605212-1562926084=:2976" X-SW-Source: 2019-07/txt/msg00948.txt.bz2 This message is in MIME format. The first part should be readable text, while the remaining parts are likely unreadable without MIME-aware tools. ---1609908220-482605212-1562926084=:2976 Content-Type: text/plain; charset=ISO-8859-15 Content-Transfer-Encoding: 8BIT Content-length: 4970 On Thu, 11 Jul 2019, Jan Hubicka wrote: > > > On Thu, 11 Jul 2019, Jan Hubicka wrote: > > > > > > > Hi, > > > > this patch makes nonoverlapping_component_refs_since_match_p to accept > > > > paths with non-trivial MEM_REFs and TMRs assuming that they have same > > > > semantics. > > > > > > Hmm. We'll never get any TARGET_MEM_REFs wrapped with > > > handled-components so I wonder if it makes sense to handle it in > > > nonoverlapping_component_refs_since_match_p at all. > > > > OK, that makes my life easier. Here is updated patch. > Hi, > the patch finished testing on x86_64-linux so here is with Changelog and > testcase. OK? OK. Richard. > > > * tree-ssa-alias.c (same_tmr_indexing_p): Break out from ... > (indirect_refs_may_alias_p): ... here. > (nonoverlapping_component_refs_since_match_p): Support also non-trivial > mem refs in the access paths. > Index: testsuite/gcc.dg/tree-ssa/alias-access-path-9.c > =================================================================== > --- testsuite/gcc.dg/tree-ssa/alias-access-path-9.c (nonexistent) > +++ testsuite/gcc.dg/tree-ssa/alias-access-path-9.c (working copy) > @@ -0,0 +1,44 @@ > +/* { dg-do compile } */ > +/* { dg-options "-O2 -fdump-tree-fre1" } */ > + > +/* This testcase tests nonoverlapping_component_refs_since_match_p in presence > + of non-trivial mem-refs. */ > +struct a {int a,b;}; > +struct b {struct a a[10];}; > +struct c {int c; struct b b;} c, *cptr; > + > +void > +set_a(struct a *a, int p) > +{ > + a->a=p; > +} > +void > +set_b(struct a *a, int p) > +{ > + a->b=p; > +} > +int > +get_a(struct a *a) > +{ > + return a->a; > +} > + > +int > +test(int i, int j) > +{ > + struct b *bptr = &c.b; > + set_a (&bptr->a[i], 123); > + set_b (&bptr->a[j], 124); > + return get_a (&bptr->a[i]); > +} > + > +int > +test2(int i, int j) > +{ > + struct b *bptr = &cptr->b; > + set_a (&bptr->a[i], 125); > + set_b (&bptr->a[j], 126); > + return get_a (&bptr->a[i]); > +} > +/* { dg-final { scan-tree-dump-times "return 123" 1 "fre1"} } */ > +/* { dg-final { scan-tree-dump-times "return 125" 1 "fre1"} } */ > Index: tree-ssa-alias.c > =================================================================== > --- tree-ssa-alias.c (revision 273322) > +++ tree-ssa-alias.c (working copy) > @@ -1265,20 +1265,6 @@ nonoverlapping_component_refs_since_matc > component_refs1.safe_push (ref1); > ref1 = TREE_OPERAND (ref1, 0); > } > - if (TREE_CODE (ref1) == MEM_REF && ref1 != match1) > - { > - if (!integer_zerop (TREE_OPERAND (ref1, 1))) > - { > - ++alias_stats.nonoverlapping_component_refs_since_match_p_may_alias; > - return -1; > - } > - } > - /* TODO: Handle TARGET_MEM_REF later. */ > - if (TREE_CODE (ref1) == TARGET_MEM_REF && ref1 != match1) > - { > - ++alias_stats.nonoverlapping_component_refs_since_match_p_may_alias; > - return -1; > - } > > /* Create the stack of handled components for REF2. */ > while (handled_component_p (ref2) && ref2 != match2) > @@ -1290,20 +1276,31 @@ nonoverlapping_component_refs_since_matc > component_refs2.safe_push (ref2); > ref2 = TREE_OPERAND (ref2, 0); > } > - if (TREE_CODE (ref2) == MEM_REF && ref2 != match2) > - { > - if (!integer_zerop (TREE_OPERAND (ref2, 1))) > - { > - ++alias_stats.nonoverlapping_component_refs_since_match_p_may_alias; > - return -1; > - } > - } > - if (TREE_CODE (ref2) == TARGET_MEM_REF && ref2 != match2) > + > + bool mem_ref1 = TREE_CODE (ref1) == MEM_REF && ref1 != match1; > + bool mem_ref2 = TREE_CODE (ref2) == MEM_REF && ref2 != match2; > + > + /* If only one of access paths starts with MEM_REF check that offset is 0 > + so the addresses stays the same after stripping it. > + TODO: In this case we may walk the other access path until we get same > + offset. > + > + If both starts with MEM_REF, offset has to be same. */ > + if ((mem_ref1 && !mem_ref2 && !integer_zerop (TREE_OPERAND (ref1, 1))) > + || (mem_ref2 && !mem_ref1 && !integer_zerop (TREE_OPERAND (ref2, 1))) > + || (mem_ref1 && mem_ref2 > + && !tree_int_cst_equal (TREE_OPERAND (ref1, 1), > + TREE_OPERAND (ref2, 1)))) > { > ++alias_stats.nonoverlapping_component_refs_since_match_p_may_alias; > return -1; > } > > + /* TARGET_MEM_REF are never wrapped in handled components, so we do not need > + to handle them here at all. */ > + gcc_checking_assert (TREE_CODE (ref1) != TARGET_MEM_REF > + && TREE_CODE (ref2) != TARGET_MEM_REF); > + > /* Pop the stacks in parallel and examine the COMPONENT_REFs of the same > rank. This is sufficient because we start from the same DECL and you > cannot reference several fields at a time with COMPONENT_REFs (unlike > -- Richard Biener SUSE Linux GmbH, Maxfeldstrasse 5, 90409 Nuernberg, Germany; GF: Felix Imendörffer, Mary Higgins, Sri Rasiah; HRB 21284 (AG Nürnberg) ---1609908220-482605212-1562926084=:2976--