// Use --mlir-disable-threading so that the AA queries are serialized
// as well as its diagnostic output.
// RUN: fir-opt %s -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' -split-input-file --mlir-disable-threading 2>&1 | FileCheck %s

// CHECK-LABEL: Testing : "_QPtest1"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: NoAlias

// Generated from 
// subroutine test1(arrayA, arrayB, arrayC, N)
//   integer, dimension(:) :: arrayA, arrayB, arrayC
//   integer N
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine

func.func @_QPtest1(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arraya"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arrayb"}, %arg2: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arrayc"}, %arg3: !fir.ref<i32> {fir.bindc_name = "n"}) {
  %c1 = arith.constant 1 : index
  %c1_i64 = arith.constant 1 : i64
  %0 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QFtest1Eii"}
  %1 = fir.load %arg3 : !fir.ref<i32>
  %2 = fir.convert %1 : (i32) -> index
  %3 = fir.convert %c1 : (index) -> i32
  %4:2 = fir.do_loop %arg4 = %c1 to %2 step %c1 iter_args(%arg5 = %3) -> (index, i32) {
    fir.store %arg5 to %0 : !fir.ref<i32>
    %5 = fir.load %0 : !fir.ref<i32>
    %6 = fir.convert %5 : (i32) -> i64
    %7 = arith.subi %6, %c1_i64 : i64
    %8 = fir.coordinate_of %arg1, %7 : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %9 = fir.load %8 : !fir.ref<i32>
    %10 = fir.coordinate_of %arg0, %7 {test.ptr = "arraya(ii)"} : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %11 = fir.load %10 : !fir.ref<i32>
    %12 = arith.addi %9, %11 : i32
    %13 = fir.coordinate_of %arg2, %7 {test.ptr = "arrayc(ii)"} : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    fir.store %12 to %13 : !fir.ref<i32>
    %14 = arith.addi %arg4, %c1 : index
    %15 = fir.load %0 : !fir.ref<i32>
    %16 = arith.addi %15, %3 : i32
    fir.result %14, %16 : index, i32
  }
  fir.store %4#1 to %0 : !fir.ref<i32>
  return
}

// -----

// CHECK-LABEL: Testing : "_QPtest3"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: MayAlias

// subroutine test3(arrayA, arrayB, arrayC, N)
//   integer, dimension(:), target :: arrayA
//   integer, dimension(:) :: arrayB
//   integer, dimension(:), pointer :: arrayC
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine

func.func @_QPtest3(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arraya", fir.target}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arrayb"}, %arg2: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>> {fir.bindc_name = "arrayc"}, %arg3: !fir.ref<i32> {fir.bindc_name = "n"}) {
  %c1 = arith.constant 1 : index
  %c0 = arith.constant 0 : index
  %c1_i64 = arith.constant 1 : i64
  %0 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QFtest3Eii"}
  %1 = fir.load %arg3 : !fir.ref<i32>
  %2 = fir.convert %1 : (i32) -> index
  %3 = fir.convert %c1 : (index) -> i32
  %4:2 = fir.do_loop %arg4 = %c1 to %2 step %c1 iter_args(%arg5 = %3) -> (index, i32) {
    fir.store %arg5 to %0 : !fir.ref<i32>
    %5 = fir.load %0 : !fir.ref<i32>
    %6 = fir.convert %5 : (i32) -> i64
    %7 = arith.subi %6, %c1_i64 : i64
    %8 = fir.coordinate_of %arg1, %7 : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %9 = fir.load %8 : !fir.ref<i32>
    %10 = fir.coordinate_of %arg0, %7 {test.ptr = "arraya(ii)"} : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %11 = fir.load %10 : !fir.ref<i32>
    %12 = arith.addi %9, %11 : i32
    %13 = fir.load %arg2 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
    %14:3 = fir.box_dims %13, %c0 : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, index) -> (index, index, index)
    %15 = fir.convert %14#0 : (index) -> i64
    %16 = arith.subi %6, %15 : i64
    %17 = fir.coordinate_of %13, %16 {test.ptr = "arrayc(ii)"} : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, i64) -> !fir.ref<i32>
    fir.store %12 to %17 : !fir.ref<i32>
    %18 = arith.addi %arg4, %c1 : index
    %19 = fir.load %0 : !fir.ref<i32>
    %20 = arith.addi %19, %3 : i32
    fir.result %18, %20 : index, i32
  }
  fir.store %4#1 to %0 : !fir.ref<i32>
  return
}

