Do not assume pointers cannot alias arrays of different types

As added in the comment, the assumption that a pointer of a certain type
cannot alias an array of a different type is tricky.
First, it is wrong in general currently because equivalence uses
pointer aliasing for its aliasing, and the any type can alias any
other types.
Then, in the normal pointer case, it is at least possible to have
complex/real overlap starting with F2008 introduction of %RE/%IM,
and in general with derived types and there component types.
Although one should note that not all compilers are very carefully
here.

Complex/Real overlap example:

```
module m
contains
  subroutine foo(p, x)
    real, target :: x(:)
    real, pointer :: p(:)
    p => x
  end subroutine
end module

  use :: m
  real, pointer :: real_pointer(:)
  complex, target :: complex_target(4) = [(1., 1.), (2., 2.), (3., 3.), (4., 4.)]
  call foo(real_pointer, complex_target%re)
  real_pointer = abs(complex_target(4:1:-1))
  print *, real_pointer
end
```

- ifort, gfortran (need >= 9.3 to support %re), and Nagfor all compile and
assume potential overlap printing `5.6568542   4.2426405   2.8284271   1.4142135`.
- nvfortran hits an ICE (probably caused by passing the complex_target%re).
- xlf ignore the overlap and prints `5.656854153 4.242640495 4.690415382 5.744562626`.

Derived/Part overlap example:

```
  type t
    integer :: i
  end type
  integer, pointer :: integer_pointer(:)
  type(t), target :: derived_target(4) = [t(1), t(2), t(3), t(4)]
  integer_pointer => derived_target%i
  derived_target%i = integer_pointer(4:1:-1)
  print *, integer_pointer
end
```
- Nvfortran and Nagfor assumes it can overlap and print `4 3 2 1`
- gfortran, xlf and ifort assume no overlap and prints `4 3 3 4`

Hence, once the equivalence aliasing is handled another way, we may want
to dig more into this and find the correct requirement here. For now,
assumes we need to be as strict as the stricter compilers out there.

Author: jeanPerier

flang/lib/Optimizer/Transforms/ArrayValueCopy.cpp

@@ -434,23 +434,26 @@ static bool conflictOnLoad(llvm::ArrayRef<mlir::Operation *> reach,
   mlir::Value load;
   mlir::Value addr = st.memref();
   const bool storeHasPointerType = hasPointerType(addr.getType());
-  mlir::Type stEleTy =
-      fir::unwrapSequenceType(fir::unwrapPassByRefType(addr.getType()));
   for (auto *op : reach)
     if (auto ld = mlir::dyn_cast<ArrayLoadOp>(op)) {
       mlir::Type ldTy = ld.memref().getType();
-      mlir::Type ldEleTy =
-          fir::unwrapSequenceType(fir::unwrapPassByRefType(ldTy));
       if (ld.memref() == addr) {
         if (ld.getResult() != st.original())
           return true;
         if (load)
           // TODO: only return if the loads may overlap (look at slices if any).
           return true;
         load = ld;
-      } else if ((hasPointerType(ldTy) || storeHasPointerType) &&
-                 stEleTy == ldEleTy) {
+      } else if ((hasPointerType(ldTy) || storeHasPointerType)) {
         // TODO: Use target attribute to restrict this case further.
+        // TODO: Check if types can also allow ruling out some cases. For now,
+        // the fact that equivalences is using pointer attribute to enforce
+        // aliasing is preventing any attempt to do so, and in general, it may
+        // be wrong to use this if any of the types is a complex or a derived
+        // for which it is possible to create a pointer to a part with a
+        // different type than the whole, although this deserve some more
+        // investigation because existing compiler behavior seem to diverge
+        // here.
         return true;
       }
     }

flang/test/Fir/array-copies-pointers.f90

@@ -87,3 +87,55 @@
   fir.array_merge_store %3, %4 to %arg1 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ptr<!fir.array<100xf32>>
   return
 }
+
+// Test derived_target(:)%i = integer_pointer(:)
+// The integer pointer may be aliasing the derived target component.
+// CHECK-LABEL: func @derived_whose_component_may_be_aliased
+// CHECK: fir.allocmem !fir.array<4x!fir.type<some_type{i:i32}>>
+func @derived_whose_component_may_be_aliased(%arg0: !fir.box<!fir.array<4x!fir.type<some_type{i:i32}>>> {fir.target}, %arg1: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) {
+  %c4 = arith.constant 4 : index
+  %0 = fir.field_index i, !fir.type<some_type{i:i32}>
+  %c1 = arith.constant 1 : index
+  %1 = fir.slice %c1, %c4, %c1 path %0 : (index, index, index, !fir.field) -> !fir.slice<1>
+  %2 = fir.array_load %arg0 [%1] : (!fir.box<!fir.array<4x!fir.type<some_type{i:i32}>>>, !fir.slice<1>) -> !fir.array<4xi32>
+  %3 = fir.load %arg1 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
+  %c0 = arith.constant 0 : index
+  %4:3 = fir.box_dims %3, %c0 : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, index) -> (index, index, index)
+  %5 = fir.shift %4#0 : (index) -> !fir.shift<1>
+  %6 = fir.array_load %3(%5) : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, !fir.shift<1>) -> !fir.array<?xi32>
+  %7 = arith.subi %c4, %c1 : index
+  %8 = fir.do_loop %arg2 = %c0 to %7 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<4xi32>) {
+    %9 = fir.array_fetch %6, %arg2 : (!fir.array<?xi32>, index) -> i32
+    %10 = fir.array_update %arg3, %9, %arg2 : (!fir.array<4xi32>, i32, index) -> !fir.array<4xi32>
+    fir.result %10 : !fir.array<4xi32>
+  }
+  fir.array_merge_store %2, %8 to %arg0[%1] : !fir.array<4xi32>, !fir.array<4xi32>, !fir.box<!fir.array<4x!fir.type<some_type{i:i32}>>>, !fir.slice<1>
+  return
+}
+
+// Test real_target = complex_target(:)%re
+// The real pointer may be aliasing the complex real part.
+// CHECK-LABEL: func @complex_real_aliasing
+// CHECK: fir.allocmem !fir.array<?xf32>
+func @complex_real_aliasing(%arg0: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, %arg1: !fir.ref<!fir.array<4x!fir.complex<4>>> {fir.target}) {
+  %c4 = arith.constant 4 : index
+  %0 = fir.load %arg0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
+  %c0 = arith.constant 0 : index
+  %1:3 = fir.box_dims %0, %c0 : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
+  %2 = fir.shift %1#0 : (index) -> !fir.shift<1>
+  %3 = fir.array_load %0(%2) : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.shift<1>) -> !fir.array<?xf32>
+  %c0_i32 = arith.constant 0 : i32
+  %4 = fir.shape %c4 : (index) -> !fir.shape<1>
+  %c1 = arith.constant 1 : index
+  %5 = fir.slice %c1, %c4, %c1 path %c0_i32 : (index, index, index, i32) -> !fir.slice<1>
+  %6 = fir.array_load %arg1(%4) [%5] : (!fir.ref<!fir.array<4x!fir.complex<4>>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<4xf32>
+  %7 = arith.subi %c4, %c1 : index
+  %8 = fir.do_loop %arg2 = %c0 to %7 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<?xf32>) {
+    %9 = fir.array_fetch %6, %arg2 : (!fir.array<4xf32>, index) -> f32
+    %10 = fir.array_update %arg3, %9, %arg2 : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
+    fir.result %10 : !fir.array<?xf32>
+  }
+  fir.array_merge_store %3, %8 to %0 : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.ptr<!fir.array<?xf32>>>
+  return
+}
+