[Bug tree-optimization/98674] [10/11] Regression vectorizer failed for compilation time alias

["rguenth at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98674

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2021-01-14
                 CC|                            |rguenth at gcc dot gnu.org,
                   |                            |rsandifo at gcc dot gnu.org
     Ever confirmed|0                           |1

--- Comment #1 from Richard Biener <rguenth at gcc dot gnu.org> ---
(compute_affine_dependence
  stmt_a: load_dst_23 = MEM[(short int *)p_21];
  stmt_b: *p_21 = _8;
) -> dependence analysis failed
x.c:1:6: missed:   versioning for alias required: can't determine dependence
between MEM[(short int *)p_21] and *p_21
consider run-time aliasing test between MEM[(short int *)p_21] and *p_21

so the issue is that dependence analysis fails.  A dependence distance of
zero would be OK.  Above we see two different base objects, one accesses
the ref as 'short int' and one as 'unsigned short int' (but with
short int alias type).  We're doing

  bool same_base_p = (full_seq.start_a + full_seq.length == num_dimensions_a
                      && full_seq.start_b + full_seq.length == num_dimensions_b
                      && DR_UNCONSTRAINED_BASE (a) == DR_UNCONSTRAINED_BASE (b)
                      && operand_equal_p (base_a, base_b, OEP_ADDRESS_OF)
                      && types_compatible_p (TREE_TYPE (base_a),
                                             TREE_TYPE (base_b))
                      && (!loop_nest.exists ()
                          || (object_address_invariant_in_loop_p
                              (loop_nest[0], base_a))));

and "fail" the types_compatible_p test which for non-aggregate types is
probably too strict and could be relaxed to at least consider
signed/unsigned type variants as the same.  Maybe for non-aggregate
types just compare the mode.

Richard, you refactored this code last?

For example

diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index 394470af757..1853f4b4a07 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -3272,8 +3272,11 @@ initialize_data_dependence_relation (struct
data_reference *a,
                      && full_seq.start_b + full_seq.length == num_dimensions_b
                      && DR_UNCONSTRAINED_BASE (a) == DR_UNCONSTRAINED_BASE (b)
                      && operand_equal_p (base_a, base_b, OEP_ADDRESS_OF)
-                     && types_compatible_p (TREE_TYPE (base_a),
-                                            TREE_TYPE (base_b))
+                     && ((!AGGREGATE_TYPE_P (TREE_TYPE (base_a))
+                          && !AGGREGATE_TYPE_P (TREE_TYPE (base_b))
+                          && TYPE_MODE (TREE_TYPE (base_a)) == TYPE_MODE
(TREE_TYPE (base_b)))
+                         || types_compatible_p (TREE_TYPE (base_a),
+                                                TREE_TYPE (base_b)))
                      && (!loop_nest.exists ()
                          || (object_address_invariant_in_loop_p
                              (loop_nest[0], base_a))));

makes this vectorized but in the end the same_base_p check is supposed to
verify whether access functions generated are comparable.