// -----

// CHECK-LABEL: Testing : "_QMtest4Ptest"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: NoAlias

// module test4
//   integer, dimension(:), allocatable :: arrayA
//   integer, dimension(:), allocatable :: arrayB
//   integer, dimension(:), allocatable :: arrayC
//   integer :: N
// contains
// subroutine test
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine
// endmodule

fir.global @_QMtest4Earraya : !fir.box<!fir.heap<!fir.array<?xi32>>> 
fir.global @_QMtest4Earrayb : !fir.box<!fir.heap<!fir.array<?xi32>>> 
fir.global @_QMtest4Earrayc : !fir.box<!fir.heap<!fir.array<?xi32>>> 
fir.global @_QMtest4En : i32

func.func @_QMtest4Ptest() {
  %c1 = arith.constant 1 : index
  %c0 = arith.constant 0 : index
  %0 = fir.address_of(@_QMtest4Earraya) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %1 = fir.address_of(@_QMtest4Earrayb) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %2 = fir.address_of(@_QMtest4Earrayc) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %3 = fir.address_of(@_QMtest4En) : !fir.ref<i32>
  %4 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QMtest4FtestEii"}
  %5 = fir.load %3 : !fir.ref<i32>
  %6 = fir.convert %5 : (i32) -> index
  %7 = fir.convert %c1 : (index) -> i32
  %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) {
    fir.store %arg1 to %4 : !fir.ref<i32>
    %9 = fir.load %1 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %10:3 = fir.box_dims %9, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %11 = fir.box_addr %9 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %12 = fir.load %4 : !fir.ref<i32>
    %13 = fir.convert %12 : (i32) -> i64
    %14 = fir.convert %10#0 : (index) -> i64
    %15 = arith.subi %13, %14 : i64
    %16 = fir.coordinate_of %11, %15 : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %17 = fir.load %16 : !fir.ref<i32>
    %18 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %19:3 = fir.box_dims %18, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %20 = fir.box_addr %18 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %21 = fir.convert %19#0 : (index) -> i64
    %22 = arith.subi %13, %21 : i64
    %23 = fir.coordinate_of %20, %22 {test.ptr = "arraya(ii)"} : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %24 = fir.load %23 : !fir.ref<i32>
    %25 = arith.addi %17, %24 : i32
    %26 = fir.load %2 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %27:3 = fir.box_dims %26, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %28 = fir.box_addr %26 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %29 = fir.convert %27#0 : (index) -> i64
    %30 = arith.subi %13, %29 : i64
    %31 = fir.coordinate_of %28, %30 {test.ptr = "arrayc(ii)"} : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    fir.store %25 to %31 : !fir.ref<i32>
    %32 = arith.addi %arg0, %c1 : index
    %33 = fir.load %4 : !fir.ref<i32>
    %34 = arith.addi %33, %7 : i32
    fir.result %32, %34 : index, i32
  }
  fir.store %8#1 to %4 : !fir.ref<i32>
  return
}

// -----

// CHECK-LABEL: Testing : "_QMtest5Ptest"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: NoAlias

// module test5
//   integer, dimension(:), allocatable :: arrayA
//   integer, dimension(:), allocatable :: arrayB
//   integer, dimension(:), pointer :: arrayC
//   integer :: N
// contains
// subroutine test
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine
// endmodule

fir.global @_QMtest5Earraya : !fir.box<!fir.heap<!fir.array<?xi32>>> 
fir.global @_QMtest5Earrayb : !fir.box<!fir.heap<!fir.array<?xi32>>>
fir.global @_QMtest5Earrayc : !fir.box<!fir.ptr<!fir.array<?xi32>>>
fir.global @_QMtest5En : i32

