From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 28270 invoked by alias); 14 Jun 2019 11:25:00 -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 28220 invoked by uid 89); 14 Jun 2019 11:24:57 -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 autolearn=ham version=3.3.1 spammy=lunch, 12456 X-HELO: nikam.ms.mff.cuni.cz Received: from nikam.ms.mff.cuni.cz (HELO nikam.ms.mff.cuni.cz) (195.113.20.16) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 14 Jun 2019 11:24:54 +0000 Received: by nikam.ms.mff.cuni.cz (Postfix, from userid 16202) id 4FEFF282523; Fri, 14 Jun 2019 13:24:52 +0200 (CEST) Date: Fri, 14 Jun 2019 11:25:00 -0000 From: Jan Hubicka To: Richard Biener Cc: gcc-patches@gcc.gnu.org, d@dcepelik.cz, ebotcazou@adacore.com Subject: Re: Remove nonoverlapping_component_refs_of_decl_p Message-ID: <20190614112452.ydsqbo5ouxsuc2p2@kam.mff.cuni.cz> References: <20190614084950.j4vmohkzuo3ql4aa@kam.mff.cuni.cz> <20190614105656.jf4rddqhjjgrteaz@kam.mff.cuni.cz> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: User-Agent: NeoMutt/20170113 (1.7.2) X-SW-Source: 2019-06/txt/msg00826.txt.bz2 Hi, I am heading to lunch, thanks for all the reviews! This is the cut down version of patch I am testing and will be back in about an hour. Honza * tree-ssa-alias.c (alias_stats): Add nonoverlapping_component_refs_p_may_alias, nonoverlapping_component_refs_p_no_alias, nonoverlapping_component_refs_of_decl_p_may_alias, nonoverlapping_component_refs_of_decl_p_no_alias. (dump_alias_stats): Dump them. (nonoverlapping_component_refs_of_decl_p): Add stats. (nonoverlapping_component_refs_p): Add stats; do not stop on first ARRAY_REF. Index: tree-ssa-alias.c =================================================================== --- tree-ssa-alias.c (revision 272283) +++ tree-ssa-alias.c (working copy) @@ -100,6 +100,10 @@ static struct { unsigned HOST_WIDE_INT call_may_clobber_ref_p_no_alias; unsigned HOST_WIDE_INT aliasing_component_refs_p_may_alias; unsigned HOST_WIDE_INT aliasing_component_refs_p_no_alias; + unsigned HOST_WIDE_INT nonoverlapping_component_refs_p_may_alias; + unsigned HOST_WIDE_INT nonoverlapping_component_refs_p_no_alias; + unsigned HOST_WIDE_INT nonoverlapping_component_refs_of_decl_p_may_alias; + unsigned HOST_WIDE_INT nonoverlapping_component_refs_of_decl_p_no_alias; } alias_stats; void @@ -124,7 +128,19 @@ dump_alias_stats (FILE *s) alias_stats.call_may_clobber_ref_p_no_alias, alias_stats.call_may_clobber_ref_p_no_alias + alias_stats.call_may_clobber_ref_p_may_alias); - fprintf (s, " aliasing_component_ref_p: " + fprintf (s, " nonoverlapping_component_refs_p: " + HOST_WIDE_INT_PRINT_DEC" disambiguations, " + HOST_WIDE_INT_PRINT_DEC" queries\n", + alias_stats.nonoverlapping_component_refs_p_no_alias, + alias_stats.nonoverlapping_component_refs_p_no_alias + + alias_stats.nonoverlapping_component_refs_p_may_alias); + fprintf (s, " nonoverlapping_component_refs_of_decl_p: " + HOST_WIDE_INT_PRINT_DEC" disambiguations, " + HOST_WIDE_INT_PRINT_DEC" queries\n", + alias_stats.nonoverlapping_component_refs_of_decl_p_no_alias, + alias_stats.nonoverlapping_component_refs_of_decl_p_no_alias + + alias_stats.nonoverlapping_component_refs_of_decl_p_may_alias); + fprintf (s, " aliasing_component_refs_p: " HOST_WIDE_INT_PRINT_DEC" disambiguations, " HOST_WIDE_INT_PRINT_DEC" queries\n", alias_stats.aliasing_component_refs_p_no_alias, @@ -1047,7 +1063,10 @@ nonoverlapping_component_refs_of_decl_p if (TREE_CODE (ref1) == MEM_REF) { if (!integer_zerop (TREE_OPERAND (ref1, 1))) - return false; + { + ++alias_stats.nonoverlapping_component_refs_of_decl_p_may_alias; + return false; + } ref1 = TREE_OPERAND (TREE_OPERAND (ref1, 0), 0); } @@ -1060,7 +1079,10 @@ nonoverlapping_component_refs_of_decl_p if (TREE_CODE (ref2) == MEM_REF) { if (!integer_zerop (TREE_OPERAND (ref2, 1))) - return false; + { + ++alias_stats.nonoverlapping_component_refs_of_decl_p_may_alias; + return false; + } ref2 = TREE_OPERAND (TREE_OPERAND (ref2, 0), 0); } @@ -1080,7 +1102,10 @@ nonoverlapping_component_refs_of_decl_p do { if (component_refs1.is_empty ()) - return false; + { + ++alias_stats.nonoverlapping_component_refs_of_decl_p_may_alias; + return false; + } ref1 = component_refs1.pop (); } while (!RECORD_OR_UNION_TYPE_P (TREE_TYPE (TREE_OPERAND (ref1, 0)))); @@ -1088,7 +1113,10 @@ nonoverlapping_component_refs_of_decl_p do { if (component_refs2.is_empty ()) - return false; + { + ++alias_stats.nonoverlapping_component_refs_of_decl_p_may_alias; + return false; + } ref2 = component_refs2.pop (); } while (!RECORD_OR_UNION_TYPE_P (TREE_TYPE (TREE_OPERAND (ref2, 0)))); @@ -1096,7 +1124,10 @@ nonoverlapping_component_refs_of_decl_p /* Beware of BIT_FIELD_REF. */ if (TREE_CODE (ref1) != COMPONENT_REF || TREE_CODE (ref2) != COMPONENT_REF) - return false; + { + ++alias_stats.nonoverlapping_component_refs_of_decl_p_may_alias; + return false; + } tree field1 = TREE_OPERAND (ref1, 1); tree field2 = TREE_OPERAND (ref2, 1); @@ -1109,7 +1140,10 @@ nonoverlapping_component_refs_of_decl_p /* We cannot disambiguate fields in a union or qualified union. */ if (type1 != type2 || TREE_CODE (type1) != RECORD_TYPE) - return false; + { + ++alias_stats.nonoverlapping_component_refs_of_decl_p_may_alias; + return false; + } if (field1 != field2) { @@ -1117,15 +1151,23 @@ nonoverlapping_component_refs_of_decl_p same. */ if (DECL_BIT_FIELD_REPRESENTATIVE (field1) == field2 || DECL_BIT_FIELD_REPRESENTATIVE (field2) == field1) - return false; + { + ++alias_stats.nonoverlapping_component_refs_of_decl_p_may_alias; + return false; + } /* Different fields of the same record type cannot overlap. ??? Bitfields can overlap at RTL level so punt on them. */ if (DECL_BIT_FIELD (field1) && DECL_BIT_FIELD (field2)) - return false; + { + ++alias_stats.nonoverlapping_component_refs_of_decl_p_may_alias; + return false; + } + ++alias_stats.nonoverlapping_component_refs_of_decl_p_no_alias; return true; } } + ++alias_stats.nonoverlapping_component_refs_of_decl_p_may_alias; return false; } @@ -1154,17 +1196,23 @@ nonoverlapping_component_refs_p (const_t { if (!flag_strict_aliasing || !x || !y - || TREE_CODE (x) != COMPONENT_REF - || TREE_CODE (y) != COMPONENT_REF) - return false; + || !handled_component_p (x) + || !handled_component_p (y)) + { + ++alias_stats.nonoverlapping_component_refs_p_may_alias; + return false; + } auto_vec fieldsx; - while (TREE_CODE (x) == COMPONENT_REF) + while (handled_component_p (x)) { - tree field = TREE_OPERAND (x, 1); - tree type = DECL_FIELD_CONTEXT (field); - if (TREE_CODE (type) == RECORD_TYPE) - fieldsx.safe_push (field); + if (TREE_CODE (x) == COMPONENT_REF) + { + tree field = TREE_OPERAND (x, 1); + tree type = DECL_FIELD_CONTEXT (field); + if (TREE_CODE (type) == RECORD_TYPE) + fieldsx.safe_push (field); + } x = TREE_OPERAND (x, 0); } if (fieldsx.length () == 0) @@ -1172,22 +1220,39 @@ nonoverlapping_component_refs_p (const_t auto_vec fieldsy; while (TREE_CODE (y) == COMPONENT_REF) { - tree field = TREE_OPERAND (y, 1); - tree type = DECL_FIELD_CONTEXT (field); - if (TREE_CODE (type) == RECORD_TYPE) - fieldsy.safe_push (TREE_OPERAND (y, 1)); + if (TREE_CODE (y) == COMPONENT_REF) + { + tree field = TREE_OPERAND (y, 1); + tree type = DECL_FIELD_CONTEXT (field); + if (TREE_CODE (type) == RECORD_TYPE) + fieldsy.safe_push (TREE_OPERAND (y, 1)); + } y = TREE_OPERAND (y, 0); } if (fieldsy.length () == 0) - return false; + { + ++alias_stats.nonoverlapping_component_refs_p_may_alias; + return false; + } /* Most common case first. */ if (fieldsx.length () == 1 && fieldsy.length () == 1) - return ((DECL_FIELD_CONTEXT (fieldsx[0]) - == DECL_FIELD_CONTEXT (fieldsy[0])) - && fieldsx[0] != fieldsy[0] - && !(DECL_BIT_FIELD (fieldsx[0]) && DECL_BIT_FIELD (fieldsy[0]))); + { + if ((DECL_FIELD_CONTEXT (fieldsx[0]) + == DECL_FIELD_CONTEXT (fieldsy[0])) + && fieldsx[0] != fieldsy[0] + && !(DECL_BIT_FIELD (fieldsx[0]) && DECL_BIT_FIELD (fieldsy[0]))) + { + ++alias_stats.nonoverlapping_component_refs_p_no_alias; + return true; + } + else + { + ++alias_stats.nonoverlapping_component_refs_p_may_alias; + return false; + } + } if (fieldsx.length () == 2) { @@ -1222,11 +1287,18 @@ nonoverlapping_component_refs_p (const_t same. */ if (DECL_BIT_FIELD_REPRESENTATIVE (fieldx) == fieldy || DECL_BIT_FIELD_REPRESENTATIVE (fieldy) == fieldx) - return false; + { + ++alias_stats.nonoverlapping_component_refs_p_may_alias; + return false; + } /* Different fields of the same record type cannot overlap. ??? Bitfields can overlap at RTL level so punt on them. */ if (DECL_BIT_FIELD (fieldx) && DECL_BIT_FIELD (fieldy)) - return false; + { + ++alias_stats.nonoverlapping_component_refs_p_may_alias; + return false; + } + ++alias_stats.nonoverlapping_component_refs_p_no_alias; return true; } } @@ -1245,6 +1317,7 @@ nonoverlapping_component_refs_p (const_t } while (1); + ++alias_stats.nonoverlapping_component_refs_p_may_alias; return false; }