mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-16 07:36:33 +00:00
575a648306
Add support for fir.box_addr, fir.array_corr, fir.coordinate, fir.embox, fir.rebox and fir.load. 1) Through the use of boolean `followBoxAddr` determine whether the analysis should apply to the address of the box or the address wrapped by the box. 2) Some asserts have been removed to allow for more SourceKinds though the flow, in a particular SourceKind::Direct 3) getSource was a public method but the returned type (SourceKind) was not public making it impossible to be called publicly 4) About 12 tests have been added to check for real Fortran scenarios 5) More tests will be added with HLFIR 6) A few TODOs have been identified and will need to be addressed in follow-up patches. I felt that more changes would increase the complexity of the patch.
672 lines
29 KiB
Plaintext
672 lines
29 KiB
Plaintext
// 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
|
|
}
|
|
|