func.func @_QMtest5Ptest() {
  %c1 = arith.constant 1 : index
  %c0 = arith.constant 0 : index
  %0 = fir.address_of(@_QMtest5Earraya) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %1 = fir.address_of(@_QMtest5Earrayb) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %2 = fir.address_of(@_QMtest5Earrayc) : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
  %3 = fir.address_of(@_QMtest5En) : !fir.ref<i32>
  %4 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QMtest5FtestEii"}
  %5 = fir.load %3 : !fir.ref<i32>
  %6 = fir.convert %5 : (i32) -> index
  %7 = fir.convert %c1 : (index) -> i32
  %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) {
    fir.store %arg1 to %4 : !fir.ref<i32>
    %9 = fir.load %1 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %10:3 = fir.box_dims %9, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %11 = fir.box_addr %9 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %12 = fir.load %4 : !fir.ref<i32>
    %13 = fir.convert %12 : (i32) -> i64
    %14 = fir.convert %10#0 : (index) -> i64
    %15 = arith.subi %13, %14 : i64
    %16 = fir.coordinate_of %11, %15 : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %17 = fir.load %16 : !fir.ref<i32>
    %18 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %19:3 = fir.box_dims %18, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %20 = fir.box_addr %18 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %21 = fir.convert %19#0 : (index) -> i64
    %22 = arith.subi %13, %21 : i64
    %23 = fir.coordinate_of %20, %22 {test.ptr = "arraya(ii)"} : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %24 = fir.load %23 : !fir.ref<i32>
    %25 = arith.addi %17, %24 : i32
    %26 = fir.load %2 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
    %27:3 = fir.box_dims %26, %c0 : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, index) -> (index, index, index)
    %28 = fir.convert %27#0 : (index) -> i64
    %29 = arith.subi %13, %28 : i64
    %30 = fir.coordinate_of %26, %29 {test.ptr = "arrayc(ii)"}  : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, i64) -> !fir.ref<i32>
    fir.store %25 to %30 : !fir.ref<i32>
    %31 = arith.addi %arg0, %c1 : index
    %32 = fir.load %4 : !fir.ref<i32>
    %33 = arith.addi %32, %7 : i32
    fir.result %31, %33 : index, i32
  }
  fir.store %8#1 to %4 : !fir.ref<i32>
  return
}

// -----

// CHECK-LABEL: Testing : "_QMtest6Ptest"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: MayAlias

// module test6
//   integer, dimension(:), allocatable, target :: arrayA
//   integer, dimension(:), allocatable :: arrayB
//   integer, dimension(:), pointer :: arrayC
//   integer :: N
// contains
// subroutine test
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine
// endmodule

fir.global @_QMtest6Earraya target : !fir.box<!fir.heap<!fir.array<?xi32>>> 
fir.global @_QMtest6Earrayb : !fir.box<!fir.heap<!fir.array<?xi32>>>
fir.global @_QMtest6Earrayc : !fir.box<!fir.ptr<!fir.array<?xi32>>>
fir.global @_QMtest6En : i32

func.func @_QMtest6Ptest() {
  %c1 = arith.constant 1 : index
  %c0 = arith.constant 0 : index
  %0 = fir.address_of(@_QMtest6Earraya) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %1 = fir.address_of(@_QMtest6Earrayb) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %2 = fir.address_of(@_QMtest6Earrayc) : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
  %3 = fir.address_of(@_QMtest6En) : !fir.ref<i32>
  %4 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QMtest6FtestEii"}
  %5 = fir.load %3 : !fir.ref<i32>
  %6 = fir.convert %5 : (i32) -> index
  %7 = fir.convert %c1 : (index) -> i32
  %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) {
    fir.store %arg1 to %4 : !fir.ref<i32>
    %9 = fir.load %1 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %10:3 = fir.box_dims %9, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %11 = fir.box_addr %9 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %12 = fir.load %4 : !fir.ref<i32>
    %13 = fir.convert %12 : (i32) -> i64
    %14 = fir.convert %10#0 : (index) -> i64
    %15 = arith.subi %13, %14 : i64
    %16 = fir.coordinate_of %11, %15 : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %17 = fir.load %16 : !fir.ref<i32>
    %18 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %19:3 = fir.box_dims %18, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %20 = fir.box_addr %18 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %21 = fir.convert %19#0 : (index) -> i64
    %22 = arith.subi %13, %21 : i64
    %23 = fir.coordinate_of %20, %22 {test.ptr = "arraya(ii)"} : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %24 = fir.load %23 : !fir.ref<i32>
    %25 = arith.addi %17, %24 : i32
    %26 = fir.load %2 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
    %27:3 = fir.box_dims %26, %c0 : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, index) -> (index, index, index)
    %28 = fir.convert %27#0 : (index) -> i64
    %29 = arith.subi %13, %28 : i64
    %30 = fir.coordinate_of %26, %29 {test.ptr = "arrayc(ii)"} : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, i64) -> !fir.ref<i32>
    fir.store %25 to %30 : !fir.ref<i32>
    %31 = arith.addi %arg0, %c1 : index
    %32 = fir.load %4 : !fir.ref<i32>
    %33 = arith.addi %32, %7 : i32
    fir.result %31, %33 : index, i32
  }
  fir.store %8#1 to %4 : !fir.ref<i32>
  return
}

