> On Mon, 17 Jun 2019, Jan Hubicka wrote:
>
> > Hi,
> > this is patch for aliasing_component_refs_p and VCE.
> > I also turned the refp to ref, but there are no changes relative
> > to that.
> > Bootstrapped/regtested x86_64-linux, OK?
>
> OK.
>
> Bonus points for wrong-code testcases involving these... like
> the following which doesn't fail for some reason:
We punt on same_type_for_tbaa on arrays so the aliasing_component_refs_p
thinks that int and int[2] possibly match and gives up :)
Honza
>
> struct S { int i; int j[2]; };
>
> __GIMPLE(startwith("fre1")) int foo(struct S *x, struct S *y)
> {
> int _1;
> x->j[0] = 1;
> __VIEW_CONVERT <struct S> (__MEM <int[2]> ((int(*)[2])y + 4)).i = 0;
> _1 = x->j[0];
> return _1;
> }
>
> int main()
> {
> struct S s;
> if (foo (&s, &s) != 0)
> __builtin_abort ();
> return 0;
> }
>
> Thanks,
> Richard.
>
> > Honza
> >
> > * tree-ssa-alias.c (aliasing_component_refs_p): Consider only
> > the access path from base to first VIEW_CONVERT_EXPR or
> > BIT_FIELD_REF.
> > Index: tree-ssa-alias.c
> > ===================================================================
> > --- tree-ssa-alias.c (revision 272381)
> > +++ tree-ssa-alias.c (working copy)
> > @@ -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;
> >
>
> --
> Richard Biener <rguent...@suse.de>
> SUSE Linux GmbH, Maxfeldstrasse 5, 90409 Nuernberg, Germany;
> GF: Felix Imendörffer, Mary Higgins, Sri Rasiah; HRB 21284 (AG Nürnberg)
