From 07c8304c06be23ce4eb580b637cda9be3784baff Mon Sep 17 00:00:00 2001 From: Jan Hubicka Date: Mon, 17 Jun 2019 15:44:58 +0200 Subject: [PATCH] tree-ssa-alias.c (aliasing_component_refs_p): Consider only the access path from base to first VIEW_CONVERT_EXPR or BIT_FIELD_REF. * tree-ssa-alias.c (aliasing_component_refs_p): Consider only the access path from base to first VIEW_CONVERT_EXPR or BIT_FIELD_REF. From-SVN: r272383 --- gcc/ChangeLog | 6 ++++++ gcc/tree-ssa-alias.c | 39 ++++++++++++++++++++++----------------- 2 files changed, 28 insertions(+), 17 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 43519721ee6..f11854438aa 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,9 @@ +2019-06-17 Jan Hubicka + + * tree-ssa-alias.c (aliasing_component_refs_p): Consider only + the access path from base to first VIEW_CONVERT_EXPR or + BIT_FIELD_REF. + 2019-06-17 Jan Hubicka * tree-ssa-alias.c (nonoverlapping_component_refs_p): Also truncate diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c index 399e06c3825..867b4cb53f2 100644 --- a/gcc/tree-ssa-alias.c +++ b/gcc/tree-ssa-alias.c @@ -874,7 +874,6 @@ aliasing_component_refs_p (tree ref1, disambiguating q->i and p->a.j. */ tree base1, base2; tree type1, type2; - tree *refp; int same_p1 = 0, same_p2 = 0; bool maybe_match = false; tree end_struct_ref1 = NULL, end_struct_ref2 = NULL; @@ -903,6 +902,9 @@ aliasing_component_refs_p (tree ref1, gcc_checking_assert (!end_struct_ref1); end_struct_ref1 = base1; } + if (TREE_CODE (base1) == VIEW_CONVERT_EXPR + || TREE_CODE (base1) == BIT_FIELD_REF) + ref1 = TREE_OPERAND (base1, 0); base1 = TREE_OPERAND (base1, 0); } type1 = TREE_TYPE (base1); @@ -918,6 +920,9 @@ aliasing_component_refs_p (tree ref1, gcc_checking_assert (!end_struct_ref2); end_struct_ref2 = base2; } + if (TREE_CODE (base2) == VIEW_CONVERT_EXPR + || TREE_CODE (base2) == BIT_FIELD_REF) + ref2 = TREE_OPERAND (base2, 0); base2 = TREE_OPERAND (base2, 0); } type2 = TREE_TYPE (base2); @@ -934,23 +939,23 @@ aliasing_component_refs_p (tree ref1, || (end_struct_ref2 && compare_type_sizes (TREE_TYPE (end_struct_ref2), type1) >= 0)) { - refp = &ref2; + tree ref = ref2; while (true) { /* We walk from inner type to the outer types. If type we see is already too large to be part of type1, terminate the search. */ - int cmp = compare_type_sizes (type1, TREE_TYPE (*refp)); + int cmp = compare_type_sizes (type1, TREE_TYPE (ref)); if (cmp < 0 && (!end_struct_ref1 || compare_type_sizes (TREE_TYPE (end_struct_ref1), - TREE_TYPE (*refp)) < 0)) + TREE_TYPE (ref)) < 0)) break; /* If types may be of same size, see if we can decide about their equality. */ if (cmp == 0) { - same_p2 = same_type_for_tbaa (TREE_TYPE (*refp), type1); + same_p2 = same_type_for_tbaa (TREE_TYPE (ref), type1); if (same_p2 == 1) break; /* In case we can't decide whether types are same try to @@ -960,9 +965,9 @@ aliasing_component_refs_p (tree ref1, if (same_p2 == -1) maybe_match = true; } - if (!handled_component_p (*refp)) + if (!handled_component_p (ref)) break; - refp = &TREE_OPERAND (*refp, 0); + ref = TREE_OPERAND (ref, 0); } if (same_p2 == 1) { @@ -977,13 +982,13 @@ aliasing_component_refs_p (tree ref1, if (TREE_CODE (TREE_TYPE (base1)) == ARRAY_TYPE && (!TYPE_SIZE (TREE_TYPE (base1)) || TREE_CODE (TYPE_SIZE (TREE_TYPE (base1))) != INTEGER_CST - || (*refp == base2 && !ref2_is_decl))) + || (ref == base2 && !ref2_is_decl))) { ++alias_stats.aliasing_component_refs_p_may_alias; return true; } - get_ref_base_and_extent (*refp, &offadj, &sztmp, &msztmp, &reverse); + get_ref_base_and_extent (ref, &offadj, &sztmp, &msztmp, &reverse); offset2 -= offadj; get_ref_base_and_extent (base1, &offadj, &sztmp, &msztmp, &reverse); offset1 -= offadj; @@ -1005,28 +1010,28 @@ aliasing_component_refs_p (tree ref1, || (end_struct_ref1 && compare_type_sizes (TREE_TYPE (end_struct_ref1), type1) <= 0)) { - refp = &ref1; + tree ref = ref1; while (true) { - int cmp = compare_type_sizes (type2, TREE_TYPE (*refp)); + int cmp = compare_type_sizes (type2, TREE_TYPE (ref)); if (cmp < 0 && (!end_struct_ref2 || compare_type_sizes (TREE_TYPE (end_struct_ref2), - TREE_TYPE (*refp)) < 0)) + TREE_TYPE (ref)) < 0)) break; /* If types may be of same size, see if we can decide about their equality. */ if (cmp == 0) { - same_p1 = same_type_for_tbaa (TREE_TYPE (*refp), type2); + same_p1 = same_type_for_tbaa (TREE_TYPE (ref), type2); if (same_p1 == 1) break; if (same_p1 == -1) maybe_match = true; } - if (!handled_component_p (*refp)) + if (!handled_component_p (ref)) break; - refp = &TREE_OPERAND (*refp, 0); + ref = TREE_OPERAND (ref, 0); } if (same_p1 == 1) { @@ -1036,13 +1041,13 @@ aliasing_component_refs_p (tree ref1, if (TREE_CODE (TREE_TYPE (base2)) == ARRAY_TYPE && (!TYPE_SIZE (TREE_TYPE (base2)) || TREE_CODE (TYPE_SIZE (TREE_TYPE (base2))) != INTEGER_CST - || (*refp == base1 && !ref2_is_decl))) + || (ref == base1 && !ref2_is_decl))) { ++alias_stats.aliasing_component_refs_p_may_alias; return true; } - get_ref_base_and_extent (*refp, &offadj, &sztmp, &msztmp, &reverse); + get_ref_base_and_extent (ref, &offadj, &sztmp, &msztmp, &reverse); offset1 -= offadj; get_ref_base_and_extent (base2, &offadj, &sztmp, &msztmp, &reverse); offset2 -= offadj; -- 2.30.2