// -----

// CHECK-LABEL: Testing : "_QMtest7Ptest"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: MayAlias

// module test7
//   integer, dimension(1000), target :: arrayA
//   integer, dimension(:), allocatable :: arrayB
//   integer, dimension(:), pointer :: arrayC
//   integer :: N
// contains
// subroutine test
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine
// endmodule

fir.global @_QMtest7Earraya target : !fir.array<1000xi32> 
fir.global @_QMtest7Earrayb : !fir.box<!fir.heap<!fir.array<?xi32>>> 
fir.global @_QMtest7Earrayc : !fir.box<!fir.ptr<!fir.array<?xi32>>> 
fir.global @_QMtest7En : i32 

func.func @_QMtest7Ptest() {
  %c1 = arith.constant 1 : index
  %c1_i64 = arith.constant 1 : i64
  %c0 = arith.constant 0 : index
  %0 = fir.address_of(@_QMtest7Earraya) : !fir.ref<!fir.array<1000xi32>>
  %1 = fir.address_of(@_QMtest7Earrayb) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %2 = fir.address_of(@_QMtest7Earrayc) : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
  %3 = fir.address_of(@_QMtest7En) : !fir.ref<i32>
  %4 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QMtest7FtestEii"}
  %5 = fir.load %3 : !fir.ref<i32>
  %6 = fir.convert %5 : (i32) -> index
  %7 = fir.convert %c1 : (index) -> i32
  %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) {
    fir.store %arg1 to %4 : !fir.ref<i32>
    %9 = fir.load %1 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %10:3 = fir.box_dims %9, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %11 = fir.box_addr %9 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %12 = fir.load %4 : !fir.ref<i32>
    %13 = fir.convert %12 : (i32) -> i64
    %14 = fir.convert %10#0 : (index) -> i64
    %15 = arith.subi %13, %14 : i64
    %16 = fir.coordinate_of %11, %15 : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %17 = fir.load %16 : !fir.ref<i32>
    %18 = arith.subi %13, %c1_i64 : i64
    %19 = fir.coordinate_of %0, %18 {test.ptr = "arraya(ii)"} : (!fir.ref<!fir.array<1000xi32>>, i64) -> !fir.ref<i32>
    %20 = fir.load %19 : !fir.ref<i32>
    %21 = arith.addi %17, %20 : i32
    %22 = fir.load %2 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
    %23:3 = fir.box_dims %22, %c0 : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, index) -> (index, index, index)
    %24 = fir.convert %23#0 : (index) -> i64
    %25 = arith.subi %13, %24 : i64
    %26 = fir.coordinate_of %22, %25 {test.ptr = "arrayc(ii)"} : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, i64) -> !fir.ref<i32>
    fir.store %21 to %26 : !fir.ref<i32>
    %27 = arith.addi %arg0, %c1 : index
    %28 = fir.load %4 : !fir.ref<i32>
    %29 = arith.addi %28, %7 : i32
    fir.result %27, %29 : index, i32
  }
  fir.store %8#1 to %4 : !fir.ref<i32>
  return
}

// -----

// CHECK-LABEL: Testing : "_QMtest8Ptest"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: NoAlias

// module test8
//   integer, dimension(1000) :: arrayA
//   integer, dimension(:), allocatable :: arrayB
//   integer, dimension(:), pointer :: arrayC
//   integer :: N
// contains
// subroutine test
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine
// endmodule

fir.global @_QMtest8Earraya : !fir.array<1000xi32> 
fir.global @_QMtest8Earrayb : !fir.box<!fir.heap<!fir.array<?xi32>>> 
fir.global @_QMtest8Earrayc : !fir.box<!fir.ptr<!fir.array<?xi32>>> 
fir.global @_QMtest8En : i32 

