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:
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 <[email protected]>
SUSE Linux GmbH, Maxfeldstrasse 5, 90409 Nuernberg, Germany;
GF: Felix Imendörffer, Mary Higgins, Sri Rasiah; HRB 21284 (AG Nürnberg)
