// 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
}
Codebase Browser
llvm