func.func @_QMtest8Ptest() {
  %c1 = arith.constant 1 : index
  %c1_i64 = arith.constant 1 : i64
  %c0 = arith.constant 0 : index
  %0 = fir.address_of(@_QMtest8Earraya) : !fir.ref<!fir.array<1000xi32>>
  %1 = fir.address_of(@_QMtest8Earrayb) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %2 = fir.address_of(@_QMtest8Earrayc) : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
  %3 = fir.address_of(@_QMtest8En) : !fir.ref<i32>
  %4 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QMtest8FtestEii"}
  %5 = fir.load %3 : !fir.ref<i32>
  %6 = fir.convert %5 : (i32) -> index
  %7 = fir.convert %c1 : (index) -> i32
  %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) {
    fir.store %arg1 to %4 : !fir.ref<i32>
    %9 = fir.load %1 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %10:3 = fir.box_dims %9, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %11 = fir.box_addr %9 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %12 = fir.load %4 : !fir.ref<i32>
    %13 = fir.convert %12 : (i32) -> i64
    %14 = fir.convert %10#0 : (index) -> i64
    %15 = arith.subi %13, %14 : i64
    %16 = fir.coordinate_of %11, %15 : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %17 = fir.load %16 : !fir.ref<i32>
    %18 = arith.subi %13, %c1_i64 : i64
    %19 = fir.coordinate_of %0, %18 {test.ptr = "arraya(ii)"} : (!fir.ref<!fir.array<1000xi32>>, i64) -> !fir.ref<i32>
    %20 = fir.load %19 : !fir.ref<i32>
    %21 = arith.addi %17, %20 : i32
    %22 = fir.load %2 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
    %23:3 = fir.box_dims %22, %c0 : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, index) -> (index, index, index)
    %24 = fir.convert %23#0 : (index) -> i64
    %25 = arith.subi %13, %24 : i64
    %26 = fir.coordinate_of %22, %25 {test.ptr = "arrayc(ii)"} : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, i64) -> !fir.ref<i32>
    fir.store %21 to %26 : !fir.ref<i32>
    %27 = arith.addi %arg0, %c1 : index
    %28 = fir.load %4 : !fir.ref<i32>
    %29 = arith.addi %28, %7 : i32
    fir.result %27, %29 : index, i32
  }
  fir.store %8#1 to %4 : !fir.ref<i32>
  return
}

// -----

// CHECK-LABEL: Testing : "_QMtest9Ptest"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: NoAlias

// module test9
//   integer, dimension(:), allocatable :: arrayB
//   integer, dimension(:), pointer :: arrayC
//   integer :: N
// contains
// subroutine test(arrayA)
//   integer, dimension(:) :: arrayA
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine
// endmodule

fir.global @_QMtest9Earrayb : !fir.box<!fir.heap<!fir.array<?xi32>>> 
fir.global @_QMtest9Earrayc : !fir.box<!fir.ptr<!fir.array<?xi32>>>
fir.global @_QMtest9En : i32

func.func @_QMtest9Ptest(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arraya"}) {
  %c1 = arith.constant 1 : index
  %c1_i64 = arith.constant 1 : i64
  %c0 = arith.constant 0 : index
  %0 = fir.address_of(@_QMtest9Earrayb) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %1 = fir.address_of(@_QMtest9Earrayc) : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
  %2 = fir.address_of(@_QMtest9En) : !fir.ref<i32>
  %3 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QMtest9FtestEii"}
  %4 = fir.load %2 : !fir.ref<i32>
  %5 = fir.convert %4 : (i32) -> index
  %6 = fir.convert %c1 : (index) -> i32
  %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) {
    fir.store %arg2 to %3 : !fir.ref<i32>
    %8 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %9:3 = fir.box_dims %8, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %10 = fir.box_addr %8 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %11 = fir.load %3 : !fir.ref<i32>
    %12 = fir.convert %11 : (i32) -> i64
    %13 = fir.convert %9#0 : (index) -> i64
    %14 = arith.subi %12, %13 : i64
    %15 = fir.coordinate_of %10, %14 : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %16 = fir.load %15 : !fir.ref<i32>
    %17 = arith.subi %12, %c1_i64 : i64
    %18 = fir.coordinate_of %arg0, %17 {test.ptr = "arraya(ii)"} : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %19 = fir.load %18 : !fir.ref<i32>
    %20 = arith.addi %16, %19 : i32
    %21 = fir.load %1 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
    %22:3 = fir.box_dims %21, %c0 : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, index) -> (index, index, index)
    %23 = fir.convert %22#0 : (index) -> i64
    %24 = arith.subi %12, %23 : i64
    %25 = fir.coordinate_of %21, %24 {test.ptr = "arrayc(ii)"} : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, i64) -> !fir.ref<i32>
    fir.store %20 to %25 : !fir.ref<i32>
    %26 = arith.addi %arg1, %c1 : index
    %27 = fir.load %3 : !fir.ref<i32>
    %28 = arith.addi %27, %6 : i32
    fir.result %26, %28 : index, i32
  }
  fir.store %7#1 to %3 : !fir.ref<i32>
  return
}

// -----

// CHECK-LABEL: Testing : "_QMtest10Ptest"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: MayAlias

// module test10
//   integer, dimension(:), allocatable :: arrayB
//   integer, dimension(:), pointer :: arrayC
//   integer :: N
// contains
// subroutine test(arrayA)
//   integer, dimension(:), target :: arrayA
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine
// endmodule

fir.global @_QMtest10Earrayb : !fir.box<!fir.heap<!fir.array<?xi32>>> 
fir.global @_QMtest10Earrayc : !fir.box<!fir.ptr<!fir.array<?xi32>>> 
fir.global @_QMtest10En : i32

func.func @_QMtest10Ptest(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arraya", fir.target}) {
  %c1 = arith.constant 1 : index
  %c1_i64 = arith.constant 1 : i64
  %c0 = arith.constant 0 : index
  %0 = fir.address_of(@_QMtest10Earrayb) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %1 = fir.address_of(@_QMtest10Earrayc) : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
  %2 = fir.address_of(@_QMtest10En) : !fir.ref<i32>
  %3 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QMtest10FtestEii"}
  %4 = fir.load %2 : !fir.ref<i32>
  %5 = fir.convert %4 : (i32) -> index
  %6 = fir.convert %c1 : (index) -> i32
  %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) {
    fir.store %arg2 to %3 : !fir.ref<i32>
    %8 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %9:3 = fir.box_dims %8, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %10 = fir.box_addr %8 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %11 = fir.load %3 : !fir.ref<i32>
    %12 = fir.convert %11 : (i32) -> i64
    %13 = fir.convert %9#0 : (index) -> i64
    %14 = arith.subi %12, %13 : i64
    %15 = fir.coordinate_of %10, %14 : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %16 = fir.load %15 : !fir.ref<i32>
    %17 = arith.subi %12, %c1_i64 : i64
    %18 = fir.coordinate_of %arg0, %17 {test.ptr = "arraya(ii)"} : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %19 = fir.load %18 : !fir.ref<i32>
    %20 = arith.addi %16, %19 : i32
    %21 = fir.load %1 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
    %22:3 = fir.box_dims %21, %c0 : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, index) -> (index, index, index)
    %23 = fir.convert %22#0 : (index) -> i64
    %24 = arith.subi %12, %23 : i64
    %25 = fir.coordinate_of %21, %24 {test.ptr = "arrayc(ii)"} : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, i64) -> !fir.ref<i32>
    fir.store %20 to %25 : !fir.ref<i32>
    %26 = arith.addi %arg1, %c1 : index
    %27 = fir.load %3 : !fir.ref<i32>
    %28 = arith.addi %27, %6 : i32
    fir.result %26, %28 : index, i32
  }
  fir.store %7#1 to %3 : !fir.ref<i32>
  return
}

// -----

// CHECK-LABEL: Testing : "_QMtest11Ptest"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: MayAlias

// module test11
//   integer, dimension(:), allocatable :: arrayB
//   integer, dimension(1000), target :: arrayC
//   integer :: N
// contains
// subroutine test(arrayA)
//   integer, dimension(:), target :: arrayA
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine
// endmodule

fir.global @_QMtest11Earrayb : !fir.box<!fir.heap<!fir.array<?xi32>>> 
fir.global @_QMtest11Earrayc target : !fir.array<1000xi32> 
fir.global @_QMtest11En : i32 

func.func @_QMtest11Ptest(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arraya", fir.target}) {
  %c1 = arith.constant 1 : index
  %c1_i64 = arith.constant 1 : i64
  %c0 = arith.constant 0 : index
  %0 = fir.address_of(@_QMtest11Earrayb) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %1 = fir.address_of(@_QMtest11Earrayc) : !fir.ref<!fir.array<1000xi32>>
  %2 = fir.address_of(@_QMtest11En) : !fir.ref<i32>
  %3 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QMtest11FtestEii"}
  %4 = fir.load %2 : !fir.ref<i32>
  %5 = fir.convert %4 : (i32) -> index
  %6 = fir.convert %c1 : (index) -> i32
  %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) {
    fir.store %arg2 to %3 : !fir.ref<i32>
    %8 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %9:3 = fir.box_dims %8, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %10 = fir.box_addr %8 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %11 = fir.load %3 : !fir.ref<i32>
    %12 = fir.convert %11 : (i32) -> i64
    %13 = fir.convert %9#0 : (index) -> i64
    %14 = arith.subi %12, %13 : i64
    %15 = fir.coordinate_of %10, %14 : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %16 = fir.load %15 : !fir.ref<i32>
    %17 = arith.subi %12, %c1_i64 : i64
    %18 = fir.coordinate_of %arg0, %17 {test.ptr = "arraya(ii)"} : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %19 = fir.load %18 : !fir.ref<i32>
    %20 = arith.addi %16, %19 : i32
    %21 = fir.coordinate_of %1, %17 {test.ptr = "arrayc(ii)"} : (!fir.ref<!fir.array<1000xi32>>, i64) -> !fir.ref<i32>
    fir.store %20 to %21 : !fir.ref<i32>
    %22 = arith.addi %arg1, %c1 : index
    %23 = fir.load %3 : !fir.ref<i32>
    %24 = arith.addi %23, %6 : i32
    fir.result %22, %24 : index, i32
  }
  fir.store %7#1 to %3 : !fir.ref<i32>
  return
}


// -----

// CHECK-LABEL: Testing : "_QMtest12Ptest"
// CHECK: arraya(ii)#0 <-> arrayc(ii)#0: NoAlias

// module test12
//   integer, dimension(:), allocatable :: arrayB
//   integer, dimension(1000) :: arrayC
//   integer :: N
// contains
// subroutine test(arrayA)
//   integer, dimension(:), target :: arrayA
//   do ii = 1, N
//     arrayC(ii) = arrayB(ii) + arrayA(ii)
//   end do
// end subroutine
// endmodule

fir.global @_QMtest12Earrayb : !fir.box<!fir.heap<!fir.array<?xi32>>>
fir.global @_QMtest12Earrayc : !fir.array<1000xi32> 
fir.global @_QMtest12En : i32

func.func @_QMtest12Ptest(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arraya", fir.target}) {
  %c1 = arith.constant 1 : index
  %c1_i64 = arith.constant 1 : i64
  %c0 = arith.constant 0 : index
  %0 = fir.address_of(@_QMtest12Earrayb) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
  %1 = fir.address_of(@_QMtest12Earrayc) : !fir.ref<!fir.array<1000xi32>>
  %2 = fir.address_of(@_QMtest12En) : !fir.ref<i32>
  %3 = fir.alloca i32 {bindc_name = "ii", uniq_name = "_QMtest12FtestEii"}
  %4 = fir.load %2 : !fir.ref<i32>
  %5 = fir.convert %4 : (i32) -> index
  %6 = fir.convert %c1 : (index) -> i32
  %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) {
    fir.store %arg2 to %3 : !fir.ref<i32>
    %8 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
    %9:3 = fir.box_dims %8, %c0 : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
    %10 = fir.box_addr %8 : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
    %11 = fir.load %3 : !fir.ref<i32>
    %12 = fir.convert %11 : (i32) -> i64
    %13 = fir.convert %9#0 : (index) -> i64
    %14 = arith.subi %12, %13 : i64
    %15 = fir.coordinate_of %10, %14 : (!fir.heap<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %16 = fir.load %15 : !fir.ref<i32>
    %17 = arith.subi %12, %c1_i64 : i64
    %18 = fir.coordinate_of %arg0, %17 {test.ptr = "arraya(ii)"} : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
    %19 = fir.load %18 : !fir.ref<i32>
    %20 = arith.addi %16, %19 : i32
    %21 = fir.coordinate_of %1, %17 {test.ptr = "arrayc(ii)"} : (!fir.ref<!fir.array<1000xi32>>, i64) -> !fir.ref<i32>
    fir.store %20 to %21 : !fir.ref<i32>
    %22 = arith.addi %arg1, %c1 : index
    %23 = fir.load %3 : !fir.ref<i32>
    %24 = arith.addi %23, %6 : i32
    fir.result %22, %24 : index, i32
  }
  fir.store %7#1 to %3 : !fir.ref<i32>
  return
}